@twinsearth/agent-universe 2.3.6 → 2.5.7

package/index.js

@@ -1,71 +1,7 @@
-// index.js
-// Agent Universe（智能体宇宙）主入口
+// Agent Universe - 智能体宇宙
 // 群众化的 AGI 路线，去中心化的智能体共享 & 开源网络
+//
+// 根入口：re-export js/ 完整 SDK 实现。
+// 另有 Rust 核心库 gsn-core（cd gsn-core && cargo build）与 Python SDK (aip-sdk-py)。
 
-const { Keypair } = require('./lib/keychain');
-const { AgentCard, Task, TaskStatus } = require('./lib/models');
-const { MemoryDHT, ShardedIndex, shardOf } = require('./lib/dht');
-const { AgentMarket, Bid, Reputation, MIN_STAKE } = require('./lib/market');
-const { McpHttpClient, McpError, MCP_PROTOCOL_VERSION } = require('./lib/mcp');
-const aca = require('./lib/aca');
-
-const version = '2.3.6';
-
-/**
- * AgentUniverse 门面：聚合身份、网络、市场能力
- */
-class AgentUniverse {
-  constructor() {
-    this.identity = Keypair.generate();
-    this.dht = new MemoryDHT();
-    this.market = new AgentMarket();
-  }
-
-  get did() {
-    return this.identity.did;
-  }
-
-  /** 注册一张 AgentCard 到本地网络 */
-  register(card) {
-    this.dht.put(card.did, card);
-    return card;
-  }
-
-  /** 发现某能力的 Agent */
-  discover(capability) {
-    return this.market.discoverBySkill(capability);
-  }
-}
-
-module.exports = {
-  version,
-  AgentUniverse,
-  Keypair,
-  AgentCard,
-  Task,
-  TaskStatus,
-  MemoryDHT,
-  ShardedIndex,
-  shardOf,
-  AgentMarket,
-  Bid,
-  Reputation,
-  MIN_STAKE,
-  // MCP
-  McpHttpClient,
-  McpError,
-  MCP_PROTOCOL_VERSION,
-  // ACA（跨语言对齐身份与协议对象）
-  AipIdentity: aca.AipIdentity,
-  buildManifest: aca.buildManifest,
-  buildEnvelope: aca.buildEnvelope,
-  buildMessage: aca.buildMessage,
-  buildReceipt: aca.buildReceipt,
-  handshakeMessage: aca.handshakeMessage,
-  proposalMessage: aca.proposalMessage,
-  receiptMessage: aca.receiptMessage,
-  verifyManifest: aca.verifyManifest,
-  verifyMessage: aca.verifyMessage,
-  verifyReceipt: aca.verifyReceipt,
-  verifyReceiptResult: aca.verifyReceiptResult,
-};
+module.exports = require('./js');

package/js/index.d.ts

