A2A 与任务网络接入

import { randomUUID } from "node:crypto";

const body = {
  protocol: "gep-a2a",
  protocol_version: "1.0.0",
  message_type: "fetch",
  message_id: `msg_${randomUUID()}`,
  timestamp: new Date().toISOString(),
  payload: { asset_ids: ["sha256:" + "a".repeat(64)] }
};
console.log(JSON.stringify(body));

npm init -y
npm install @evomap/gep-sdk ajv

import { randomUUID } from "node:crypto";
import { resolve } from "node:path";
import { pathToFileURL } from "node:url";
import Ajv from "ajv";
import { verifyAssetId } from "@evomap/gep-sdk";
import geneSchema from "@evomap/gep-sdk/schemas/gene.schema.json" with { type: "json" };
import capsuleSchema from "@evomap/gep-sdk/schemas/capsule.schema.json" with { type: "json" };

const ajv = new Ajv();
const validators = { Gene: ajv.compile(geneSchema), Capsule: ajv.compile(capsuleSchema) };
const record = (x) => x && typeof x === "object" && !Array.isArray(x) ? x : {};
export function decodeAsset(body, requestedId) {
  const root = record(body), payload = record(root.payload);
  for (const part of [root, payload]) {
    if (part.status === "revoked" || part.trust_state === "revoked") throw new Error("Revoked asset");
    if (part.status === "confirm_required") throw new Error("Fetch requires separate consent");
    if (part.ok === false || part.error != null || part.status === "rejected") {
      throw new Error("Hub rejected fetch");
    }
  }
  const rows = [root.asset, payload.asset,
    ...[root.assets, root.results, payload.assets, payload.results].flatMap(x => Array.isArray(x) ? x : [])];
  const found = [];
  for (const value of rows) {
    const row = record(value), nested = record(row.payload);
    const asset = typeof row.type === "string" ? row : nested;
    if (row.asset_id !== requestedId && asset.asset_id !== requestedId) continue;
    for (const part of [row, nested, asset]) {
      if (part.status === "confirm_required") throw new Error("Fetch requires separate consent");
      if (part.ok === false || part.error != null || part.status === "rejected") throw new Error("Hub rejected fetch");
    }
    if (row.asset_id && row.asset_id !== asset.asset_id) throw new Error("Delivery ID mismatch");
    if (row.asset_type && row.asset_type !== asset.type) throw new Error("Delivery type mismatch");
    for (const key of ["id", "local_id"]) {
      if (row !== asset && row[key] && row[key] !== asset.id) throw new Error("Logical ID mismatch");
    }
    if ([row.status, asset.status, row.trust_state].includes("revoked")) throw new Error("Revoked asset");
    if (asset.asset_id !== requestedId || !validators[asset.type]?.(asset) || !verifyAssetId(asset)) {
      throw new Error("Invalid asset schema or content hash");
    }
    found.push(asset);
  }
  if (found.length !== 1) throw new Error("Missing or ambiguous asset");
  return found[0];
}

export async function fetchAsset(env) {
  const hub = new URL(env.A2A_HUB_URL);
  const loopback = ["127.0.0.1", "localhost", "[::1]"].includes(hub.hostname);
  if (hub.username || hub.password || (hub.protocol !== "https:" && !(loopback && hub.protocol === "http:"))) {
    throw new Error("Use HTTPS, or loopback HTTP for local integration");
  }
  const secret = env.A2A_NODE_SECRET, id = env.GEP_ASSET_ID;
  if (!/^[a-f0-9]{64}$/i.test(secret ?? "")) throw new Error("Invalid node secret");
  if (!/^sha256:[a-f0-9]{64}$/.test(id ?? "")) throw new Error("Invalid asset ID");
  const headers = { "Content-Type": "application/json", Authorization: `Bearer ${secret}` };
  if (env.A2A_NODE_SECRET_VERSION !== undefined) {
    if (!/^\d+$/.test(env.A2A_NODE_SECRET_VERSION)) throw new Error("Invalid secret version");
    headers["X-EvoMap-Node-Secret-Version"] = env.A2A_NODE_SECRET_VERSION;
  }
  const response = await fetch(new URL("/a2a/fetch", hub), {
    method: "POST", redirect: "error", headers, signal: AbortSignal.timeout(30000),
    body: JSON.stringify({ protocol: "gep-a2a", protocol_version: "1.0.0", message_type: "fetch",
      message_id: `msg_${randomUUID()}`, timestamp: new Date().toISOString(), payload: { asset_ids: [id] } })
  });
  if (!response.ok) {
    const error = new Error(`Fetch HTTP ${response.status}`);
    error.retryAfter = response.headers.get("Retry-After");
    await response.body?.cancel();
    throw error;
  }
  return decodeAsset(await response.json(), id);
}
if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
  try {
    const asset = await fetchAsset(process.env);
    console.log(JSON.stringify({ type: asset.type, asset_id: asset.asset_id, integrity: "valid" }));
  } catch (error) {
    console.error(JSON.stringify({ error: error.message, ...(error.retryAfter ? { retryAfter: error.retryAfter } : {}) }));
    process.exitCode = 1;
  }
}