@axiom-lattice/core 2.1.77 → 2.1.78

package/dist/index.js

@@ -52,7 +52,8 @@ __export(index_exports, {
   EmbeddingsLatticeManager: () => EmbeddingsLatticeManager,
   FileSystemSkillStore: () => FileSystemSkillStore,
   FilesystemBackend: () => FilesystemBackend,
-  HumanMessage: () => import_messages5.HumanMessage,
+  HumanMessage: () => import_messages6.HumanMessage,
+  InMemoryA2AApiKeyStore: () => InMemoryA2AApiKeyStore,
   InMemoryAssistantStore: () => InMemoryAssistantStore,
   InMemoryBindingStore: () => InMemoryBindingStore,
   InMemoryChannelInstallationStore: () => InMemoryChannelInstallationStore,
@@ -1894,6 +1895,7 @@ var InMemoryProjectStore = class {
       workspaceId,
       name: data.name,
       description: data.description,
+      config: data.config,
       createdAt: now,
       updatedAt: now
     };
@@ -1901,6 +1903,13 @@ var InMemoryProjectStore = class {
     this.projects.set(key, project);
     return project;
   }
+  /**
+   * Update an existing project
+   *
+   * @remarks
+   * - The `config` field uses **replace** semantics: if provided, it completely
+   *   overwrites the existing config. To preserve the current config, omit this field.
+   */
   async updateProject(tenantId, id, updates) {
     const key = this.getKey(tenantId, id);
     const existing = this.projects.get(key);
@@ -2908,6 +2917,87 @@ var InMemoryBindingStore = class {
   }
 };
 
+// src/store_lattice/InMemoryA2AApiKeyStore.ts
+var import_crypto2 = require("crypto");
+function generateApiKey() {
+  return `a2a_${(0, import_crypto2.randomUUID)().replace(/-/g, "")}`;
+}
+var InMemoryA2AApiKeyStore = class {
+  constructor() {
+    this.keys = /* @__PURE__ */ new Map();
+  }
+  async findByKey(key) {
+    for (const record of this.keys.values()) {
+      if (record.key === key && record.enabled) return record;
+    }
+    return null;
+  }
+  async list(params) {
+    let records = Array.from(this.keys.values());
+    if (params.tenantId) {
+      records = records.filter((r) => r.tenantId === params.tenantId);
+    }
+    const offset = params.offset || 0;
+    const limit = params.limit;
+    records = records.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return limit ? records.slice(offset, offset + limit) : records.slice(offset);
+  }
+  async create(input) {
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      id: (0, import_crypto2.randomUUID)(),
+      key: generateApiKey(),
+      tenantId: input.tenantId,
+      projectId: input.projectId,
+      workspaceId: input.workspaceId,
+      label: input.label,
+      enabled: true,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.keys.set(record.id, record);
+    return record;
+  }
+  async disable(id) {
+    const record = this.keys.get(id);
+    if (!record) throw new Error(`A2A API key not found: ${id}`);
+    const updated = { ...record, enabled: false, updatedAt: /* @__PURE__ */ new Date() };
+    this.keys.set(id, updated);
+    return updated;
+  }
+  async enable(id) {
+    const record = this.keys.get(id);
+    if (!record) throw new Error(`A2A API key not found: ${id}`);
+    const updated = { ...record, enabled: true, updatedAt: /* @__PURE__ */ new Date() };
+    this.keys.set(id, updated);
+    return updated;
+  }
+  async rotate(id) {
+    const record = this.keys.get(id);
+    if (!record) throw new Error(`A2A API key not found: ${id}`);
+    const updated = { ...record, key: generateApiKey(), updatedAt: /* @__PURE__ */ new Date() };
+    this.keys.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.keys.delete(id);
+  }
+  async loadIntoMap() {
+    const map = /* @__PURE__ */ new Map();
+    for (const record of this.keys.values()) {
+      if (record.enabled) {
+        map.set(record.key, {
+          key: record.key,
+          tenantId: record.tenantId,
+          projectId: record.projectId,
+          workspaceId: record.workspaceId
+        });
+      }
+    }
+    return map;
+  }
+};
+
 // src/store_lattice/StoreLatticeManager.ts
 var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
   /**
@@ -3082,6 +3172,12 @@ storeLatticeManager.registerLattice(
   "channelBinding",
   defaultChannelBindingStore
 );
+var defaultA2AApiKeyStore = new InMemoryA2AApiKeyStore();
+storeLatticeManager.registerLattice(
+  "default",
+  "a2aApiKey",
+  defaultA2AApiKeyStore
+);
 
 // src/tool_lattice/manage_binding/index.ts
 function getInstallationStore() {
@@ -7169,7 +7265,7 @@ var createBrowserGetInfoTool = ({ vmIsolation }) => {
 };
 
 // src/index.ts
-var import_messages5 = require("@langchain/core/messages");
+var import_messages6 = require("@langchain/core/messages");
 
 // src/agent_lattice/types.ts
 var import_protocols = require("@axiom-lattice/protocols");
@@ -18276,6 +18372,227 @@ var ProcessingAgentGraphBuilder = class {
   }
 };
 
+// src/agent_lattice/builders/RemoteAgentGraphBuilder.ts
+var import_langgraph14 = require("@langchain/langgraph");
+var import_messages5 = require("@langchain/core/messages");
+
+// src/services/a2a-client.ts
+var import_uuid4 = require("uuid");
+var A2ARemoteError = class extends Error {
+  constructor(message, statusCode, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.name = "A2ARemoteError";
+  }
+};
+var A2ARemoteClient = class {
+  constructor(config) {
+    this.config = config;
+    this.jsonRpcUrl = null;
+    this.card = null;
+  }
+  // ── Resolution ───────────────────────────────────────────────────────────
+  /**
+   * Fetch the agent card and resolve the JSON-RPC endpoint.
+   */
+  async resolve() {
+    if (this.card) return this.card;
+    const resp = await fetch(this.config.agentCardUrl, {
+      signal: AbortSignal.timeout(this.config.timeout ?? 3e4)
+    });
+    if (!resp.ok) {
+      throw new A2ARemoteError(
+        `Failed to fetch agent card: HTTP ${resp.status}`,
+        resp.status
+      );
+    }
+    this.card = await resp.json();
+    const card = this.card;
+    const jsonRpc = card.additionalInterfaces?.find(
+      (i) => i.transport === "JSONRPC"
+    );
+    this.jsonRpcUrl = jsonRpc?.url ?? card.url;
+    return this.card;
+  }
+  // ── Execute ──────────────────────────────────────────────────────────────
+  /**
+   * Send a text prompt to the remote A2A agent and return the response.
+   *
+   * Supports SSE streaming (parses status-update events) and falls back
+   * to polling the task status for non-streaming agents.
+   */
+  async sendMessage(text) {
+    await this.resolve();
+    const taskId = (0, import_uuid4.v4)();
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      method: "tasks/send",
+      params: {
+        id: taskId,
+        message: {
+          role: "user",
+          parts: [{ kind: "text", text }]
+        }
+      },
+      id: taskId
+    });
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "text/event-stream"
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    const resp = await fetch(this.jsonRpcUrl, {
+      method: "POST",
+      headers,
+      body,
+      signal: AbortSignal.timeout(this.config.timeout ?? 3e5)
+    });
+    if (!resp.ok) {
+      const text2 = await resp.text().catch(() => "");
+      throw new A2ARemoteError(
+        `A2A request failed: HTTP ${resp.status}`,
+        resp.status,
+        text2
+      );
+    }
+    const contentType = resp.headers.get("content-type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      return this.parseSSE(resp);
+    }
+    const json = await resp.json();
+    return this.extractArtifactText(json);
+  }
+  // ── SSE Parsing ──────────────────────────────────────────────────────────
+  async parseSSE(resp) {
+    if (!resp.body) {
+      throw new A2ARemoteError("Empty response body");
+    }
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer2 = "";
+    let accumulatedText = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer2 += decoder.decode(value, { stream: true });
+        const lines = buffer2.split("\n");
+        buffer2 = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6).trim();
+            if (!data) continue;
+            try {
+              const event = JSON.parse(data);
+              this.handleSSEEvent(event, (t) => {
+                accumulatedText += t;
+              });
+            } catch {
+            }
+          }
+        }
+      }
+      if (buffer2.startsWith("data: ")) {
+        const data = buffer2.slice(6).trim();
+        if (data) {
+          try {
+            const event = JSON.parse(data);
+            this.handleSSEEvent(event, (t) => {
+              accumulatedText += t;
+            });
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return accumulatedText;
+  }
+  handleSSEEvent(event, onText) {
+    const e = event;
+    const messageParts = e.status?.message?.parts;
+    if (messageParts) {
+      for (const part of messageParts) {
+        if (part.text) onText(part.text);
+      }
+    }
+  }
+  // ── Artifact Extraction ──────────────────────────────────────────────────
+  extractArtifactText(task) {
+    const artifacts = task.artifacts ?? [];
+    return artifacts.flatMap((a) => a.parts ?? []).filter((p) => p.text).map((p) => p.text).join("\n");
+  }
+};
+
+// src/agent_lattice/builders/RemoteAgentGraphBuilder.ts
+var import_protocols9 = require("@axiom-lattice/protocols");
+var RemoteAgentGraphBuilder = class {
+  async build(agentLattice, params) {
+    if (agentLattice.config.type !== import_protocols9.AgentType.A2A_REMOTE) {
+      throw new Error(
+        `RemoteAgentGraphBuilder received wrong agent type: ${agentLattice.config.type}`
+      );
+    }
+    const config = agentLattice.config;
+    const client = new A2ARemoteClient({
+      agentCardUrl: config.agentCardUrl,
+      apiKey: config.apiKey,
+      timeout: config.timeout
+    });
+    await client.resolve();
+    const remoteCallNode = async (state) => {
+      const messages = state.messages ?? [];
+      const text = extractLastHumanMessage(messages);
+      if (!text) {
+        return {
+          messages: [
+            new import_messages5.AIMessage("No text input provided to remote agent.")
+          ]
+        };
+      }
+      try {
+        const fullPrompt = params.prompt ? `${params.prompt}
+
+User request:
+${text}` : text;
+        const response = await client.sendMessage(fullPrompt);
+        return {
+          messages: [new import_messages5.AIMessage(response)]
+        };
+      } catch (error) {
+        const msg = error.message ?? String(error);
+        return {
+          messages: [
+            new import_messages5.AIMessage(`Remote A2A agent error: ${msg}`)
+          ]
+        };
+      }
+    };
+    const workflow = new import_langgraph14.StateGraph(import_langgraph14.MessagesAnnotation).addNode("remote_call", remoteCallNode).addEdge("__start__", "remote_call").addEdge("remote_call", "__end__");
+    return workflow.compile();
+  }
+};
+function extractLastHumanMessage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg._getType() === "human") {
+      const content = msg.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        return content.filter(
+          (c) => typeof c === "object" && c !== null && c.type === "text"
+        ).map((c) => c.text).join("\n");
+      }
+      return String(content);
+    }
+  }
+  return "";
+}
+
 // src/agent_lattice/builders/AgentGraphBuilderFactory.ts
 var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
   constructor() {
@@ -18299,6 +18616,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
     this.builders.set(import_protocols.AgentType.DEEP_AGENT, new DeepAgentGraphBuilder());
     this.builders.set(import_protocols.AgentType.TEAM, new TeamAgentGraphBuilder());
     this.builders.set(import_protocols.AgentType.PROCESSING, new ProcessingAgentGraphBuilder());
+    this.builders.set(import_protocols.AgentType.A2A_REMOTE, new RemoteAgentGraphBuilder());
   }
   /**
    * 注册自定义Builder
@@ -18325,7 +18643,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
 };
 
 // src/agent_lattice/builders/AgentParamsBuilder.ts
-var import_protocols9 = require("@axiom-lattice/protocols");
+var import_protocols10 = require("@axiom-lattice/protocols");
 var AgentParamsBuilder = class {
   /**
    * constructor
@@ -18343,8 +18661,8 @@ var AgentParamsBuilder = class {
    * @returns Agent build parameters
    */
   async buildParams(agentLattice, options) {
-    const skills = (0, import_protocols9.isDeepAgentConfig)(agentLattice.config) || (0, import_protocols9.isProcessingAgentConfig)(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
-    const toolKeys = options?.overrideTools || (0, import_protocols9.getToolsFromConfig)(agentLattice.config);
+    const skills = (0, import_protocols10.isDeepAgentConfig)(agentLattice.config) || (0, import_protocols10.isProcessingAgentConfig)(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
+    const toolKeys = options?.overrideTools || (0, import_protocols10.getToolsFromConfig)(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
       const toolLattice = toolLatticeManager.getToolLattice(toolKey);
       if (!toolLattice) {
@@ -18361,7 +18679,7 @@ var AgentParamsBuilder = class {
     if (!model) {
       throw new Error(`Model "${modelKey}" does not exist`);
     }
-    const subAgentKeys = (0, import_protocols9.getSubAgentsFromConfig)(agentLattice.config);
+    const subAgentKeys = (0, import_protocols10.getSubAgentsFromConfig)(agentLattice.config);
     const subAgents = await Promise.all(subAgentKeys.map(async (agentKey) => {
       const subAgentLattice = await this.getAgentLatticeFunc(agentKey);
       if (!subAgentLattice) {
@@ -18374,7 +18692,7 @@ var AgentParamsBuilder = class {
       };
     }));
     let internalSubAgents = [];
-    if ((0, import_protocols9.isDeepAgentConfig)(agentLattice.config) || (0, import_protocols9.isProcessingAgentConfig)(agentLattice.config)) {
+    if ((0, import_protocols10.isDeepAgentConfig)(agentLattice.config) || (0, import_protocols10.isProcessingAgentConfig)(agentLattice.config)) {
       internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
         key: i.key,
         config: i
@@ -18970,8 +19288,8 @@ ${body}` : `${frontmatter}
 
 // src/agent_lattice/agentArchitectTools.ts
 var import_zod53 = __toESM(require("zod"));
-var import_uuid4 = require("uuid");
-var import_protocols10 = require("@axiom-lattice/protocols");
+var import_uuid5 = require("uuid");
+var import_protocols11 = require("@axiom-lattice/protocols");
 function getTenantId(exeConfig) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
   return runConfig.tenantId || "default";
@@ -19079,7 +19397,7 @@ registerToolLattice(
         key: id,
         name: input.name,
         description: input.description || "",
-        type: input.type === "deep_agent" ? import_protocols10.AgentType.DEEP_AGENT : import_protocols10.AgentType.REACT,
+        type: input.type === "deep_agent" ? import_protocols11.AgentType.DEEP_AGENT : import_protocols11.AgentType.REACT,
         prompt: input.prompt,
         ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
         ...input.middleware && input.middleware.length > 0 ? { middleware: input.middleware } : {},
@@ -19168,7 +19486,7 @@ registerToolLattice(
         key: id,
         name: input.name,
         description: input.description || "",
-        type: import_protocols10.AgentType.PROCESSING,
+        type: import_protocols11.AgentType.PROCESSING,
         prompt: input.prompt,
         ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
         middleware,
@@ -19236,7 +19554,7 @@ registerToolLattice(
         return JSON.stringify({ error: `Agent '${input.id}' not found` });
       }
       const existingConfig = existing.graphDefinition || {};
-      if (existingConfig.type !== import_protocols10.AgentType.PROCESSING) {
+      if (existingConfig.type !== import_protocols11.AgentType.PROCESSING) {
         return JSON.stringify({ error: `Agent '${input.id}' is not a PROCESSING agent (type: ${existingConfig.type})` });
       }
       const normalize = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
@@ -19444,7 +19762,7 @@ registerToolLattice(
       if (!existing) {
         return JSON.stringify({ error: `Agent '${id}' not found` });
       }
-      const threadId = (0, import_uuid4.v4)();
+      const threadId = (0, import_uuid5.v4)();
       const agent = new Agent({
         tenant_id: tenantId,
         assistant_id: id,
@@ -19468,7 +19786,7 @@ registerToolLattice(
 );
 
 // src/agent_lattice/agentArchitectConfig.ts
-var import_protocols12 = require("@axiom-lattice/protocols");
+var import_protocols13 = require("@axiom-lattice/protocols");
 
 // src/agent_lattice/agentArchitectPrompt.ts
 var AGENT_ARCHITECT_PROMPT = `# Agent Architect
@@ -20108,7 +20426,7 @@ Updates a PROCESSING agent's topology edges, name, prompt, or sub-agents. Unlike
 `;
 
 // src/agent_lattice/agentReviewerConfig.ts
-var import_protocols11 = require("@axiom-lattice/protocols");
+var import_protocols12 = require("@axiom-lattice/protocols");
 
 // src/agent_lattice/agentReviewerPrompt.ts
 var AGENT_REVIEWER_PROMPT = `# Agent Reviewer
@@ -20171,7 +20489,7 @@ var agentReviewerConfig = {
   key: AGENT_REVIEWER_KEY,
   name: "Agent Reviewer",
   description: "Review and test AI agents. Use this agent to check agent configurations for correctness and to test agents by invoking them with realistic messages.",
-  type: import_protocols11.AgentType.REACT,
+  type: import_protocols12.AgentType.REACT,
   prompt: AGENT_REVIEWER_PROMPT,
   tools: [
     "invoke_agent",
@@ -20197,7 +20515,7 @@ var agentArchitectConfig = {
   key: AGENT_ARCHITECT_KEY,
   name: "Agent Architect",
   description: "Design and manage AI agents through natural language conversation. Use this agent when you want to create a new agent, modify an existing agent, or manage your agent collection (list, view, update, delete).",
-  type: import_protocols12.AgentType.DEEP_AGENT,
+  type: import_protocols13.AgentType.DEEP_AGENT,
   prompt: AGENT_ARCHITECT_PROMPT,
   tools: [
     "list_agents",
@@ -20863,7 +21181,7 @@ var getVectorStoreLattice = (key) => vectorStoreLatticeManager.getVectorStoreLat
 var getVectorStoreClient = (key) => vectorStoreLatticeManager.getVectorStoreClient(key);
 
 // src/logger_lattice/LoggerLatticeManager.ts
-var import_protocols13 = require("@axiom-lattice/protocols");
+var import_protocols14 = require("@axiom-lattice/protocols");
 
 // src/logger_lattice/PinoLoggerClient.ts
 var import_pino = __toESM(require("pino"));
@@ -21085,11 +21403,11 @@ var LoggerLatticeManager = class _LoggerLatticeManager extends BaseLatticeManage
     if (client) {
       loggerClient = client;
     } else {
-      if (config.type === import_protocols13.LoggerType.PINO) {
+      if (config.type === import_protocols14.LoggerType.PINO) {
         loggerClient = new PinoLoggerClient(config);
-      } else if (config.type === import_protocols13.LoggerType.CONSOLE) {
+      } else if (config.type === import_protocols14.LoggerType.CONSOLE) {
         loggerClient = new ConsoleLoggerClient(config);
-      } else if (config.type === import_protocols13.LoggerType.CUSTOM) {
+      } else if (config.type === import_protocols14.LoggerType.CUSTOM) {
         throw new Error(
           `Custom logger client must be provided. Please pass the client to registerLattice.`
         );
@@ -22939,7 +23257,7 @@ function createSandboxProvider(config) {
 var Protocols = __toESM(require("@axiom-lattice/protocols"));
 
 // src/util/encryption.ts
-var import_crypto2 = require("crypto");
+var import_crypto3 = require("crypto");
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 var SALT_LENGTH = 32;
@@ -22952,7 +23270,7 @@ function getEncryptionKey() {
     return cachedKey;
   }
   const key = process.env.LATTICE_ENCRYPTION_KEY || DEFAULT_ENCRYPTION_KEY;
-  cachedKey = (0, import_crypto2.pbkdf2Sync)(key, "lattice-encryption-salt", ITERATIONS, 32, "sha256");
+  cachedKey = (0, import_crypto3.pbkdf2Sync)(key, "lattice-encryption-salt", ITERATIONS, 32, "sha256");
   if (!keyValidated) {
     keyValidated = true;
     validateEncryptionKey();
@@ -22961,10 +23279,10 @@ function getEncryptionKey() {
 }
 function encrypt(plaintext, key) {
   const actualKey = key || getEncryptionKey();
-  const salt = (0, import_crypto2.randomBytes)(SALT_LENGTH);
-  const iv = (0, import_crypto2.randomBytes)(IV_LENGTH);
-  const derivedKey = (0, import_crypto2.pbkdf2Sync)(actualKey, salt, ITERATIONS, 32, "sha256");
-  const cipher = (0, import_crypto2.createCipheriv)(ALGORITHM, derivedKey, iv);
+  const salt = (0, import_crypto3.randomBytes)(SALT_LENGTH);
+  const iv = (0, import_crypto3.randomBytes)(IV_LENGTH);
+  const derivedKey = (0, import_crypto3.pbkdf2Sync)(actualKey, salt, ITERATIONS, 32, "sha256");
+  const cipher = (0, import_crypto3.createCipheriv)(ALGORITHM, derivedKey, iv);
   const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
   const authTag = cipher.getAuthTag();
   return Buffer.concat([salt, iv, encrypted, authTag]).toString("base64");
@@ -22976,8 +23294,8 @@ function decrypt(encrypted, key) {
   const iv = data.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
   const authTag = data.subarray(-16);
   const ciphertext = data.subarray(SALT_LENGTH + IV_LENGTH, -16);
-  const derivedKey = (0, import_crypto2.pbkdf2Sync)(actualKey, salt, ITERATIONS, 32, "sha256");
-  const decipher = (0, import_crypto2.createDecipheriv)(ALGORITHM, derivedKey, iv);
+  const derivedKey = (0, import_crypto3.pbkdf2Sync)(actualKey, salt, ITERATIONS, 32, "sha256");
+  const decipher = (0, import_crypto3.createDecipheriv)(ALGORITHM, derivedKey, iv);
   decipher.setAuthTag(authTag);
   return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
 }
@@ -23026,6 +23344,7 @@ function clearEncryptionKeyCache() {
   FileSystemSkillStore,
   FilesystemBackend,
   HumanMessage,
+  InMemoryA2AApiKeyStore,
   InMemoryAssistantStore,
   InMemoryBindingStore,
   InMemoryChannelInstallationStore,