@@ -0,0 +1,209 @@
+// Type definitions for @twinsearth/agent-universe
+
+export const version: string;
+export const MIN_STAKE: number;
+
+export class Keypair {
+  publicKey: string;
+  privateKey: string;
+  did: string;
+  static generate(): Keypair;
+  sign(message: string | Buffer): string;
+  verify(message: string | Buffer, signatureHex: string): boolean;
+}
+
+export class AgentCard {
+  did: string;
+  name: string;
+  capabilities: string[];
+  skills: string[];
+  version: string;
+  stake: number;
+  reputation: number;
+  static new(opts: { did: string; name: string }): AgentCard;
+  withCapability(cap: string): this;
+  withSkill(skill: string): this;
+  hasCapability(cap: string): boolean;
+}
+
+export const TaskStatus: Record<string, string>;
+
+export class Task {
+  taskId: string;
+  goal: string;
+  status: string;
+  assignee: string | null;
+  history: string[];
+  constructor(taskId: string, goal: string);
+  assign(did: string): this;
+  start(): this;
+  complete(): this;
+  verify(passed: boolean): this;
+  settle(): this;
+  readonly isTerminal: boolean;
+}
+
+export class MemoryDHT {
+  put(key: string, value: unknown): void;
+  get(key: string): unknown;
+  has(key: string): boolean;
+  remove(key: string): boolean;
+  readonly size: number;
+}
+
+export class ShardedIndex {
+  constructor(numShards?: number);
+  put(key: string, value: unknown): number;
+  get(key: string): unknown;
+  has(key: string): boolean;
+  remove(key: string): boolean;
+  readonly size: number;
+  distribution(): number[];
+}
+
+export function shardOf(key: string, numShards: number): number;
+
+export class Bid {
+  agentId: string;
+  price: number;
+}
+
+export class Reputation {
+  quality: number;
+  speed: number;
+  honesty: number;
+  availability: number;
+  overall(): number;
+}
+
+export class AgentMarket {
+  agents: Map<string, unknown>;
+  tasks: Map<string, Task>;
+  deposit(account: string, amount: number): void;
+  balance(account: string): number;
+  registerAgent(card: AgentCard, stake: number): boolean;
+  publishTask(taskId: string, goal: string, budget: number, requester: string): Task;
+  submitBid(taskId: string, agentId: string, price: number): boolean;
+  matchTask(taskId: string): Bid;
+  completeTask(taskId: string, passed?: boolean): Task;
+  settle(taskId: string): { paid: number; reason: string };
+  slash(agentId: string, amount: number, reason: string): unknown;
+  discoverBySkill(skill: string): AgentCard[];
+  leaderboard(limit?: number): unknown[];
+  conservationCheck(totalDeposits: number): {
+    conserved: boolean;
+    balanceSum: number;
+    totalSlashed: number;
+    expected: number;
+  };
+}
+
+export class AgentUniverse {
+  identity: Keypair;
+  dht: MemoryDHT;
+  market: AgentMarket;
+  readonly did: string;
+  register(card: AgentCard): AgentCard;
+  discover(capability: string): AgentCard[];
+}
+
+// ── MCP ──
+export const MCP_PROTOCOL_VERSION: string;
+
+export class McpError extends Error {
+  code: number;
+}
+
+export class McpHttpClient {
+  initialized: boolean;
+  constructor(baseUrl?: string, path?: string, timeout?: number);
+  initialize(): Promise<{
+    protocolVersion: string;
+    serverInfo: { name: string; version: string };
+  }>;
+  ping(): Promise<boolean>;
+  listTools(): Promise<
+    Array<{
+      name: string;
+      description?: string;
+      inputSchema: Record<string, unknown>;
+    }>
+  >;
+  callTool(
+    name: string,
+    args?: Record<string, unknown>
+  ): Promise<{ content: Array<{ type: string; text: string }>; isError?: boolean }>;
+}
+
+// ── ACA ──
+export class AipIdentity {
+  did: string;
+  readonly publicKey: Buffer;
+  static generate(): AipIdentity;
+  static fromSeed(seed: Buffer | Uint8Array): AipIdentity;
+  signObject(obj: Record<string, unknown>): string;
+  signInto(obj: Record<string, unknown>): Record<string, unknown>;
+  static verifyObject(obj: Record<string, unknown>, rawPub: Buffer): boolean;
+}
+
+export function buildManifest(
+  identity: AipIdentity,
+  name: string,
+  capabilities: string[],
+  opts?: Record<string, unknown>
+): Record<string, unknown>;
+
+export function buildEnvelope(
+  requesterDid: string,
+  capability: string,
+  outputSpec: string,
+  opts?: Record<string, unknown>
+): Record<string, unknown>;
+
+export function buildMessage(
+  identity: AipIdentity,
+  msgType: string,
+  toDid: string,
+  payload: unknown
+): Record<string, unknown>;
+
+export function buildReceipt(
+  identity: AipIdentity,
+  taskId: string,
+  result: Buffer,
+  opts?: Record<string, unknown>
+): Record<string, unknown>;
+
+export function handshakeMessage(
+  identity: AipIdentity,
+  manifest: Record<string, unknown>
+): Record<string, unknown>;
+
+export function proposalMessage(
+  identity: AipIdentity,
+  toDid: string,
+  envelope: Record<string, unknown>
+): Record<string, unknown>;
+
+export function receiptMessage(
+  identity: AipIdentity,
+  toDid: string,
+  receipt: Record<string, unknown>
+): Record<string, unknown>;
+
+export function verifyManifest(
+  manifest: Record<string, unknown>,
+  rawPub: Buffer
+): boolean;
+export function verifyMessage(
+  message: Record<string, unknown>,
+  rawPub: Buffer
+): boolean;
+export function verifyReceipt(
+  receipt: Record<string, unknown>,
+  rawPub: Buffer
+): boolean;
+export function verifyReceiptResult(
+  receipt: Record<string, unknown>,
+  result: Buffer
+): boolean;

package/js/index.js

