@highway1/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1876 @@
+import * as ed25519 from '@noble/ed25519';
+import { base58btc } from 'multiformats/bases/base58';
+import { createLibp2p } from 'libp2p';
+import { tcp } from '@libp2p/tcp';
+import { noise } from '@chainsafe/libp2p-noise';
+import { mplex } from '@libp2p/mplex';
+import { kadDHT, passthroughMapper, removePrivateAddressesMapper } from '@libp2p/kad-dht';
+import { bootstrap } from '@libp2p/bootstrap';
+import { identify } from '@libp2p/identify';
+import { ping } from '@libp2p/ping';
+import { circuitRelayTransport, circuitRelayServer } from '@libp2p/circuit-relay-v2';
+import Ajv from 'ajv';
+import { encode, decode } from 'cbor-x';
+import { fromString } from 'uint8arrays/from-string';
+import lunr from 'lunr';
+import Fuse from 'fuse.js';
+import { peerIdFromString } from '@libp2p/peer-id';
+import { multiaddr } from '@multiformats/multiaddr';
+import { Level } from 'level';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+
+// src/identity/keys.ts
+
+// src/utils/errors.ts
+var ClawiverseError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ClawiverseError";
+  }
+};
+var IdentityError = class extends ClawiverseError {
+  constructor(message, details) {
+    super(message, "IDENTITY_ERROR", details);
+    this.name = "IdentityError";
+  }
+};
+var TransportError = class extends ClawiverseError {
+  constructor(message, details) {
+    super(message, "TRANSPORT_ERROR", details);
+    this.name = "TransportError";
+  }
+};
+var DiscoveryError = class extends ClawiverseError {
+  constructor(message, details) {
+    super(message, "DISCOVERY_ERROR", details);
+    this.name = "DiscoveryError";
+  }
+};
+var MessagingError = class extends ClawiverseError {
+  constructor(message, details) {
+    super(message, "MESSAGING_ERROR", details);
+    this.name = "MessagingError";
+  }
+};
+
+// src/identity/keys.ts
+async function generateKeyPair() {
+  try {
+    const privateKey = ed25519.utils.randomPrivateKey();
+    const publicKey = await ed25519.getPublicKeyAsync(privateKey);
+    return {
+      publicKey,
+      privateKey
+    };
+  } catch (error) {
+    throw new IdentityError("Failed to generate key pair", error);
+  }
+}
+async function sign(message, privateKey) {
+  try {
+    return await ed25519.signAsync(message, privateKey);
+  } catch (error) {
+    throw new IdentityError("Failed to sign message", error);
+  }
+}
+async function verify(signature, message, publicKey) {
+  try {
+    return await ed25519.verifyAsync(signature, message, publicKey);
+  } catch (error) {
+    throw new IdentityError("Failed to verify signature", error);
+  }
+}
+function exportKeyPair(keyPair) {
+  return {
+    publicKey: Buffer.from(keyPair.publicKey).toString("hex"),
+    privateKey: Buffer.from(keyPair.privateKey).toString("hex")
+  };
+}
+function importKeyPair(exported) {
+  return {
+    publicKey: new Uint8Array(Buffer.from(exported.publicKey, "hex")),
+    privateKey: new Uint8Array(Buffer.from(exported.privateKey, "hex"))
+  };
+}
+function deriveDID(publicKey) {
+  try {
+    const encoded = base58btc.encode(publicKey);
+    return `did:clawiverse:${encoded}`;
+  } catch (error) {
+    throw new IdentityError("Failed to derive DID", error);
+  }
+}
+function extractPublicKey(did) {
+  if (!did.startsWith("did:clawiverse:")) {
+    throw new IdentityError("Invalid DID format: must start with did:clawiverse:");
+  }
+  try {
+    const encoded = did.replace("did:clawiverse:", "");
+    return base58btc.decode(encoded);
+  } catch (error) {
+    throw new IdentityError("Failed to extract public key from DID", error);
+  }
+}
+function validateDID(did) {
+  if (!did.startsWith("did:clawiverse:")) {
+    return false;
+  }
+  try {
+    const encoded = did.replace("did:clawiverse:", "");
+    base58btc.decode(encoded);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/identity/signer.ts
+async function signMessage(payload, privateKey, publicKey) {
+  try {
+    const signature = await sign(payload, privateKey);
+    const signer = deriveDID(publicKey);
+    return {
+      payload,
+      signature,
+      signer
+    };
+  } catch (error) {
+    throw new IdentityError("Failed to sign message", error);
+  }
+}
+async function verifyMessage(signedMessage, expectedPublicKey) {
+  try {
+    const expectedDID = deriveDID(expectedPublicKey);
+    if (signedMessage.signer !== expectedDID) {
+      return false;
+    }
+    return await verify(
+      signedMessage.signature,
+      signedMessage.payload,
+      expectedPublicKey
+    );
+  } catch (error) {
+    throw new IdentityError("Failed to verify message", error);
+  }
+}
+
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class {
+  level;
+  prefix;
+  constructor(prefix, level = 1 /* INFO */) {
+    this.prefix = prefix;
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug(`[${this.prefix}] DEBUG:`, message, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.info(`[${this.prefix}] INFO:`, message, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(`[${this.prefix}] WARN:`, message, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(`[${this.prefix}] ERROR:`, message, ...args);
+    }
+  }
+};
+var createLogger = (prefix, level) => {
+  return new Logger(prefix, level);
+};
+
+// src/transport/node.ts
+var logger = createLogger("transport");
+async function createNode(config) {
+  try {
+    const {
+      listenAddresses = ["/ip4/0.0.0.0/tcp/0"],
+      bootstrapPeers = [],
+      enableDHT = true,
+      allowPrivateAddresses = false,
+      enableRelay = false,
+      privateKey
+    } = config;
+    const libp2pConfig = {
+      addresses: {
+        listen: listenAddresses
+      },
+      ...privateKey ? { privateKey } : {},
+      transports: [
+        tcp(),
+        circuitRelayTransport()
+      ],
+      connectionEncrypters: [noise()],
+      streamMuxers: [mplex()],
+      services: {
+        identify: identify(),
+        ping: ping()
+      }
+    };
+    if (enableRelay) {
+      libp2pConfig.services.relay = circuitRelayServer();
+    }
+    if (enableDHT) {
+      libp2pConfig.services.dht = kadDHT({
+        clientMode: false,
+        peerInfoMapper: allowPrivateAddresses ? passthroughMapper : removePrivateAddressesMapper,
+        validators: {
+          clawiverse: async () => {
+          }
+        },
+        selectors: {
+          clawiverse: () => 0
+        }
+      });
+    }
+    if (bootstrapPeers.length > 0) {
+      libp2pConfig.peerDiscovery = [
+        bootstrap({
+          list: bootstrapPeers
+        })
+      ];
+    }
+    const libp2p = await createLibp2p(libp2pConfig);
+    logger.info("Libp2p node created");
+    return {
+      libp2p,
+      start: async () => {
+        await libp2p.start();
+        logger.info("Node started", {
+          peerId: libp2p.peerId.toString(),
+          addresses: libp2p.getMultiaddrs().map((ma) => ma.toString()),
+          relay: enableRelay
+        });
+      },
+      stop: async () => {
+        await libp2p.stop();
+        logger.info("Node stopped");
+      },
+      getMultiaddrs: () => {
+        return libp2p.getMultiaddrs().map((ma) => ma.toString());
+      },
+      getPeerId: () => {
+        return libp2p.peerId.toString();
+      }
+    };
+  } catch (error) {
+    throw new TransportError("Failed to create transport node", error);
+  }
+}
+
+// src/discovery/agent-card-types.ts
+function isLegacyCard(card) {
+  return Array.isArray(card.capabilities) && card.capabilities.length > 0 && typeof card.capabilities[0] === "string";
+}
+function upgradeLegacyCard(legacy) {
+  return {
+    ...legacy,
+    capabilities: legacy.capabilities.map((cap) => ({
+      id: cap,
+      name: cap,
+      description: `Capability: ${cap}`
+    }))
+  };
+}
+function downgradeToLegacyCard(card) {
+  const { "@context": _, trust: __, ...rest } = card;
+  return {
+    ...rest,
+    capabilities: card.capabilities.map((cap) => cap.id)
+  };
+}
+
+// src/discovery/agent-card.ts
+var legacyAgentCardSchema = {
+  type: "object",
+  properties: {
+    did: { type: "string", pattern: "^did:clawiverse:[1-9A-HJ-NP-Za-km-z]+$" },
+    name: { type: "string", minLength: 1, maxLength: 100 },
+    description: { type: "string", maxLength: 500 },
+    version: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+$" },
+    capabilities: {
+      type: "array",
+      items: { type: "string" },
+      minItems: 0,
+      maxItems: 50
+    },
+    endpoints: {
+      type: "array",
+      items: { type: "string" },
+      minItems: 0,
+      maxItems: 10
+    },
+    peerId: { type: "string", nullable: true },
+    metadata: {
+      type: "object",
+      nullable: true,
+      required: []
+    },
+    timestamp: { type: "number" }
+  },
+  required: ["did", "name", "description", "version", "capabilities", "endpoints", "timestamp"],
+  additionalProperties: false
+};
+var ajv = new Ajv();
+var validateLegacySchema = ajv.compile(legacyAgentCardSchema);
+function createAgentCard(did, name, description, capabilities, endpoints = [], peerId, metadata) {
+  return {
+    did,
+    name,
+    description,
+    version: "1.0.0",
+    capabilities,
+    endpoints,
+    peerId,
+    metadata,
+    timestamp: Date.now()
+  };
+}
+function createLegacyAgentCard(did, name, description, capabilities, endpoints = [], peerId, metadata) {
+  return {
+    did,
+    name,
+    description,
+    version: "1.0.0",
+    capabilities,
+    endpoints,
+    peerId,
+    metadata,
+    timestamp: Date.now()
+  };
+}
+function validateAgentCard(card) {
+  if (typeof card !== "object" || card === null) {
+    return false;
+  }
+  const c = card;
+  if (typeof c.signature !== "string") {
+    return false;
+  }
+  if (isLegacyCard(c)) {
+    return validateLegacySchema(c);
+  }
+  return typeof c.did === "string" && typeof c.name === "string" && typeof c.description === "string" && typeof c.version === "string" && Array.isArray(c.capabilities) && Array.isArray(c.endpoints) && typeof c.timestamp === "number";
+}
+async function signAgentCard(card, signFn) {
+  try {
+    const cardJson = JSON.stringify(card);
+    const cardBytes = new TextEncoder().encode(cardJson);
+    const signature = await signFn(cardBytes);
+    return {
+      ...card,
+      signature: Buffer.from(signature).toString("hex")
+    };
+  } catch (error) {
+    throw new DiscoveryError("Failed to sign Agent Card", error);
+  }
+}
+async function verifyAgentCard(card, verifyFn) {
+  try {
+    const { signature, ...cardWithoutSig } = card;
+    const cardJson = JSON.stringify(cardWithoutSig);
+    const cardBytes = new TextEncoder().encode(cardJson);
+    const signatureBytes = Buffer.from(signature, "hex");
+    return await verifyFn(signatureBytes, cardBytes);
+  } catch (error) {
+    throw new DiscoveryError("Failed to verify Agent Card", error);
+  }
+}
+function matchesCapability(card, capability) {
+  if (isLegacyCard(card)) {
+    return card.capabilities.some(
+      (cap) => cap.toLowerCase().includes(capability.toLowerCase())
+    );
+  }
+  return card.capabilities.some(
+    (cap) => cap.id.toLowerCase().includes(capability.toLowerCase()) || cap.name.toLowerCase().includes(capability.toLowerCase()) || cap.description.toLowerCase().includes(capability.toLowerCase())
+  );
+}
+
+// src/discovery/agent-card-schema.ts
+var CLAWIVERSE_CONTEXT = "https://clawiverse.org/context/v1";
+var SCHEMA_ORG_CONTEXT = "https://schema.org";
+var clawiverseContext = {
+  "@context": {
+    "@vocab": CLAWIVERSE_CONTEXT,
+    "schema": SCHEMA_ORG_CONTEXT,
+    "AgentCard": "schema:SoftwareApplication",
+    "Capability": "schema:Action",
+    "did": "@id",
+    "name": "schema:name",
+    "description": "schema:description",
+    "version": "schema:softwareVersion",
+    "capabilities": {
+      "@id": "schema:potentialAction",
+      "@type": "@id",
+      "@container": "@list"
+    },
+    "endpoints": {
+      "@id": "schema:url",
+      "@container": "@list"
+    },
+    "peerId": "clawiverse:peerId",
+    "trust": "clawiverse:trustScore",
+    "metadata": "schema:additionalProperty",
+    "timestamp": "schema:dateModified",
+    "signature": "clawiverse:signature",
+    "parameters": {
+      "@id": "schema:object",
+      "@container": "@list"
+    }
+  }
+};
+var CapabilityTypes = {
+  TRANSLATION: "TranslationService",
+  CODE_REVIEW: "CodeReviewService",
+  DATA_ANALYSIS: "DataAnalysisService",
+  TEXT_GENERATION: "TextGenerationService",
+  IMAGE_GENERATION: "ImageGenerationService",
+  SEARCH: "SearchService",
+  COMPUTATION: "ComputationService",
+  STORAGE: "StorageService",
+  MESSAGING: "MessagingService",
+  AUTHENTICATION: "AuthenticationService"
+};
+var ParameterTypes = {
+  STRING: "string",
+  NUMBER: "number",
+  BOOLEAN: "boolean",
+  OBJECT: "object",
+  ARRAY: "array"
+};
+function getAgentCardContext() {
+  return [SCHEMA_ORG_CONTEXT, CLAWIVERSE_CONTEXT];
+}
+function isValidContext(context) {
+  if (!Array.isArray(context)) return false;
+  return context.every((c) => typeof c === "string");
+}
+function encodeForDHT(card) {
+  try {
+    const { "@context": _, ...cardWithoutContext } = card;
+    return encode(cardWithoutContext);
+  } catch (error) {
+    throw new DiscoveryError("Failed to encode Agent Card as CBOR", error);
+  }
+}
+function encodeForWeb(card) {
+  try {
+    const cardWithContext = {
+      "@context": card["@context"] || getAgentCardContext(),
+      ...card
+    };
+    return JSON.stringify(cardWithContext, null, 2);
+  } catch (error) {
+    throw new DiscoveryError("Failed to encode Agent Card as JSON-LD", error);
+  }
+}
+function decodeFromCBOR(data) {
+  try {
+    const decoded = decode(data);
+    if (isLegacyCard(decoded)) {
+      return upgradeLegacyCard(decoded);
+    }
+    if (!decoded["@context"]) {
+      decoded["@context"] = getAgentCardContext();
+    }
+    return decoded;
+  } catch (error) {
+    throw new DiscoveryError("Failed to decode Agent Card from CBOR", error);
+  }
+}
+function decodeFromJSON(json) {
+  try {
+    const decoded = JSON.parse(json);
+    if (isLegacyCard(decoded)) {
+      return upgradeLegacyCard(decoded);
+    }
+    if (!decoded["@context"]) {
+      decoded["@context"] = getAgentCardContext();
+    }
+    return decoded;
+  } catch (error) {
+    throw new DiscoveryError("Failed to decode Agent Card from JSON", error);
+  }
+}
+function decodeAgentCard(data) {
+  if (typeof data === "string") {
+    return decodeFromJSON(data);
+  }
+  try {
+    return decodeFromCBOR(data);
+  } catch {
+    const text = new TextDecoder().decode(data);
+    if (text.trim().startsWith("{")) {
+      return decodeFromJSON(text);
+    }
+    throw new DiscoveryError("Unable to decode Agent Card: unknown format");
+  }
+}
+function getEncodedSize(card) {
+  return {
+    cbor: encodeForDHT(card).length,
+    json: encodeForWeb(card).length
+  };
+}
+var logger2 = createLogger("search-index");
+var SearchIndex = class {
+  cards = /* @__PURE__ */ new Map();
+  lunrIndex;
+  fuse;
+  needsRebuild = false;
+  /**
+   * Add or update an Agent Card in the index
+   */
+  indexAgentCard(card) {
+    this.cards.set(card.did, card);
+    this.needsRebuild = true;
+    logger2.debug("Indexed Agent Card", { did: card.did, capabilities: card.capabilities.length });
+  }
+  /**
+   * Remove an Agent Card from the index
+   */
+  removeAgentCard(did) {
+    this.cards.delete(did);
+    this.needsRebuild = true;
+    logger2.debug("Removed Agent Card from index", { did });
+  }
+  /**
+   * Search for agents matching a query
+   */
+  search(query) {
+    if (this.needsRebuild) {
+      this.rebuild();
+    }
+    let results = [];
+    if (query.text && this.lunrIndex) {
+      results = this.searchByText(query.text);
+    } else if (query.capability && this.fuse) {
+      results = this.searchByCapability(query.capability);
+    } else {
+      results = Array.from(this.cards.values()).map((card) => ({
+        card,
+        score: 1
+      }));
+    }
+    if (query.filters) {
+      results = this.applyFilters(results, query.filters);
+    }
+    results.sort((a, b) => b.score - a.score);
+    if (query.limit) {
+      results = results.slice(0, query.limit);
+    }
+    logger2.debug("Search completed", { query, results: results.length });
+    return results;
+  }
+  /**
+   * Get all indexed cards
+   */
+  getAllCards() {
+    return Array.from(this.cards.values());
+  }
+  /**
+   * Clear the index
+   */
+  clear() {
+    this.cards.clear();
+    this.lunrIndex = void 0;
+    this.fuse = void 0;
+    this.needsRebuild = false;
+    logger2.info("Search index cleared");
+  }
+  /**
+   * Get index size
+   */
+  size() {
+    return this.cards.size;
+  }
+  /**
+   * Rebuild search indexes
+   */
+  rebuild() {
+    logger2.info("Rebuilding search indexes", { cards: this.cards.size });
+    const cards = Array.from(this.cards.values());
+    this.lunrIndex = lunr(function() {
+      this.ref("did");
+      this.field("name", { boost: 10 });
+      this.field("description", { boost: 5 });
+      this.field("capabilities");
+      for (const card of cards) {
+        this.add({
+          did: card.did,
+          name: card.name,
+          description: card.description,
+          capabilities: card.capabilities.map((cap) => `${cap.name} ${cap.description}`).join(" ")
+        });
+      }
+    });
+    this.fuse = new Fuse(Array.from(this.cards.values()), {
+      keys: [
+        { name: "name", weight: 0.3 },
+        { name: "description", weight: 0.2 },
+        { name: "capabilities.name", weight: 0.3 },
+        { name: "capabilities.description", weight: 0.2 }
+      ],
+      threshold: 0.4,
+      includeScore: true
+    });
+    this.needsRebuild = false;
+    logger2.info("Search indexes rebuilt");
+  }
+  /**
+   * Search by text using Lunr
+   */
+  searchByText(text) {
+    if (!this.lunrIndex) return [];
+    const lunrResults = this.lunrIndex.search(text);
+    return lunrResults.map((result) => ({
+      card: this.cards.get(result.ref),
+      score: result.score
+    }));
+  }
+  /**
+   * Search by capability using Fuse
+   */
+  searchByCapability(capability) {
+    if (!this.fuse) return [];
+    const fuseResults = this.fuse.search(capability);
+    return fuseResults.map((result) => ({
+      card: result.item,
+      score: 1 - (result.score || 0)
+      // Fuse score is distance, convert to similarity
+    }));
+  }
+  /**
+   * Apply filters to search results
+   */
+  applyFilters(results, filters) {
+    return results.filter((result) => {
+      const { card } = result;
+      if (filters.minTrustScore !== void 0 && card.trust) {
+        const overallTrust = card.trust.interactionScore * 0.4 + Math.min(card.trust.endorsements / 10, 1) * 0.2 + card.trust.completionRate * 0.2 + card.trust.uptime * 0.2;
+        if (overallTrust < filters.minTrustScore) {
+          return false;
+        }
+      }
+      if (filters.language) {
+        const hasLanguage = card.capabilities.some(
+          (cap) => {
+            const metadata = cap.metadata;
+            if (!metadata) return false;
+            return metadata.language === filters.language || Array.isArray(metadata.languages) && metadata.languages.includes(filters.language);
+          }
+        );
+        if (!hasLanguage) return false;
+      }
+      if (filters.tags && filters.tags.length > 0) {
+        const cardTags = Array.isArray(card.metadata?.tags) ? card.metadata.tags : [];
+        const hasAllTags = filters.tags.every((tag) => cardTags.includes(tag));
+        if (!hasAllTags) return false;
+      }
+      return true;
+    });
+  }
+};
+
+// src/discovery/capability-matcher.ts
+var CapabilityMatcher = class {
+  /**
+   * Match a query against a capability
+   * Returns a score between 0 and 1
+   */
+  match(query, capability) {
+    let score = 0;
+    let weights = 0;
+    if (query.capability && capability.id === query.capability) {
+      return 1;
+    }
+    if (query.capability) {
+      const nameScore = this.fuzzyMatch(query.capability, capability.name);
+      score += nameScore * 0.4;
+      weights += 0.4;
+    }
+    if (query.text) {
+      const keywords = this.extractKeywords(query.text);
+      const keywordScore = this.matchKeywords(keywords, capability);
+      score += keywordScore * 0.4;
+      weights += 0.4;
+    }
+    if (query.capability && capability["@type"]) {
+      const typeScore = this.matchesType(query.capability, capability["@type"]) ? 0.6 : 0;
+      score += typeScore * 0.2;
+      weights += 0.2;
+    }
+    return weights > 0 ? score / weights : 0;
+  }
+  /**
+   * Extract keywords from natural language text
+   */
+  extractKeywords(text) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "a",
+      "an",
+      "the",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "to",
+      "from",
+      "in",
+      "on",
+      "at",
+      "by",
+      "for",
+      "with",
+      "about",
+      "can",
+      "could",
+      "should",
+      "would",
+      "will",
+      "do",
+      "does",
+      "did",
+      "i",
+      "you",
+      "he",
+      "she",
+      "it",
+      "we",
+      "they",
+      "me",
+      "him",
+      "her"
+    ]);
+    return text.toLowerCase().split(/\W+/).filter((word) => word.length > 2 && !stopWords.has(word));
+  }
+  /**
+   * Match keywords against capability
+   */
+  matchKeywords(keywords, capability) {
+    if (keywords.length === 0) return 0;
+    const capText = `${capability.name} ${capability.description}`.toLowerCase();
+    const matches = keywords.filter((keyword) => capText.includes(keyword));
+    return matches.length / keywords.length;
+  }
+  /**
+   * Check if query matches capability type hierarchy
+   */
+  matchesType(query, type) {
+    const queryLower = query.toLowerCase();
+    const typeLower = type.toLowerCase();
+    if (typeLower.includes(queryLower)) return true;
+    const typeMap = {
+      translate: ["translation", "translationservice"],
+      review: ["codereview", "reviewservice"],
+      analyze: ["analysis", "dataanalysis"],
+      generate: ["generation", "textgeneration", "imagegeneration"],
+      search: ["searchservice", "query"],
+      compute: ["computation", "computationservice"],
+      store: ["storage", "storageservice"],
+      message: ["messaging", "messagingservice"],
+      auth: ["authentication", "authenticationservice"]
+    };
+    for (const [key, values] of Object.entries(typeMap)) {
+      if (queryLower.includes(key) && values.some((v) => typeLower.includes(v))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Fuzzy string matching using Levenshtein distance
+   */
+  fuzzyMatch(query, target) {
+    const queryLower = query.toLowerCase();
+    const targetLower = target.toLowerCase();
+    if (queryLower === targetLower) return 1;
+    if (targetLower.includes(queryLower)) return 0.8;
+    if (queryLower.includes(targetLower)) return 0.7;
+    const distance = this.levenshteinDistance(queryLower, targetLower);
+    const maxLen = Math.max(queryLower.length, targetLower.length);
+    const similarity = 1 - distance / maxLen;
+    return similarity > 0.5 ? similarity * 0.6 : 0;
+  }
+  /**
+   * Calculate Levenshtein distance between two strings
+   */
+  levenshteinDistance(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+      matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+      matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+      for (let j = 1; j <= a.length; j++) {
+        if (b.charAt(i - 1) === a.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            // substitution
+            matrix[i][j - 1] + 1,
+            // insertion
+            matrix[i - 1][j] + 1
+            // deletion
+          );
+        }
+      }
+    }
+    return matrix[b.length][a.length];
+  }
+};
+
+// src/discovery/semantic-search.ts
+var logger3 = createLogger("semantic-search");
+var SemanticSearchEngine = class {
+  constructor(dht) {
+    this.dht = dht;
+    this.index = new SearchIndex();
+    this.matcher = new CapabilityMatcher();
+  }
+  index;
+  matcher;
+  /**
+   * Main search interface
+   * Local-first with network fallback
+   */
+  async search(query) {
+    logger3.info("Searching for agents", { query });
+    const localResults = this.index.search(query);
+    logger3.debug("Local search results", { count: localResults.length });
+    const limit = query.limit || 10;
+    if (localResults.length < limit && this.dht) {
+      logger3.debug("Insufficient local results, querying network");
+      const networkResults = await this.searchNetwork(query);
+      return this.mergeResults(localResults, networkResults, limit);
+    }
+    return localResults.map((r) => r.card);
+  }
+  /**
+   * Index an Agent Card for local search
+   */
+  indexAgentCard(card) {
+    this.index.indexAgentCard(card);
+  }
+  /**
+   * Remove an Agent Card from local index
+   */
+  removeAgentCard(did) {
+    this.index.removeAgentCard(did);
+  }
+  /**
+   * Get all indexed cards
+   */
+  getAllIndexedCards() {
+    return this.index.getAllCards();
+  }
+  /**
+   * Clear local index
+   */
+  clearIndex() {
+    this.index.clear();
+  }
+  /**
+   * Get index size
+   */
+  getIndexSize() {
+    return this.index.size();
+  }
+  /**
+   * Search network via DHT
+   */
+  async searchNetwork(query) {
+    if (!this.dht) {
+      return [];
+    }
+    try {
+      const capability = query.capability || this.extractPrimaryCapability(query.text);
+      if (!capability) {
+        logger3.debug("No capability extracted from query, skipping network search");
+        return [];
+      }
+      const cards = await this.dht.queryByCapability(capability);
+      logger3.debug("Network search results", { count: cards.length });
+      return cards.map((card) => {
+        const score = this.scoreCard(card, query);
+        return { card, score };
+      });
+    } catch (error) {
+      logger3.error("Network search failed", { error });
+      return [];
+    }
+  }
+  /**
+   * Merge local and network results, removing duplicates
+   */
+  mergeResults(local, network, limit) {
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const result of local) {
+      if (!seen.has(result.card.did)) {
+        seen.add(result.card.did);
+        merged.push(result);
+      }
+    }
+    for (const result of network) {
+      if (!seen.has(result.card.did)) {
+        seen.add(result.card.did);
+        merged.push(result);
+        this.index.indexAgentCard(result.card);
+      }
+    }
+    merged.sort((a, b) => b.score - a.score);
+    return merged.slice(0, limit).map((r) => r.card);
+  }
+  /**
+   * Score a card against a query
+   */
+  scoreCard(card, query) {
+    let totalScore = 0;
+    let count = 0;
+    for (const capability of card.capabilities) {
+      const score = this.matcher.match(query, capability);
+      if (score > 0) {
+        totalScore += score;
+        count++;
+      }
+    }
+    const avgScore = count > 0 ? totalScore / count : 0;
+    if (card.trust) {
+      const trustBoost = card.trust.interactionScore * 0.2;
+      return Math.min(avgScore + trustBoost, 1);
+    }
+    return avgScore;
+  }
+  /**
+   * Extract primary capability from natural language text
+   */
+  extractPrimaryCapability(text) {
+    if (!text) return void 0;
+    const keywords = this.matcher.extractKeywords(text);
+    const capabilityKeywords = [
+      "translate",
+      "translation",
+      "review",
+      "code",
+      "analyze",
+      "analysis",
+      "generate",
+      "generation",
+      "search",
+      "query",
+      "compute",
+      "calculation",
+      "store",
+      "storage",
+      "message",
+      "messaging",
+      "auth",
+      "authentication"
+    ];
+    for (const keyword of keywords) {
+      if (capabilityKeywords.includes(keyword)) {
+        return keyword;
+      }
+    }
+    return keywords[0];
+  }
+};
+function createSemanticSearch(dht) {
+  return new SemanticSearchEngine(dht);
+}
+
+// src/discovery/dht.ts
+var logger4 = createLogger("dht");
+function createDHTOperations(libp2p) {
+  const operations = {};
+  const searchEngine = createSemanticSearch(operations);
+  return Object.assign(operations, {
+    publishAgentCard: async (card) => {
+      try {
+        const dht = libp2p.services?.dht;
+        if (!dht) {
+          throw new DiscoveryError("DHT service not available");
+        }
+        const key = fromString(`/clawiverse/agent/${card.did}`);
+        const value = encodeForDHT(card);
+        for await (const event of dht.put(key, value)) {
+          logger4.debug("DHT put event", { name: event.name });
+        }
+        searchEngine.indexAgentCard(card);
+        logger4.info("Published Agent Card to DHT", { did: card.did });
+      } catch (error) {
+        throw new DiscoveryError("Failed to publish Agent Card", error);
+      }
+    },
+    queryAgentCard: async (did) => {
+      try {
+        const dht = libp2p.services?.dht;
+        if (!dht) {
+          throw new DiscoveryError("DHT service not available");
+        }
+        const key = fromString(`/clawiverse/agent/${did}`);
+        for await (const event of dht.get(key)) {
+          if (event.name === "VALUE") {
+            const card = decodeFromCBOR(event.value);
+            searchEngine.indexAgentCard(card);
+            logger4.debug("Found Agent Card in DHT", { did });
+            return card;
+          }
+        }
+        logger4.debug("Agent Card not found in DHT", { did });
+        return null;
+      } catch (error) {
+        logger4.warn("Failed to query Agent Card", { did, error });
+        return null;
+      }
+    },
+    queryByCapability: async (capability) => {
+      try {
+        const query = { capability, limit: 20 };
+        return searchEngine.search(query);
+      } catch (error) {
+        throw new DiscoveryError("Failed to query by capability", error);
+      }
+    },
+    searchSemantic: async (query) => {
+      try {
+        return searchEngine.search(query);
+      } catch (error) {
+        throw new DiscoveryError("Failed to perform semantic search", error);
+      }
+    },
+    resolveDID: async (did) => {
+      try {
+        const dht = libp2p.services?.dht;
+        if (!dht) {
+          throw new DiscoveryError("DHT service not available");
+        }
+        const key = fromString(`/clawiverse/agent/${did}`);
+        for await (const event of dht.get(key)) {
+          if (event.name === "VALUE") {
+            const card = decodeFromCBOR(event.value);
+            if (card.peerId) {
+              logger4.debug("Resolved DID to peer", { did, peerId: card.peerId });
+              return {
+                peerId: card.peerId,
+                multiaddrs: card.endpoints || []
+              };
+            }
+            logger4.warn("Agent Card found but has no peerId", { did });
+            return null;
+          }
+        }
+        logger4.debug("DID not found in DHT", { did });
+        return null;
+      } catch (error) {
+        logger4.warn("Failed to resolve DID", { did, error });
+        return null;
+      }
+    }
+  });
+}
+
+// src/messaging/envelope.ts
+function createEnvelope(from, to, type, protocol, payload, replyTo) {
+  return {
+    id: generateMessageId(),
+    from,
+    to,
+    type,
+    protocol,
+    payload,
+    timestamp: Date.now(),
+    replyTo
+  };
+}
+async function signEnvelope(envelope, signFn) {
+  try {
+    const envelopeJson = JSON.stringify(envelope);
+    const envelopeBytes = new TextEncoder().encode(envelopeJson);
+    const signature = await signFn(envelopeBytes);
+    return {
+      ...envelope,
+      signature: Buffer.from(signature).toString("hex")
+    };
+  } catch (error) {
+    throw new MessagingError("Failed to sign envelope", error);
+  }
+}
+async function verifyEnvelope(envelope, verifyFn) {
+  try {
+    const { signature, ...envelopeWithoutSig } = envelope;
+    const envelopeJson = JSON.stringify(envelopeWithoutSig);
+    const envelopeBytes = new TextEncoder().encode(envelopeJson);
+    const signatureBytes = Buffer.from(signature, "hex");
+    return await verifyFn(signatureBytes, envelopeBytes);
+  } catch (error) {
+    throw new MessagingError("Failed to verify envelope", error);
+  }
+}
+function validateEnvelope(msg) {
+  if (typeof msg !== "object" || msg === null) {
+    return false;
+  }
+  const m = msg;
+  return typeof m.id === "string" && typeof m.from === "string" && m.from.startsWith("did:clawiverse:") && typeof m.to === "string" && m.to.startsWith("did:clawiverse:") && (m.type === "request" || m.type === "response" || m.type === "notification") && typeof m.protocol === "string" && m.payload !== void 0 && typeof m.timestamp === "number" && typeof m.signature === "string";
+}
+function generateMessageId() {
+  return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+}
+function encodeMessage(envelope) {
+  try {
+    return encode(envelope);
+  } catch (error) {
+    throw new MessagingError("Failed to encode message", error);
+  }
+}
+function decodeMessage(data) {
+  try {
+    return decode(data);
+  } catch (error) {
+    throw new MessagingError("Failed to decode message", error);
+  }
+}
+function encodeMessageJSON(envelope) {
+  try {
+    return JSON.stringify(envelope, null, 2);
+  } catch (error) {
+    throw new MessagingError("Failed to encode message to JSON", error);
+  }
+}
+function decodeMessageJSON(json) {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    throw new MessagingError("Failed to decode message from JSON", error);
+  }
+}
+var logger5 = createLogger("router");
+function createMessageRouter(libp2p, verifyFn, dht) {
+  const handlers = /* @__PURE__ */ new Map();
+  const PROTOCOL_PREFIX = "/clawiverse/msg/1.0.0";
+  return {
+    registerHandler: (protocol, handler) => {
+      handlers.set(protocol, handler);
+      logger5.info("Registered message handler", { protocol });
+    },
+    unregisterHandler: (protocol) => {
+      handlers.delete(protocol);
+      logger5.info("Unregistered message handler", { protocol });
+    },
+    sendMessage: async (envelope, peerHint) => {
+      try {
+        if (!validateEnvelope(envelope)) {
+          throw new MessagingError("Invalid message envelope");
+        }
+        let targetPeerIdStr;
+        let targetMultiaddrs = [];
+        if (peerHint) {
+          targetPeerIdStr = peerHint.peerId;
+          targetMultiaddrs = peerHint.multiaddrs;
+          logger5.info("Using peer hint for direct addressing", { peerId: targetPeerIdStr });
+        } else if (dht) {
+          const resolved = await dht.resolveDID(envelope.to);
+          if (resolved) {
+            targetPeerIdStr = resolved.peerId;
+            targetMultiaddrs = resolved.multiaddrs;
+          }
+        }
+        if (!targetPeerIdStr) {
+          throw new MessagingError(
+            `Cannot resolve recipient: ${envelope.to} \u2014 provide peerHint or ensure agent is in DHT`
+          );
+        }
+        const targetPeerId = peerIdFromString(targetPeerIdStr);
+        if (targetMultiaddrs.length > 0) {
+          const mas = targetMultiaddrs.map((a) => multiaddr(a));
+          await libp2p.peerStore.merge(targetPeerId, { multiaddrs: mas });
+        }
+        logger5.info("Dialing peer for message delivery", {
+          peerId: targetPeerIdStr,
+          multiaddrs: targetMultiaddrs
+        });
+        const stream = await libp2p.dialProtocol(targetPeerId, PROTOCOL_PREFIX);
+        const encoded = encodeMessage(envelope);
+        await stream.sink(
+          (async function* () {
+            yield encoded;
+          })()
+        );
+        logger5.info("Message sent over libp2p stream", {
+          id: envelope.id,
+          from: envelope.from,
+          to: envelope.to,
+          protocol: envelope.protocol
+        });
+        return void 0;
+      } catch (error) {
+        if (error instanceof MessagingError) throw error;
+        throw new MessagingError("Failed to send message", error);
+      }
+    },
+    start: async () => {
+      await libp2p.handle(PROTOCOL_PREFIX, async ({ stream }) => {
+        try {
+          await handleIncomingStream(stream, handlers, verifyFn);
+        } catch (error) {
+          logger5.error("Error handling incoming stream", error);
+        }
+      });
+      logger5.info("Message router started");
+    },
+    stop: async () => {
+      await libp2p.unhandle(PROTOCOL_PREFIX);
+      handlers.clear();
+      logger5.info("Message router stopped");
+    }
+  };
+}
+async function handleIncomingStream(stream, handlers, _verifyFn) {
+  try {
+    const chunks = [];
+    for await (const chunk of stream.source) {
+      chunks.push(chunk.subarray());
+    }
+    const data = new Uint8Array(
+      chunks.reduce((acc, chunk) => acc + chunk.length, 0)
+    );
+    let offset = 0;
+    for (const chunk of chunks) {
+      data.set(chunk, offset);
+      offset += chunk.length;
+    }
+    const envelope = decodeMessage(data);
+    if (!validateEnvelope(envelope)) {
+      logger5.warn("Received invalid message envelope");
+      return;
+    }
+    logger5.info("Received message", {
+      id: envelope.id,
+      from: envelope.from,
+      to: envelope.to,
+      protocol: envelope.protocol,
+      payload: envelope.payload
+    });
+    const handler = handlers.get(envelope.protocol);
+    if (!handler) {
+      logger5.warn("No handler for protocol", { protocol: envelope.protocol });
+      return;
+    }
+    const response = await handler(envelope);
+    if (response) {
+      const encoded = encodeMessage(response);
+      logger5.debug("Response prepared", { size: encoded.length });
+    }
+  } catch (error) {
+    logger5.error("Error handling incoming message", error);
+  }
+}
+
+// src/trust/trust-score.ts
+var TrustMetrics = class {
+  /**
+   * Calculate trust score from interaction history
+   */
+  calculateScore(stats, endorsements, uptime) {
+    const volumeWeight = Math.min(stats.totalInteractions / 100, 1);
+    const interactionScore = stats.successRate * volumeWeight;
+    const completionRate = stats.successRate;
+    return {
+      interactionScore,
+      endorsements,
+      completionRate,
+      responseTime: stats.avgResponseTime,
+      uptime,
+      lastUpdated: Date.now()
+    };
+  }
+  /**
+   * Calculate overall trust level (0-1)
+   */
+  calculateOverallTrust(score) {
+    const weights = {
+      interaction: 0.4,
+      endorsement: 0.2,
+      completion: 0.2,
+      uptime: 0.2
+    };
+    const endorsementScore = Math.min(score.endorsements / 10, 1);
+    return score.interactionScore * weights.interaction + endorsementScore * weights.endorsement + score.completionRate * weights.completion + score.uptime * weights.uptime;
+  }
+  /**
+   * Get trust level category
+   */
+  getTrustLevel(score) {
+    const overall = this.calculateOverallTrust(score);
+    if (score.interactionScore === 0) return "new";
+    if (overall < 0.3) return "low";
+    if (overall < 0.6) return "medium";
+    if (overall < 0.8) return "high";
+    return "trusted";
+  }
+  /**
+   * Check if agent should be rate limited
+   */
+  shouldRateLimit(score, agentAge) {
+    const overall = this.calculateOverallTrust(score);
+    const ONE_DAY = 24 * 60 * 60 * 1e3;
+    if (agentAge < ONE_DAY && overall < 0.3) {
+      return true;
+    }
+    if (overall < 0.1) {
+      return true;
+    }
+    return false;
+  }
+};
+function createDefaultTrustScore() {
+  return {
+    interactionScore: 0,
+    endorsements: 0,
+    completionRate: 0,
+    responseTime: 0,
+    uptime: 1,
+    // Assume online initially
+    lastUpdated: Date.now()
+  };
+}
+var logger6 = createLogger("interaction-history");
+var InteractionHistory = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Level(dbPath, { valueEncoding: "json" });
+  }
+  /**
+   * Open database connection
+   */
+  async open() {
+    await this.db.open();
+    logger6.info("Interaction history database opened", { path: this.db.location });
+  }
+  /**
+   * Close database connection
+   */
+  async close() {
+    await this.db.close();
+    logger6.info("Interaction history database closed");
+  }
+  /**
+   * Record an interaction
+   */
+  async record(interaction) {
+    const key = `interaction:${interaction.agentDid}:${interaction.timestamp}`;
+    await this.db.put(key, interaction);
+    logger6.debug("Recorded interaction", { agentDid: interaction.agentDid, type: interaction.type });
+  }
+  /**
+   * Get interaction history for an agent
+   */
+  async getHistory(agentDid, limit = 100) {
+    const interactions = [];
+    const prefix = `interaction:${agentDid}:`;
+    try {
+      for await (const [_, value] of this.db.iterator({
+        gte: prefix,
+        lte: prefix + "\xFF",
+        limit,
+        reverse: true
+        // Most recent first
+      })) {
+        interactions.push(value);
+      }
+    } catch (error) {
+      logger6.error("Failed to get interaction history", { agentDid, error });
+    }
+    return interactions;
+  }
+  /**
+   * Get interaction statistics for an agent
+   */
+  async getStats(agentDid) {
+    const history = await this.getHistory(agentDid, 1e3);
+    if (history.length === 0) {
+      return {
+        totalInteractions: 0,
+        successRate: 0,
+        avgResponseTime: 0,
+        lastInteraction: 0
+      };
+    }
+    const successCount = history.filter((i) => i.success).length;
+    const totalResponseTime = history.reduce((sum, i) => sum + i.responseTime, 0);
+    return {
+      totalInteractions: history.length,
+      successRate: successCount / history.length,
+      avgResponseTime: totalResponseTime / history.length,
+      lastInteraction: history[0].timestamp
+    };
+  }
+  /**
+   * Get all agents with interaction history
+   */
+  async getAllAgents() {
+    const agents = /* @__PURE__ */ new Set();
+    try {
+      for await (const [key] of this.db.iterator()) {
+        const match = key.match(/^interaction:([^:]+):/);
+        if (match) {
+          agents.add(match[1]);
+        }
+      }
+    } catch (error) {
+      logger6.error("Failed to get all agents", { error });
+    }
+    return Array.from(agents);
+  }
+  /**
+   * Delete all interactions for an agent
+   */
+  async deleteAgent(agentDid) {
+    const prefix = `interaction:${agentDid}:`;
+    const keysToDelete = [];
+    for await (const [key] of this.db.iterator({
+      gte: prefix,
+      lte: prefix + "\xFF"
+    })) {
+      keysToDelete.push(key);
+    }
+    await this.db.batch(keysToDelete.map((key) => ({ type: "del", key })));
+    logger6.info("Deleted interaction history", { agentDid, count: keysToDelete.length });
+  }
+  /**
+   * Clean up old interactions (older than 90 days)
+   */
+  async cleanup(maxAge = 90 * 24 * 60 * 60 * 1e3) {
+    const cutoff = Date.now() - maxAge;
+    const keysToDelete = [];
+    for await (const [key, value] of this.db.iterator()) {
+      if (value.timestamp < cutoff) {
+        keysToDelete.push(key);
+      }
+    }
+    if (keysToDelete.length > 0) {
+      await this.db.batch(keysToDelete.map((key) => ({ type: "del", key })));
+      logger6.info("Cleaned up old interactions", { count: keysToDelete.length });
+    }
+    return keysToDelete.length;
+  }
+};
+
+// src/trust/endorsement.ts
+var logger7 = createLogger("endorsement");
+var EndorsementManager = class {
+  constructor(db, getPublicKey) {
+    this.db = db;
+    this.getPublicKey = getPublicKey;
+  }
+  /**
+   * Create an endorsement
+   */
+  async endorse(fromDid, toDid, score, reason, signFn) {
+    if (score < 0 || score > 1) {
+      throw new Error("Score must be between 0 and 1");
+    }
+    const endorsement = {
+      from: fromDid,
+      to: toDid,
+      score,
+      reason,
+      timestamp: Date.now()
+    };
+    const data = new TextEncoder().encode(JSON.stringify(endorsement));
+    const signatureBytes = await signFn(data);
+    const signature = Buffer.from(signatureBytes).toString("hex");
+    const signedEndorsement = {
+      ...endorsement,
+      signature
+    };
+    logger7.info("Created endorsement", { from: fromDid, to: toDid, score });
+    return signedEndorsement;
+  }
+  /**
+   * Verify endorsement signature
+   */
+  async verify(endorsement, verifyFn) {
+    try {
+      const { signature, ...endorsementWithoutSig } = endorsement;
+      const data = new TextEncoder().encode(JSON.stringify(endorsementWithoutSig));
+      const signatureBytes = Buffer.from(signature, "hex");
+      const publicKey = await this.getPublicKey(endorsement.from);
+      return await verifyFn(signatureBytes, data, publicKey);
+    } catch (error) {
+      logger7.error("Failed to verify endorsement", { error });
+      return false;
+    }
+  }
+  /**
+   * Publish endorsement to local database
+   */
+  async publish(endorsement) {
+    const key = `endorsement:${endorsement.to}:${endorsement.from}`;
+    await this.db.put(key, endorsement);
+    logger7.info("Published endorsement", { from: endorsement.from, to: endorsement.to });
+  }
+  /**
+   * Get all endorsements for an agent
+   */
+  async getEndorsements(agentDid) {
+    const endorsements = [];
+    const prefix = `endorsement:${agentDid}:`;
+    try {
+      for await (const [_, value] of this.db.iterator({
+        gte: prefix,
+        lte: prefix + "\xFF"
+      })) {
+        endorsements.push(value);
+      }
+    } catch (error) {
+      logger7.error("Failed to get endorsements", { agentDid, error });
+    }
+    return endorsements;
+  }
+  /**
+   * Get endorsements given by an agent
+   */
+  async getEndorsementsBy(fromDid) {
+    const endorsements = [];
+    try {
+      for await (const [_, value] of this.db.iterator()) {
+        if (value.from === fromDid) {
+          endorsements.push(value);
+        }
+      }
+    } catch (error) {
+      logger7.error("Failed to get endorsements by agent", { fromDid, error });
+    }
+    return endorsements;
+  }
+  /**
+   * Calculate average endorsement score
+   */
+  async getAverageScore(agentDid) {
+    const endorsements = await this.getEndorsements(agentDid);
+    if (endorsements.length === 0) {
+      return 0;
+    }
+    const totalScore = endorsements.reduce((sum, e) => sum + e.score, 0);
+    return totalScore / endorsements.length;
+  }
+  /**
+   * Delete an endorsement
+   */
+  async deleteEndorsement(fromDid, toDid) {
+    const key = `endorsement:${toDid}:${fromDid}`;
+    await this.db.del(key);
+    logger7.info("Deleted endorsement", { from: fromDid, to: toDid });
+  }
+};
+var logger8 = createLogger("sybil-defense");
+var SybilDefense = class {
+  rateLimits = /* @__PURE__ */ new Map();
+  peerFirstSeen = /* @__PURE__ */ new Map();
+  NEW_AGENT_WINDOW = 24 * 60 * 60 * 1e3;
+  // 24 hours
+  RATE_LIMIT_WINDOW = 60 * 60 * 1e3;
+  // 1 hour
+  MAX_REQUESTS_NEW = 10;
+  // Max requests per hour for new agents
+  ESTABLISHED_THRESHOLD = 7 * 24 * 60 * 60 * 1e3;
+  // 7 days
+  /**
+   * Generate a Hashcash challenge for a new DID
+   */
+  generateChallenge(did, difficulty = 20) {
+    const nonce = this.generateNonce();
+    return {
+      did,
+      difficulty,
+      nonce,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Verify a Hashcash challenge solution
+   */
+  verifyChallenge(solution) {
+    const { challenge, solution: solutionNonce } = solution;
+    if (Date.now() - challenge.timestamp > 60 * 60 * 1e3) {
+      logger8.warn("Challenge expired", { did: challenge.did });
+      return false;
+    }
+    const data = `${challenge.did}:${challenge.nonce}:${solutionNonce}`;
+    const hash = sha256(new TextEncoder().encode(data));
+    const leadingZeros = this.countLeadingZeroBits(hash);
+    const valid = leadingZeros >= challenge.difficulty;
+    if (valid) {
+      logger8.info("Challenge verified", { did: challenge.did, leadingZeros });
+    } else {
+      logger8.warn("Challenge failed", { did: challenge.did, leadingZeros, required: challenge.difficulty });
+    }
+    return valid;
+  }
+  /**
+   * Check if an agent should be rate limited
+   */
+  isRateLimited(did) {
+    const record = this.rateLimits.get(did);
+    if (!record) {
+      return false;
+    }
+    const now = Date.now();
+    const agentAge = now - record.firstSeen;
+    if (agentAge > this.NEW_AGENT_WINDOW) {
+      return false;
+    }
+    const recentRequests = record.requests.filter(
+      (t) => now - t < this.RATE_LIMIT_WINDOW
+    );
+    return recentRequests.length >= this.MAX_REQUESTS_NEW;
+  }
+  /**
+   * Record a request from an agent
+   */
+  recordRequest(did) {
+    const now = Date.now();
+    let record = this.rateLimits.get(did);
+    if (!record) {
+      record = {
+        did,
+        requests: [],
+        firstSeen: now
+      };
+      this.rateLimits.set(did, record);
+    }
+    record.requests.push(now);
+    record.requests = record.requests.filter(
+      (t) => now - t < this.RATE_LIMIT_WINDOW
+    );
+    logger8.debug("Recorded request", { did, count: record.requests.length });
+  }
+  /**
+   * Get peer trust level based on age
+   */
+  getPeerTrustLevel(peerId) {
+    const firstSeen = this.peerFirstSeen.get(peerId);
+    if (!firstSeen) {
+      return "new";
+    }
+    const age = Date.now() - firstSeen;
+    if (age < this.NEW_AGENT_WINDOW) {
+      return "new";
+    } else if (age < this.ESTABLISHED_THRESHOLD) {
+      return "established";
+    } else {
+      return "trusted";
+    }
+  }
+  /**
+   * Record first seen time for a peer
+   */
+  recordPeerSeen(peerId) {
+    if (!this.peerFirstSeen.has(peerId)) {
+      this.peerFirstSeen.set(peerId, Date.now());
+      logger8.debug("Recorded new peer", { peerId });
+    }
+  }
+  /**
+   * Clean up old records
+   */
+  cleanup() {
+    const now = Date.now();
+    const cutoff = now - this.NEW_AGENT_WINDOW;
+    for (const [did, record] of this.rateLimits.entries()) {
+      if (record.firstSeen < cutoff) {
+        this.rateLimits.delete(did);
+      }
+    }
+    logger8.info("Cleaned up Sybil defense records", {
+      rateLimits: this.rateLimits.size,
+      peers: this.peerFirstSeen.size
+    });
+  }
+  /**
+   * Generate a random nonce
+   */
+  generateNonce() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return bytesToHex(bytes);
+  }
+  /**
+   * Count leading zero bits in a hash
+   */
+  countLeadingZeroBits(hash) {
+    let count = 0;
+    for (const byte of hash) {
+      if (byte === 0) {
+        count += 8;
+      } else {
+        let b = byte;
+        while ((b & 128) === 0) {
+          count++;
+          b <<= 1;
+        }
+        break;
+      }
+    }
+    return count;
+  }
+};
+var logger9 = createLogger("trust-system");
+var TrustSystem = class {
+  metrics;
+  history;
+  endorsements;
+  sybilDefense;
+  trustCache = /* @__PURE__ */ new Map();
+  CACHE_TTL = 5 * 60 * 1e3;
+  // 5 minutes
+  constructor(config) {
+    this.metrics = new TrustMetrics();
+    this.history = new InteractionHistory(`${config.dbPath}/interactions`);
+    const endorsementDb = new Level(`${config.dbPath}/endorsements`, {
+      valueEncoding: "json"
+    });
+    this.endorsements = new EndorsementManager(endorsementDb, config.getPublicKey);
+    this.sybilDefense = new SybilDefense();
+  }
+  /**
+   * Initialize the trust system
+   */
+  async start() {
+    await this.history.open();
+    logger9.info("Trust system started");
+  }
+  /**
+   * Shutdown the trust system
+   */
+  async stop() {
+    await this.history.close();
+    logger9.info("Trust system stopped");
+  }
+  /**
+   * Record an interaction
+   */
+  async recordInteraction(interaction) {
+    await this.history.record(interaction);
+    this.sybilDefense.recordRequest(interaction.agentDid);
+    this.trustCache.delete(interaction.agentDid);
+  }
+  /**
+   * Get trust score for an agent
+   */
+  async getTrustScore(agentDid) {
+    const cached = this.trustCache.get(agentDid);
+    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+      return cached.score;
+    }
+    const stats = await this.history.getStats(agentDid);
+    const endorsementList = await this.endorsements.getEndorsements(agentDid);
+    const uptime = 1;
+    const score = this.metrics.calculateScore(stats, endorsementList.length, uptime);
+    this.trustCache.set(agentDid, { score, timestamp: Date.now() });
+    return score;
+  }
+  /**
+   * Create an endorsement
+   */
+  async endorse(fromDid, toDid, score, reason, signFn) {
+    const endorsement = await this.endorsements.endorse(fromDid, toDid, score, reason, signFn);
+    await this.endorsements.publish(endorsement);
+    this.trustCache.delete(toDid);
+    return endorsement;
+  }
+  /**
+   * Get endorsements for an agent
+   */
+  async getEndorsements(agentDid) {
+    return this.endorsements.getEndorsements(agentDid);
+  }
+  /**
+   * Verify an endorsement
+   */
+  async verifyEndorsement(endorsement, verifyFn) {
+    return this.endorsements.verify(endorsement, verifyFn);
+  }
+  /**
+   * Check if agent should be rate limited
+   */
+  isRateLimited(agentDid) {
+    return this.sybilDefense.isRateLimited(agentDid);
+  }
+  /**
+   * Generate Sybil defense challenge
+   */
+  generateChallenge(did, difficulty) {
+    return this.sybilDefense.generateChallenge(did, difficulty);
+  }
+  /**
+   * Verify Sybil defense challenge
+   */
+  verifyChallenge(solution) {
+    return this.sybilDefense.verifyChallenge(solution);
+  }
+  /**
+   * Get peer trust level
+   */
+  getPeerTrustLevel(peerId) {
+    return this.sybilDefense.getPeerTrustLevel(peerId);
+  }
+  /**
+   * Record peer seen
+   */
+  recordPeerSeen(peerId) {
+    this.sybilDefense.recordPeerSeen(peerId);
+  }
+  /**
+   * Get interaction history
+   */
+  async getHistory(agentDid, limit) {
+    return this.history.getHistory(agentDid, limit);
+  }
+  /**
+   * Clean up old data
+   */
+  async cleanup() {
+    await this.history.cleanup();
+    this.sybilDefense.cleanup();
+    this.trustCache.clear();
+    logger9.info("Trust system cleanup completed");
+  }
+};
+function createTrustSystem(config) {
+  return new TrustSystem(config);
+}
+
+export { CLAWIVERSE_CONTEXT, CapabilityMatcher, CapabilityTypes, ClawiverseError, DiscoveryError, EndorsementManager, IdentityError, InteractionHistory, LogLevel, Logger, MessagingError, ParameterTypes, SCHEMA_ORG_CONTEXT, SearchIndex, SemanticSearchEngine, SybilDefense, TransportError, TrustMetrics, TrustSystem, 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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map