@twinsearth/agent-universe 2.3.5 → 2.5.6

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.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,
+};

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.6',
+    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/mcp.js

@@ -0,0 +1,101 @@
+// lib/mcp.js
+// MCP（Model Context Protocol）HTTP 客户端。
+// 通过 gsn-daemon 的 POST /api/v1/mcp JSON-RPC 端点调用市场工具，
+// 完整走 initialize → notifications/initialized → ping / tools/list /
+// tools/call。tools/call 由 daemon 端 MarketMcpBridge 真实路由执行。
+// 使用 Node 18+ 内置 fetch，零额外依赖。
+
+const MCP_PROTOCOL_VERSION = '2024-11-05';
+
+class McpError extends Error {
+  constructor(code, message) {
+    super(`[JSON-RPC ${code}] ${message}`);
+    this.code = code;
+  }
+}
+
+class McpHttpClient {
+  constructor(
+    baseUrl = 'http://127.0.0.1:4002',
+    path = '/api/v1/mcp',
+    timeout = 10000
+  ) {
+    this.endpoint = baseUrl.replace(/\/$/, '') + path;
+    this.timeout = timeout;
+    this._id = 0;
+    this.initialized = false;
+  }
+
+  async _post(payload, awaitResponse = true) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeout);
+    let res;
+    try {
+      res = await fetch(this.endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
+        body: JSON.stringify(payload),
+        signal: ctrl.signal,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+
+    const text = await res.text();
+    if (!awaitResponse || !text) return null;
+    const rpc = JSON.parse(text);
+    if (rpc.error) {
+      throw new McpError(rpc.error.code, rpc.error.message);
+    }
+    return rpc.result;
+  }
+
+  async initialize() {
+    const result = await this._post({
+      jsonrpc: '2.0',
+      id: ++this._id,
+      method: 'initialize',
+      params: {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        clientInfo: { name: 'agent-universe-js', version: '2.5.6' },
+        capabilities: {},
+      },
+    });
+    await this._post(
+      { jsonrpc: '2.0', method: 'notifications/initialized' },
+      false
+    );
+    this.initialized = true;
+    return result;
+  }
+
+  async ping() {
+    await this._post({ jsonrpc: '2.0', id: ++this._id, method: 'ping' });
+    return true;
+  }
+
+  async listTools() {
+    if (!this.initialized) await this.initialize();
+    const result = await this._post({
+      jsonrpc: '2.0',
+      id: ++this._id,
+      method: 'tools/list',
+    });
+    return result.tools;
+  }
+
+  async callTool(name, args = {}) {
+    if (!this.initialized) await this.initialize();
+    return this._post({
+      jsonrpc: '2.0',
+      id: ++this._id,
+      method: 'tools/call',
+      params: { name, arguments: args },
+    });
+  }
+}
+
+module.exports = { McpHttpClient, McpError, MCP_PROTOCOL_VERSION };

package/js/package-lock.json

@@ -0,0 +1,16 @@
+{
+  "name": "@twinsearth/agent-universe",
+  "version": "2.5.6",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@twinsearth/agent-universe",
+      "version": "2.5.6",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}

package/js/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@twinsearth/agent-universe",
+  "version": "2.5.6",
+  "description": "Agent Universe - 群众化的 AGI 路线，去中心化的智能体共享 & 开源网络。使命：让科技造福全人类！",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "agi",
+    "agent",
+    "p2p",
+    "decentralized",
+    "swarm",
+    "dht",
+    "mcp",
+    "a2a",
+    "agent-market"
+  ],
+  "author": "TwinsEarth",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TwinsEarth/agent-universe.git",
+    "directory": "js"
+  },
+  "homepage": "https://github.com/TwinsEarth/agent-universe#readme",
+  "bugs": {
+    "url": "https://github.com/TwinsEarth/agent-universe/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "lib"
+  ]
+}