@@ -0,0 +1,71 @@
+// index.js
+// Agent Universe（智能体宇宙）主入口
+// 群众化的 AGI 路线，去中心化的智能体共享 & 开源网络
+
+const { Keypair } = require('./lib/keychain');
+const { AgentCard, Task, TaskStatus } = require('./lib/models');
+const { MemoryDHT, ShardedIndex, shardOf } = require('./lib/dht');
+const { AgentMarket, Bid, Reputation, MIN_STAKE } = require('./lib/market');
+const { McpHttpClient, McpError, MCP_PROTOCOL_VERSION } = require('./lib/mcp');
+const aca = require('./lib/aca');
+
+const version = '2.5.7';
+
+/**
+ * AgentUniverse 门面：聚合身份、网络、市场能力
+ */
+class AgentUniverse {
+  constructor() {
+    this.identity = Keypair.generate();
+    this.dht = new MemoryDHT();
+    this.market = new AgentMarket();
+  }
+
+  get did() {
+    return this.identity.did;
+  }
+
+  /** 注册一张 AgentCard 到本地网络 */
+  register(card) {
+    this.dht.put(card.did, card);
+    return card;
+  }
+
+  /** 发现某能力的 Agent */
+  discover(capability) {
+    return this.market.discoverBySkill(capability);
+  }
+}
+
+module.exports = {
+  version,
+  AgentUniverse,
+  Keypair,
+  AgentCard,
+  Task,
+  TaskStatus,
+  MemoryDHT,
+  ShardedIndex,
+  shardOf,
+  AgentMarket,
+  Bid,
+  Reputation,
+  MIN_STAKE,
+  // MCP
+  McpHttpClient,
+  McpError,
+  MCP_PROTOCOL_VERSION,
+  // ACA（跨语言对齐身份与协议对象）
+  AipIdentity: aca.AipIdentity,
+  buildManifest: aca.buildManifest,
+  buildEnvelope: aca.buildEnvelope,
+  buildMessage: aca.buildMessage,
+  buildReceipt: aca.buildReceipt,
+  handshakeMessage: aca.handshakeMessage,
+  proposalMessage: aca.proposalMessage,
+  receiptMessage: aca.receiptMessage,
+  verifyManifest: aca.verifyManifest,
+  verifyMessage: aca.verifyMessage,
+  verifyReceipt: aca.verifyReceipt,
+  verifyReceiptResult: aca.verifyReceiptResult,
+};

package/js/lib/aca.js

