@agentfield/sdk 0.1.42 → 0.1.43-rc.1

package/dist/index.js

@@ -1,5 +1,6 @@
 import express from 'express';
-import crypto, { randomUUID } from 'crypto';
+import rateLimit from 'express-rate-limit';
+import crypto2, { randomUUID, createHash } from 'crypto';
 import { AsyncLocalStorage } from 'async_hooks';
 import { generateObject, generateText, streamText, embed, embedMany } from 'ai';
 import { createOpenAI } from '@ai-sdk/openai';
@@ -11,11 +12,11 @@ import { createXai } from '@ai-sdk/xai';
 import { createDeepSeek } from '@ai-sdk/deepseek';
 import { createCohere } from '@ai-sdk/cohere';
 import os from 'os';
-import axios, { isAxiosError } from 'axios';
+import axios5, { isAxiosError } from 'axios';
 import http from 'http';
 import https from 'https';
 import WebSocket from 'ws';
-import { Buffer } from 'buffer';
+import { Buffer as Buffer$1 } from 'buffer';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
 // src/agent/Agent.ts
@@ -248,7 +249,7 @@ var StatelessRateLimiter = class {
   }
   _getContainerSeed() {
     const identifier = `${os.hostname()}-${process.pid}`;
-    const hash = crypto.createHash("md5").update(identifier).digest("hex");
+    const hash = crypto2.createHash("md5").update(identifier).digest("hex");
     return parseInt(hash.slice(0, 8), 16);
   }
   _isRateLimitError(error) {
@@ -634,15 +635,97 @@ var httpsAgent = new https.Agent({
   maxTotalSockets: 50,
   maxFreeSockets: 5
 });
+var HEADER_CALLER_DID = "X-Caller-DID";
+var HEADER_DID_SIGNATURE = "X-DID-Signature";
+var HEADER_DID_TIMESTAMP = "X-DID-Timestamp";
+var HEADER_DID_NONCE = "X-DID-Nonce";
+var ED25519_PKCS8_PREFIX = Buffer.from([
+  48,
+  46,
+  2,
+  1,
+  0,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  112,
+  4,
+  34,
+  4,
+  32
+]);
+var DIDAuthenticator = class {
+  _did;
+  _privateKey;
+  constructor(did, privateKeyJwk) {
+    if (did && privateKeyJwk) {
+      this.setCredentials(did, privateKeyJwk);
+    }
+  }
+  get isConfigured() {
+    return this._did !== void 0 && this._privateKey !== void 0;
+  }
+  get did() {
+    return this._did;
+  }
+  signRequest(body) {
+    if (!this.isConfigured) {
+      return {};
+    }
+    const timestamp = Math.floor(Date.now() / 1e3).toString();
+    const nonce = crypto2.randomBytes(16).toString("hex");
+    const bodyHash = crypto2.createHash("sha256").update(body).digest("hex");
+    const payload = `${timestamp}:${nonce}:${bodyHash}`;
+    const signature = crypto2.sign(null, Buffer.from(payload), this._privateKey);
+    const signatureB64 = signature.toString("base64");
+    return {
+      [HEADER_CALLER_DID]: this._did,
+      [HEADER_DID_SIGNATURE]: signatureB64,
+      [HEADER_DID_TIMESTAMP]: timestamp,
+      [HEADER_DID_NONCE]: nonce
+    };
+  }
+  setCredentials(did, privateKeyJwk) {
+    this._privateKey = parsePrivateKeyJWK(privateKeyJwk);
+    this._did = did;
+  }
+};
+function parsePrivateKeyJWK(jwkJSON) {
+  let key;
+  try {
+    key = JSON.parse(jwkJSON);
+  } catch {
+    throw new Error("Invalid JWK format: failed to parse JSON");
+  }
+  if (key.kty !== "OKP" || key.crv !== "Ed25519") {
+    throw new Error("Invalid key type: expected Ed25519 OKP key");
+  }
+  if (!key.d) {
+    throw new Error("Missing 'd' (private key) in JWK");
+  }
+  const seedBytes = Buffer.from(key.d, "base64url");
+  if (seedBytes.length !== 32) {
+    throw new Error(`Invalid private key length: expected 32 bytes, got ${seedBytes.length}`);
+  }
+  return crypto2.createPrivateKey({
+    key: Buffer.concat([ED25519_PKCS8_PREFIX, seedBytes]),
+    format: "der",
+    type: "pkcs8"
+  });
+}
 
 // src/client/AgentFieldClient.ts
 var AgentFieldClient = class {
   http;
   config;
   defaultHeaders;
+  didAuthenticator;
   constructor(config) {
     const baseURL = (config.agentFieldUrl ?? "http://localhost:8080").replace(/\/$/, "");
-    this.http = axios.create({
+    this.http = axios5.create({
       baseURL,
       timeout: 3e4,
       httpAgent,
@@ -654,19 +737,30 @@ var AgentFieldClient = class {
       mergedHeaders["X-API-Key"] = config.apiKey;
     }
     this.defaultHeaders = this.sanitizeHeaders(mergedHeaders);
+    this.didAuthenticator = new DIDAuthenticator(config.did, config.privateKeyJwk);
   }
   async register(payload) {
-    await this.http.post("/api/v1/nodes/register", payload, { headers: this.mergeHeaders() });
+    const bodyStr = JSON.stringify(payload);
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
+    const res = await this.http.post("/api/v1/nodes/register", bodyStr, {
+      headers: this.mergeHeaders({ "Content-Type": "application/json", ...authHeaders })
+    });
+    return res.data;
+  }
+  async getNode(nodeId) {
+    const res = await this.http.get(`/api/v1/nodes/${encodeURIComponent(nodeId)}`, {
+      headers: this.mergeHeaders({})
+    });
+    return res.data;
   }
   async heartbeat(status = "ready") {
     const nodeId = this.config.nodeId;
+    const bodyStr = JSON.stringify({ status, version: this.config.version ?? "", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
     const res = await this.http.post(
       `/api/v1/nodes/${nodeId}/heartbeat`,
-      {
-        status,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      { headers: this.mergeHeaders() }
+      bodyStr,
+      { headers: this.mergeHeaders({ "Content-Type": "application/json", ...authHeaders }) }
     );
     return res.data;
   }
@@ -681,14 +775,27 @@ var AgentFieldClient = class {
     if (metadata?.targetDid) headers["X-Target-DID"] = metadata.targetDid;
     if (metadata?.agentNodeDid) headers["X-Agent-Node-DID"] = metadata.agentNodeDid;
     if (metadata?.agentNodeId) headers["X-Agent-Node-ID"] = metadata.agentNodeId;
-    const res = await this.http.post(
-      `/api/v1/execute/${target}`,
-      {
-        input
-      },
-      { headers: this.mergeHeaders(headers) }
-    );
-    return res.data?.result ?? res.data;
+    const bodyStr = JSON.stringify({ input });
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
+    try {
+      const res = await this.http.post(
+        `/api/v1/execute/${target}`,
+        bodyStr,
+        { headers: this.mergeHeaders({ "Content-Type": "application/json", ...headers, ...authHeaders }) }
+      );
+      return res.data?.result ?? res.data;
+    } catch (err) {
+      const respData = err?.response?.data;
+      if (respData) {
+        const status = err.response.status;
+        const msg = respData.message || respData.error || JSON.stringify(respData);
+        const enriched = new Error(`execute ${target} failed (${status}): ${msg}`);
+        enriched.status = status;
+        enriched.responseData = respData;
+        throw enriched;
+      }
+      throw err;
+    }
   }
   async publishWorkflowEvent(event) {
     const payload = {
@@ -706,8 +813,10 @@ var AgentFieldClient = class {
       error: event.error,
       duration_ms: event.durationMs
     };
-    this.http.post("/api/v1/workflow/executions/events", payload, {
-      headers: this.mergeHeaders(),
+    const bodyStr = JSON.stringify(payload);
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
+    this.http.post("/api/v1/workflow/executions/events", bodyStr, {
+      headers: this.mergeHeaders({ "Content-Type": "application/json", ...authHeaders }),
       timeout: this.config.devMode ? 1e3 : void 0
     }).catch(() => {
     });
@@ -723,7 +832,11 @@ var AgentFieldClient = class {
       duration_ms: update.durationMs,
       progress: update.progress !== void 0 ? Math.round(update.progress) : void 0
     };
-    await this.http.post(`/api/v1/executions/${executionId}/status`, payload, { headers: this.mergeHeaders() });
+    const bodyStr = JSON.stringify(payload);
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
+    await this.http.post(`/api/v1/executions/${executionId}/status`, bodyStr, {
+      headers: this.mergeHeaders({ "Content-Type": "application/json", ...authHeaders })
+    });
   }
   async discoverCapabilities(options = {}) {
     const format = (options.format ?? "json").toLowerCase();
@@ -864,6 +977,15 @@ var AgentFieldClient = class {
     if (metadata.agentNodeId) headers["x-agent-node-id"] = metadata.agentNodeId;
     return headers;
   }
+  setDIDCredentials(did, privateKeyJwk) {
+    this.didAuthenticator.setCredentials(did, privateKeyJwk);
+  }
+  get didAuthConfigured() {
+    return this.didAuthenticator.isConfigured;
+  }
+  getDID() {
+    return this.didAuthenticator.did;
+  }
   sendNote(message, tags, agentNodeId, metadata, uiApiBaseUrl, devMode) {
     const payload = {
       message,
@@ -872,11 +994,14 @@ var AgentFieldClient = class {
       agent_node_id: agentNodeId
     };
     const executionHeaders = this.buildExecutionHeaders({ ...metadata, agentNodeId });
+    const bodyStr = JSON.stringify(payload);
+    const authHeaders = this.didAuthenticator.signRequest(Buffer.from(bodyStr));
     const headers = this.mergeHeaders({
-      "content-type": "application/json",
-      ...executionHeaders
+      "Content-Type": "application/json",
+      ...executionHeaders,
+      ...authHeaders
     });
-    axios.post(`${uiApiBaseUrl}/executions/note`, payload, {
+    axios5.post(`${uiApiBaseUrl}/executions/note`, bodyStr, {
       headers,
       timeout: devMode ? 5e3 : 1e4,
       httpAgent,
@@ -889,7 +1014,7 @@ var MemoryClient = class {
   http;
   defaultHeaders;
   constructor(baseUrl, defaultHeaders) {
-    this.http = axios.create({
+    this.http = axios5.create({
       baseURL: baseUrl.replace(/\/$/, ""),
       timeout: 3e4,
       httpAgent,
@@ -1271,7 +1396,7 @@ var DidClient = class {
   http;
   defaultHeaders;
   constructor(baseUrl, defaultHeaders) {
-    this.http = axios.create({
+    this.http = axios5.create({
       baseURL: baseUrl.replace(/\/$/, ""),
       timeout: 3e4,
       httpAgent,
@@ -1308,7 +1433,7 @@ var DidClient = class {
   parseIdentityPackage(pkg) {
     const parseIdentity = (data) => ({
       did: data?.did ?? "",
-      privateKeyJwk: data?.private_key_jwk ?? "",
+      privateKeyJwk: data?.private_key_jwk,
       publicKeyJwk: data?.public_key_jwk ?? "",
       derivationPath: data?.derivation_path ?? "",
       componentType: data?.component_type ?? "",
@@ -1397,7 +1522,7 @@ var DidClient = class {
     if (typeof data === "string") {
       value = data;
     } else if (data instanceof Uint8Array) {
-      value = Buffer.from(data).toString("utf-8");
+      value = Buffer$1.from(data).toString("utf-8");
     } else if (typeof data === "object") {
       try {
         value = JSON.stringify(data, Object.keys(data).sort());
@@ -1407,7 +1532,7 @@ var DidClient = class {
     } else {
       value = String(data);
     }
-    return Buffer.from(value, "utf-8").toString("base64");
+    return Buffer$1.from(value, "utf-8").toString("base64");
   }
   mapExecutionCredential(data) {
     return {
@@ -1660,7 +1785,7 @@ var MCPClient = class {
     this.alias = config.alias;
     this.transport = config.transport ?? "http";
     this.baseUrl = (config.url ?? `http://localhost:${config.port}`).replace(/\/$/, "");
-    this.http = axios.create({
+    this.http = axios5.create({
       baseURL: this.baseUrl,
       headers: config.headers,
       timeout: 3e4,
@@ -1874,6 +1999,227 @@ var MCPToolRegistrar = class {
     return collapsed || "mcp_tool";
   }
 };
+var LocalVerifier = class {
+  agentFieldUrl;
+  refreshInterval;
+  timestampWindow;
+  apiKey;
+  policies = [];
+  revokedDids = /* @__PURE__ */ new Set();
+  registeredDids = /* @__PURE__ */ new Set();
+  adminPublicKeyBytes = null;
+  issuerDid = null;
+  lastRefresh = 0;
+  initialized = false;
+  constructor(agentFieldUrl, refreshInterval = 300, timestampWindow = 300, apiKey) {
+    this.agentFieldUrl = agentFieldUrl.replace(/\/+$/, "");
+    this.refreshInterval = refreshInterval;
+    this.timestampWindow = timestampWindow;
+    this.apiKey = apiKey;
+  }
+  get needsRefresh() {
+    return Date.now() / 1e3 - this.lastRefresh > this.refreshInterval;
+  }
+  async refresh() {
+    const headers = {};
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    let success = true;
+    try {
+      const resp = await axios5.get(`${this.agentFieldUrl}/api/v1/policies`, {
+        headers,
+        timeout: 1e4
+      });
+      if (resp.status !== 200) {
+        success = false;
+      } else {
+        this.policies = resp.data?.policies ?? [];
+      }
+    } catch {
+      success = false;
+    }
+    try {
+      const resp = await axios5.get(`${this.agentFieldUrl}/api/v1/revocations`, {
+        headers,
+        timeout: 1e4
+      });
+      if (resp.status !== 200) {
+        success = false;
+      } else {
+        this.revokedDids = new Set(resp.data?.revoked_dids ?? []);
+      }
+    } catch {
+      success = false;
+    }
+    try {
+      const resp = await axios5.get(`${this.agentFieldUrl}/api/v1/registered-dids`, {
+        headers,
+        timeout: 1e4
+      });
+      if (resp.status !== 200) {
+        success = false;
+      } else {
+        this.registeredDids = new Set(resp.data?.registered_dids ?? []);
+      }
+    } catch {
+      success = false;
+    }
+    try {
+      const resp = await axios5.get(`${this.agentFieldUrl}/api/v1/admin/public-key`, {
+        headers,
+        timeout: 1e4
+      });
+      if (resp.status !== 200) {
+        success = false;
+      } else {
+        const jwk = resp.data?.public_key_jwk;
+        this.issuerDid = resp.data?.issuer_did ?? null;
+        if (jwk?.x) {
+          this.adminPublicKeyBytes = new Uint8Array(Buffer.from(jwk.x, "base64url"));
+        }
+      }
+    } catch {
+      success = false;
+    }
+    if (success) {
+      this.lastRefresh = Date.now() / 1e3;
+      this.initialized = true;
+    }
+    return success;
+  }
+  checkRevocation(callerDid) {
+    return this.revokedDids.has(callerDid);
+  }
+  /**
+   * Check if a caller DID is registered with the control plane.
+   * Returns true if registered (known), false if unknown.
+   * When the cache is empty (not yet loaded), returns true to avoid
+   * blocking requests before the first refresh completes.
+   */
+  checkRegistration(callerDid) {
+    if (this.registeredDids.size === 0) {
+      return true;
+    }
+    return this.registeredDids.has(callerDid);
+  }
+  /**
+   * Resolve the public key bytes from a DID.
+   *
+   * For did:key, the public key is self-contained in the identifier:
+   *   did:key:z<base64url(0xed01 + 32-byte-pubkey)>
+   *
+   * For other DID methods, falls back to the admin public key.
+   */
+  resolvePublicKey(callerDid) {
+    if (callerDid.startsWith("did:key:z")) {
+      try {
+        const encoded = callerDid.slice("did:key:z".length);
+        const decoded = Buffer.from(encoded, "base64url");
+        if (decoded.length >= 34 && decoded[0] === 237 && decoded[1] === 1) {
+          return new Uint8Array(decoded.subarray(2, 34));
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    }
+    return this.adminPublicKeyBytes;
+  }
+  async verifySignature(callerDid, signatureB64, timestamp, body, nonce) {
+    const ts = parseInt(timestamp, 10);
+    if (isNaN(ts)) return false;
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - ts) > this.timestampWindow) return false;
+    const publicKeyBytes = this.resolvePublicKey(callerDid);
+    if (!publicKeyBytes || publicKeyBytes.length !== 32) {
+      return false;
+    }
+    try {
+      const { createPublicKey, verify } = await import('crypto');
+      const bodyHash = createHash("sha256").update(body).digest("hex");
+      const payloadStr = nonce ? `${timestamp}:${nonce}:${bodyHash}` : `${timestamp}:${bodyHash}`;
+      const payload = Buffer.from(payloadStr, "utf-8");
+      const signatureBytes = Buffer.from(signatureB64, "base64");
+      const publicKey = createPublicKey({
+        key: Buffer.concat([
+          // Ed25519 DER prefix for a 32-byte public key
+          Buffer.from("302a300506032b6570032100", "hex"),
+          Buffer.from(publicKeyBytes)
+        ]),
+        format: "der",
+        type: "spki"
+      });
+      return verify(null, payload, publicKey, signatureBytes);
+    } catch {
+      return false;
+    }
+  }
+  evaluatePolicy(callerTags, targetTags, functionName, inputParams) {
+    if (!this.policies || this.policies.length === 0) {
+      return false;
+    }
+    const sorted = [...this.policies].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    for (const policy of sorted) {
+      if (policy.enabled === false) continue;
+      if (policy.caller_tags?.length > 0) {
+        if (!policy.caller_tags.some((t) => callerTags.includes(t))) continue;
+      }
+      if (policy.target_tags?.length > 0) {
+        if (!policy.target_tags.some((t) => targetTags.includes(t))) continue;
+      }
+      if (policy.deny_functions?.length > 0 && functionMatches(functionName, policy.deny_functions)) {
+        return false;
+      }
+      if (policy.allow_functions?.length > 0 && !functionMatches(functionName, policy.allow_functions)) {
+        continue;
+      }
+      if (policy.constraints && inputParams) {
+        if (!evaluateConstraints(policy.constraints, inputParams)) {
+          return false;
+        }
+      }
+      const action = policy.action || "allow";
+      return action === "allow";
+    }
+    return true;
+  }
+};
+function functionMatches(name, patterns) {
+  for (const pattern of patterns) {
+    if (pattern === "*") return true;
+    if (pattern.endsWith("*") && name.startsWith(pattern.slice(0, -1))) return true;
+    if (pattern.startsWith("*") && name.endsWith(pattern.slice(1))) return true;
+    if (name === pattern) return true;
+  }
+  return false;
+}
+function evaluateConstraints(constraints, inputParams) {
+  for (const [paramName, constraint] of Object.entries(constraints)) {
+    if (!(paramName in inputParams)) continue;
+    const value = Number(inputParams[paramName]);
+    const threshold = Number(constraint.value);
+    if (isNaN(value) || isNaN(threshold)) return false;
+    switch (constraint.operator) {
+      case "<=":
+        if (value > threshold) return false;
+        break;
+      case ">=":
+        if (value < threshold) return false;
+        break;
+      case "<":
+        if (value >= threshold) return false;
+        break;
+      case ">":
+        if (value <= threshold) return false;
+        break;
+      case "==":
+        if (Math.abs(value - threshold) > 1e-9) return false;
+        break;
+    }
+  }
+  return true;
+}
 
 // src/agent/Agent.ts
 var TargetNotFoundError = class extends Error {
@@ -1894,6 +2240,8 @@ var Agent = class {
   memoryWatchers = [];
   mcpClientRegistry;
   mcpToolRegistrar;
+  localVerifier;
+  realtimeValidationFunctions = /* @__PURE__ */ new Set();
   constructor(config) {
     const mcp = config.mcp ? {
       autoRegisterTools: config.mcp.autoRegisterTools ?? true,
@@ -1926,14 +2274,28 @@ var Agent = class {
       });
       this.mcpToolRegistrar.registerServers(this.config.mcp.servers);
     }
+    if (this.config.localVerification && this.config.agentFieldUrl) {
+      this.localVerifier = new LocalVerifier(
+        this.config.agentFieldUrl,
+        this.config.verificationRefreshInterval ?? 300,
+        300,
+        this.config.apiKey
+      );
+    }
     this.registerDefaultRoutes();
   }
   reasoner(name, handler, options) {
     this.reasoners.register(name, handler, options);
+    if (options?.requireRealtimeValidation) {
+      this.realtimeValidationFunctions.add(name);
+    }
     return this;
   }
   skill(name, handler, options) {
     this.skills.register(name, handler, options);
+    if (options?.requireRealtimeValidation) {
+      this.realtimeValidationFunctions.add(name);
+    }
     return this;
   }
   includeRouter(router) {
@@ -2035,6 +2397,16 @@ var Agent = class {
       }
     }
     await this.registerWithControlPlane();
+    if (this.localVerifier) {
+      try {
+        const ok = await this.localVerifier.refresh();
+        if (!ok) {
+          console.warn("[LocalVerifier] Initial refresh partially failed \u2014 some verification data may be stale");
+        }
+      } catch (err) {
+        console.warn("[LocalVerifier] Initial refresh failed:", err);
+      }
+    }
     const port = this.config.port ?? 8001;
     const host = this.config.host ?? "0.0.0.0";
     await this.agentFieldClient.heartbeat("starting");
@@ -2179,6 +2551,111 @@ var Agent = class {
     this.app.get("/skills", (_req, res) => {
       res.json(this.skills.all().map((s) => s.name));
     });
+    if (this.localVerifier) {
+      const verifier = this.localVerifier;
+      const realtimeFunctions = this.realtimeValidationFunctions;
+      const authRateLimiter = rateLimit({
+        windowMs: 6e4,
+        max: 30,
+        standardHeaders: true,
+        legacyHeaders: false,
+        keyGenerator: (req) => {
+          const callerDID = req.headers["x-caller-did"];
+          if (typeof callerDID === "string" && callerDID.length > 0) {
+            return callerDID;
+          }
+          return req.ip ?? "unknown";
+        },
+        message: { error: "rate_limit_exceeded", message: "Too many authentication attempts. Try again later." },
+        skip: (req) => {
+          const path = req.path;
+          if (!path.startsWith("/reasoners/") && !path.startsWith("/skills/") && !path.startsWith("/execute") && !path.startsWith("/api/v1/reasoners/") && !path.startsWith("/api/v1/skills/")) {
+            return true;
+          }
+          const parts = path.replace(/^\/+/, "").split("/");
+          const funcName = parts[parts.length - 1] ?? "";
+          return realtimeFunctions.has(funcName);
+        }
+      });
+      this.app.use(authRateLimiter);
+      this.app.use(async (req, res, next) => {
+        const path = req.path;
+        if (!path.startsWith("/reasoners/") && !path.startsWith("/skills/") && !path.startsWith("/execute") && !path.startsWith("/api/v1/reasoners/") && !path.startsWith("/api/v1/skills/")) {
+          return next();
+        }
+        const parts = path.replace(/^\/+/, "").split("/");
+        const funcName = parts[parts.length - 1] ?? "";
+        if (realtimeFunctions.has(funcName)) {
+          return next();
+        }
+        if (verifier.needsRefresh) {
+          try {
+            await verifier.refresh();
+          } catch (err) {
+            console.warn("[LocalVerifier] Cache refresh failed:", err);
+          }
+        }
+        const callerDid = req.headers["x-caller-did"];
+        const signature = req.headers["x-did-signature"];
+        const timestamp = req.headers["x-did-timestamp"];
+        const nonce = req.headers["x-did-nonce"];
+        if (!callerDid) {
+          return res.status(401).json({
+            error: "did_auth_required",
+            message: "DID authentication required"
+          });
+        }
+        if (verifier.checkRevocation(callerDid)) {
+          return res.status(403).json({
+            error: "did_revoked",
+            message: `Caller DID ${callerDid} has been revoked`
+          });
+        }
+        if (!verifier.checkRegistration(callerDid)) {
+          return res.status(403).json({
+            error: "did_not_registered",
+            message: `Caller DID ${callerDid} is not registered with the control plane`
+          });
+        }
+        if (!signature) {
+          return res.status(401).json({
+            error: "signature_required",
+            message: "DID signature required"
+          });
+        }
+        if (timestamp) {
+          const body = Buffer.isBuffer(req.body) ? req.body : Buffer.from(JSON.stringify(req.body));
+          const valid = await verifier.verifySignature(callerDid, signature, timestamp, body, nonce);
+          if (!valid) {
+            return res.status(401).json({
+              error: "signature_invalid",
+              message: "DID signature verification failed"
+            });
+          }
+        } else {
+          return res.status(401).json({
+            error: "signature_invalid",
+            message: "DID signature verification failed: missing timestamp"
+          });
+        }
+        const agentTags = this.config.tags ?? [];
+        const allowed = verifier.evaluatePolicy(
+          [],
+          // caller tags (not resolvable without control plane)
+          agentTags,
+          // target tags (this agent's own tags)
+          funcName,
+          typeof req.body === "object" && req.body !== null ? req.body : {}
+        );
+        if (!allowed) {
+          return res.status(403).json({
+            error: "policy_denied",
+            message: "Access denied by policy"
+          });
+        }
+        next();
+      });
+    }
     this.app.post("/api/v1/reasoners/*", (req, res) => this.executeReasoner(req, res, req.params[0]));
     this.app.post("/reasoners/:name", (req, res) => this.executeReasoner(req, res, req.params.name));
     this.app.post("/api/v1/skills/*", (req, res) => this.executeSkill(req, res, req.params[0]));
@@ -2201,7 +2678,10 @@ var Agent = class {
       if (err instanceof TargetNotFoundError) {
         res.status(404).json({ error: err.message });
       } else {
-        res.status(500).json({ error: err?.message ?? "Execution failed" });
+        const body = { error: err?.message ?? "Execution failed" };
+        if (err?.responseData) body.error_details = err.responseData;
+        const statusCode = err?.status >= 400 ? err.status : 500;
+        res.status(statusCode).json(body);
       }
     }
   }
@@ -2220,7 +2700,10 @@ var Agent = class {
       if (err instanceof TargetNotFoundError) {
         res.status(404).json({ error: err.message });
       } else {
-        res.status(500).json({ error: err?.message ?? "Execution failed" });
+        const body = { error: err?.message ?? "Execution failed" };
+        if (err?.responseData) body.error_details = err.responseData;
+        const statusCode = err?.status >= 400 ? err.status : 500;
+        res.status(statusCode).json(body);
       }
     }
   }
@@ -2255,7 +2738,10 @@ var Agent = class {
       if (err instanceof TargetNotFoundError) {
         res.status(404).json({ error: err.message });
       } else {
-        res.status(500).json({ error: err?.message ?? "Execution failed" });
+        const body = { error: err?.message ?? "Execution failed" };
+        if (err?.responseData) body.error_details = err.responseData;
+        const statusCode = err?.status >= 400 ? err.status : 500;
+        res.status(statusCode).json(body);
       }
     }
   }
@@ -2440,24 +2926,32 @@ var Agent = class {
     return void 0;
   }
   reasonerDefinitions() {
-    return this.reasoners.all().map((r) => ({
-      id: r.name,
-      input_schema: toJsonSchema(r.options?.inputSchema),
-      output_schema: toJsonSchema(r.options?.outputSchema),
-      memory_config: r.options?.memoryConfig ?? {
-        auto_inject: [],
-        memory_retention: "",
-        cache_results: false
-      },
-      tags: r.options?.tags ?? []
-    }));
+    return this.reasoners.all().map((r) => {
+      const tags = r.options?.tags ?? [];
+      return {
+        id: r.name,
+        input_schema: toJsonSchema(r.options?.inputSchema),
+        output_schema: toJsonSchema(r.options?.outputSchema),
+        memory_config: r.options?.memoryConfig ?? {
+          auto_inject: [],
+          memory_retention: "",
+          cache_results: false
+        },
+        tags,
+        proposed_tags: tags
+      };
+    });
   }
   skillDefinitions() {
-    return this.skills.all().map((s) => ({
-      id: s.name,
-      input_schema: toJsonSchema(s.options?.inputSchema),
-      tags: s.options?.tags ?? []
-    }));
+    return this.skills.all().map((s) => {
+      const tags = s.options?.tags ?? [];
+      return {
+        id: s.name,
+        input_schema: toJsonSchema(s.options?.inputSchema),
+        tags,
+        proposed_tags: tags
+      };
+    });
   }
   discoveryPayload(deploymentType) {
     return {
@@ -2526,7 +3020,10 @@ var Agent = class {
         return result;
       } catch (err) {
         if (params.respond && params.res) {
-          params.res.status(500).json({ error: err?.message ?? "Execution failed" });
+          const body = { error: err?.message ?? "Execution failed" };
+          if (err?.responseData) body.error_details = err.responseData;
+          const statusCode = err?.status >= 400 ? err.status : err?.statusCode >= 400 ? err.statusCode : 500;
+          params.res.status(statusCode).json(body);
           return;
         }
         throw err;
@@ -2565,7 +3062,10 @@ var Agent = class {
         return result;
       } catch (err) {
         if (params.respond && params.res) {
-          params.res.status(500).json({ error: err?.message ?? "Execution failed" });
+          const body = { error: err?.message ?? "Execution failed" };
+          if (err?.responseData) body.error_details = err.responseData;
+          const statusCode = err?.status >= 400 ? err.status : err?.statusCode >= 400 ? err.statusCode : 500;
+          params.res.status(statusCode).json(body);
           return;
         }
         throw err;
@@ -2579,15 +3079,24 @@ var Agent = class {
       const port = this.config.port ?? 8001;
       const hostForUrl = this.config.publicUrl ? void 0 : this.config.host && this.config.host !== "0.0.0.0" ? this.config.host : "127.0.0.1";
       const publicUrl = this.config.publicUrl ?? `http://${hostForUrl ?? "127.0.0.1"}:${port}`;
-      await this.agentFieldClient.register({
+      const agentTags = this.config.tags ?? [];
+      const regResponse = await this.agentFieldClient.register({
         id: this.config.nodeId,
-        version: this.config.version,
+        version: this.config.version ?? "",
         base_url: publicUrl,
         public_url: publicUrl,
         deployment_type: this.config.deploymentType ?? "long_running",
         reasoners,
-        skills
+        skills,
+        proposed_tags: agentTags,
+        tags: agentTags
       });
+      if (regResponse?.status === "pending_approval") {
+        const pendingTags = regResponse.pending_tags ?? [];
+        console.log(`[AgentField] Node ${this.config.nodeId} registered but awaiting tag approval (pending tags: ${pendingTags.join(", ")})`);
+        await this.waitForApproval();
+        console.log(`[AgentField] Node ${this.config.nodeId} tag approval granted`);
+      }
       if (this.config.didEnabled) {
         try {
           const didRegistered = await this.didManager.registerAgent(reasoners, skills);
@@ -2595,6 +3104,10 @@ var Agent = class {
             const summary = this.didManager.getIdentitySummary();
             console.log(`[DID] Agent registered with DID: ${summary.agentDid}`);
             console.log(`[DID] Reasoner DIDs: ${summary.reasonerCount}, Skill DIDs: ${summary.skillCount}`);
+            const pkg = this.didManager.getIdentityPackage();
+            if (pkg?.agentDid?.did && pkg?.agentDid?.privateKeyJwk) {
+              this.agentFieldClient.setDIDCredentials(pkg.agentDid.did, pkg.agentDid.privateKeyJwk);
+            }
           }
         } catch (didErr) {
           if (!this.config.devMode) {
@@ -2609,6 +3122,27 @@ var Agent = class {
       console.warn("Control plane registration failed (devMode=true), continuing locally", err);
     }
   }
+  async waitForApproval() {
+    const pollInterval = 5e3;
+    const timeoutMs = 5 * 60 * 1e3;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      try {
+        const node = await this.agentFieldClient.getNode(this.config.nodeId);
+        const status = node?.lifecycle_status;
+        if (status && status !== "pending_approval") {
+          return;
+        }
+        console.log(`[AgentField] Node ${this.config.nodeId} still pending approval...`);
+      } catch (err) {
+        console.warn("[AgentField] Polling for approval status failed:", err);
+      }
+    }
+    throw new Error(
+      `[AgentField] Node ${this.config.nodeId} approval timed out after ${timeoutMs / 1e3}s`
+    );
+  }
   startHeartbeat() {
     const interval = this.config.heartbeatIntervalMs ?? 3e4;
     if (interval <= 0) return;
@@ -2685,6 +3219,6 @@ function sanitize(value) {
   return value.replace(/[^0-9a-zA-Z]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
 }
 
-export { AIClient, Agent, AgentRouter, DidClient, DidInterface, DidManager, ExecutionContext, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryEventClient, MemoryInterface, RateLimitError, ReasonerContext, SkillContext, StatelessRateLimiter, WorkflowReporter, getCurrentContext, getCurrentSkillContext };
+export { AIClient, Agent, AgentRouter, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryEventClient, MemoryInterface, RateLimitError, ReasonerContext, SkillContext, StatelessRateLimiter, WorkflowReporter, getCurrentContext, getCurrentSkillContext };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map