@@ -0,0 +1,259 @@
+// lib/aca.js
+// ACA（Agent Communication Architecture）：与 Rust gsn-core / Python SDK
+// 对齐的身份、规范签名与协议对象构造。零依赖，使用 node:crypto。
+//
+// 跨语言一致性：canonical 载荷为移除 signature 键后，紧凑、按 key 字典序、
+// 不转义非 ASCII 的 JSON 字节，与 Rust serde_json(BTreeMap)、Python
+// sort_keys 产出逐字节一致，因此三端可互验签名。
+
+const crypto = require('node:crypto');
+
+// Ed25519 PKCS#8 DER 固定前缀（16 字节），后接 32 字节种子
+const PKCS8_PREFIX = Buffer.from('302e020100300506032b657004220420', 'hex');
+
+// ── 枚举标签（与 Rust serde 变体名一致） ──
+const MODE_SELF_REPORTED = 'SelfReported';
+const LEVEL_L0 = 'L0Sample';
+const PRIVACY_PUBLIC = 'Public';
+const PRIORITY_NORMAL = 'Normal';
+const STATUS_COMPLETED = 'Completed';
+const MSG_HANDSHAKE = 'Handshake';
+const MSG_TASK_PROPOSAL = 'TaskProposal';
+const MSG_RECEIPT = 'Receipt';
+
+function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+/** 稳定 JSON 序列化：紧凑、对象键按字典序、非 ASCII 原样输出 */
+function stableStringify(value) {
+  if (value === null || typeof value !== 'object') {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return '[' + value.map(stableStringify).join(',') + ']';
+  }
+  const keys = Object.keys(value).sort();
+  return (
+    '{' +
+    keys
+      .map((k) => JSON.stringify(k) + ':' + stableStringify(value[k]))
+      .join(',') +
+    '}'
+  );
+}
+
+/** 规范待签名载荷：移除 signature 键，返回 Buffer */
+function canonicalPayload(obj) {
+  const copy = { ...obj };
+  delete copy.signature;
+  return Buffer.from(stableStringify(copy), 'utf8');
+}
+
+function rawPublicFromKey(pubKey) {
+  return Buffer.from(pubKey.export({ format: 'jwk' }).x, 'base64url');
+}
+
+function pubKeyFromRaw(raw) {
+  return crypto.createPublicKey({
+    key: { kty: 'OKP', crv: 'Ed25519', x: raw.toString('base64url') },
+    format: 'jwk',
+  });
+}
+
+/**
+ * 跨语言对齐的节点身份：Ed25519 + did:aip（原始 32 字节公钥指纹）
+ */
+class AipIdentity {
+  constructor(privKey, rawPub) {
+    this._priv = privKey;
+    this._rawPub = rawPub;
+    const hash = crypto.createHash('sha256').update(rawPub).digest('hex');
+    this.did = 'did:aip:' + hash.slice(0, 16);
+  }
+
+  static generate() {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+    return new AipIdentity(privateKey, rawPublicFromKey(publicKey));
+  }
+
+  static fromSeed(seed) {
+    const buf = Buffer.isBuffer(seed) ? seed : Buffer.from(seed);
+    if (buf.length !== 32) throw new Error('seed 必须为 32 字节');
+    const priv = crypto.createPrivateKey({
+      key: Buffer.concat([PKCS8_PREFIX, buf]),
+      format: 'der',
+      type: 'pkcs8',
+    });
+    const rawPub = rawPublicFromKey(crypto.createPublicKey(priv));
+    return new AipIdentity(priv, rawPub);
+  }
+
+  /** 32 字节原始公钥 */
+  get publicKey() {
+    return this._rawPub;
+  }
+
+  signObject(obj) {
+    return crypto.sign(null, canonicalPayload(obj), this._priv).toString('hex');
+  }
+
+  signInto(obj) {
+    obj.signature = this.signObject(obj);
+    return obj;
+  }
+
+  static verifyObject(obj, rawPub) {
+    const sigHex = obj && obj.signature;
+    if (!sigHex) return false;
+    let sig;
+    try {
+      sig = Buffer.from(sigHex, 'hex');
+    } catch (e) {
+      return false;
+    }
+    try {
+      return crypto.verify(
+        null,
+        canonicalPayload(obj),
+        pubKeyFromRaw(rawPub),
+        sig
+      );
+    } catch (e) {
+      return false;
+    }
+  }
+}
+
+function buildManifest(identity, name, capabilities, opts = {}) {
+  const manifest = {
+    did: identity.did,
+    name,
+    version: opts.version || '2.5.7',
+    capabilities: [...capabilities],
+    endpoints: opts.endpoints || [],
+    hardware: {
+      cpu_cores: opts.cpuCores || 0,
+      memory_mb: opts.memoryMb || 0,
+      disk_free_gb: opts.diskFreeGb || 0,
+      gpu: null,
+      bandwidth_up_mbps: 0,
+      bandwidth_down_mbps: 0,
+      platform: opts.platform || 'desktop',
+    },
+    verification_modes: opts.verificationModes || [MODE_SELF_REPORTED],
+    stake: opts.stake || 0,
+    reputation_ref: null,
+    model_hash: null,
+    mcp_tool_count: opts.mcpToolCount || 0,
+    signature: '',
+    timestamp: nowSec(),
+  };
+  return identity.signInto(manifest);
+}
+
+function buildEnvelope(requesterDid, capability, outputSpec, opts = {}) {
+  return {
+    task_id: crypto.randomUUID(),
+    requester_did: requesterDid,
+    capability,
+    input_cid: opts.inputCid || '',
+    output_spec: outputSpec,
+    verification_level: opts.verificationLevel || LEVEL_L0,
+    privacy: opts.privacy || PRIVACY_PUBLIC,
+    budget: opts.budget || 0,
+    timeout_secs: opts.timeoutSecs || 300,
+    priority: opts.priority || PRIORITY_NORMAL,
+    mcp_tool: opts.mcpTool || null,
+    created_at: nowSec(),
+  };
+}
+
+function buildMessage(identity, msgType, toDid, payload) {
+  const message = {
+    message_id: crypto.randomUUID(),
+    msg_type: msgType,
+    from_did: identity.did,
+    to_did: toDid,
+    payload,
+    timestamp: nowSec(),
+    signature: '',
+  };
+  return identity.signInto(message);
+}
+
+function handshakeMessage(identity, manifest) {
+  return buildMessage(identity, MSG_HANDSHAKE, '*', manifest);
+}
+
+function proposalMessage(identity, toDid, envelope) {
+  return buildMessage(identity, MSG_TASK_PROPOSAL, toDid, envelope);
+}
+
+function buildReceipt(identity, taskId, result, opts = {}) {
+  const hash = crypto.createHash('sha256').update(result).digest();
+  const metering = Object.assign(
+    {
+      compute_ms: 0,
+      memory_peak_mb: 0,
+      bandwidth_mb: 0,
+      storage_bytes: 0,
+      energy_joules: 0,
+    },
+    opts.metering || {}
+  );
+  const receipt = {
+    task_id: taskId,
+    executor_did: identity.did,
+    result_cid: 'cid:' + hash.toString('hex').slice(0, 16),
+    result_hash: [...hash],
+    status: opts.status || STATUS_COMPLETED,
+    metering,
+    tee_quote: opts.teeQuote || null,
+    zk_proof: opts.zkProof || null,
+    completed_at: nowSec(),
+    signature: '',
+  };
+  return identity.signInto(receipt);
+}
+
+function receiptMessage(identity, toDid, receipt) {
+  return buildMessage(identity, MSG_RECEIPT, toDid, receipt);
+}
+
+function verifyManifest(manifest, rawPub) {
+  return AipIdentity.verifyObject(manifest, rawPub);
+}
+function verifyMessage(message, rawPub) {
+  return AipIdentity.verifyObject(message, rawPub);
+}
+function verifyReceipt(receipt, rawPub) {
+  return AipIdentity.verifyObject(receipt, rawPub);
+}
+function verifyReceiptResult(receipt, result) {
+  const hash = crypto.createHash('sha256').update(result).digest();
+  return deepEqualArray(receipt.result_hash, [...hash]);
+}
+
+function deepEqualArray(a, b) {
+  if (!Array.isArray(a) || a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+module.exports = {
+  AipIdentity,
+  canonicalPayload,
+  stableStringify,
+  buildManifest,
+  buildEnvelope,
+  buildMessage,
+  buildReceipt,
+  handshakeMessage,
+  proposalMessage,
+  receiptMessage,
+  verifyManifest,
+  verifyMessage,
+  verifyReceipt,
+  verifyReceiptResult,
+};

package/js/lib/dht.js

@@ -0,0 +1,92 @@
+// lib/dht.js
+// MemoryDHT / ShardedIndex / shardOf（SHA-256 分片）
+
+const crypto = require('node:crypto');
+
+/** 计算 key 所属分片：SHA-256(key) 前 8 hex 转整数，对 numShards 取模 */
+function shardOf(key, numShards) {
+  const hash = crypto.createHash('sha256').update(String(key)).digest('hex');
+  const prefix = parseInt(hash.slice(0, 8), 16);
+  return prefix % numShards;
+}
+
+/** 内存 DHT（键值存储） */
+class MemoryDHT {
+  constructor() {
+    this.store = new Map();
+  }
+
+  put(key, value) {
+    this.store.set(String(key), value);
+  }
+
+  get(key) {
+    return this.store.get(String(key));
+  }
+
+  has(key) {
+    return this.store.has(String(key));
+  }
+
+  remove(key) {
+    return this.store.delete(String(key));
+  }
+
+  get size() {
+    return this.store.size;
+  }
+
+  /** 按前缀查找 */
+  findByPrefix(prefix) {
+    const result = [];
+    for (const [k, v] of this.store) {
+      if (k.startsWith(prefix)) result.push({ key: k, value: v });
+    }
+    return result;
+  }
+}
+
+/** 分片索引：把 key 均匀分布到 numShards 个分片 */
+class ShardedIndex {
+  constructor(numShards = 16) {
+    this.numShards = numShards;
+    this.shards = [];
+    for (let i = 0; i < numShards; i++) this.shards.push(new Map());
+  }
+
+  put(key, value) {
+    const s = shardOf(key, this.numShards);
+    this.shards[s].set(String(key), value);
+    return s;
+  }
+
+  get(key) {
+    const s = shardOf(key, this.numShards);
+    return this.shards[s].get(String(key));
+  }
+
+  has(key) {
+    const s = shardOf(key, this.numShards);
+    return this.shards[s].has(String(key));
+  }
+
+  remove(key) {
+    const s = shardOf(key, this.numShards);
+    return this.shards[s].delete(String(key));
+  }
+
+  shardSize(i) {
+    return this.shards[i].size;
+  }
+
+  get size() {
+    return this.shards.reduce((sum, m) => sum + m.size, 0);
+  }
+
+  /** 各分片条目数（用于验证分布均匀性） */
+  distribution() {
+    return this.shards.map((m) => m.size);
+  }
+}
+
+module.exports = { MemoryDHT, ShardedIndex, shardOf };