@axiom-lattice/gateway 2.1.89 → 2.1.91

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @axiom-lattice/gateway@2.1.89 build /home/runner/work/agentic/agentic/packages/gateway
+> @axiom-lattice/gateway@2.1.91 build /home/runner/work/agentic/agentic/packages/gateway
 > tsup src/index.ts --format cjs,esm --dts --clean --sourcemap
 
 CLI Building entry: src/index.ts
@@ -11,22 +11,24 @@
 ESM Build start
 [warn] ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]
 
-    src/index.ts:175:33:
-      175 │ const __filename = fileURLToPath(import.meta.url);
+    src/index.ts:183:33:
+      183 │ const __filename = fileURLToPath(import.meta.url);
           ╵                                  ~~~~~~~~~~~
 
   You need to set the output format to "esm" for "import.meta" to work correctly.
 
 
-CJS dist/index.js     246.20 KB
-CJS dist/index.js.map 515.19 KB
-CJS ⚡️ Build success in 415ms
-ESM dist/index.mjs               241.30 KB
+CJS dist/index.js     268.14 KB
+CJS dist/index.js.map 560.68 KB
+CJS ⚡️ Build success in 480ms
+ESM dist/index.mjs               246.84 KB
 ESM dist/sender-PX32VSHB.mjs     873.00 B
+ESM dist/a2a-ERG5RMUW.mjs        15.95 KB
 ESM dist/sender-PX32VSHB.mjs.map 2.07 KB
-ESM dist/index.mjs.map           513.63 KB
-ESM ⚡️ Build success in 415ms
+ESM dist/a2a-ERG5RMUW.mjs.map    32.14 KB
+ESM dist/index.mjs.map           526.83 KB
+ESM ⚡️ Build success in 483ms
 DTS Build start
-DTS ⚡️ Build success in 14563ms
+DTS ⚡️ Build success in 14738ms
 DTS dist/index.d.ts  7.57 KB
 DTS dist/index.d.mts 7.57 KB

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @axiom-lattice/gateway
 
+## 2.1.91
+
+### Patch Changes
+
+- ec290af: sqlit store
+- Updated dependencies [ec290af]
+  - @axiom-lattice/core@2.1.79
+  - @axiom-lattice/protocols@2.1.41
+  - @axiom-lattice/agent-eval@2.1.73
+  - @axiom-lattice/pg-stores@1.0.70
+  - @axiom-lattice/queue-redis@1.0.40
+
+## 2.1.90
+
+### Patch Changes
+
+- b7cd409: enhance more features a2a, cli
+- Updated dependencies [b7cd409]
+  - @axiom-lattice/pg-stores@1.0.69
+  - @axiom-lattice/protocols@2.1.40
+  - @axiom-lattice/core@2.1.78
+  - @axiom-lattice/agent-eval@2.1.72
+  - @axiom-lattice/queue-redis@1.0.39
+
 ## 2.1.89
 
 ### Patch Changes

package/dist/a2a-ERG5RMUW.mjs

@@ -0,0 +1,567 @@
+// src/routes/a2a.ts
+import { v4 } from "uuid";
+import {
+  agentInstanceManager
+} from "@axiom-lattice/core";
+import { MessageChunkTypes } from "@axiom-lattice/protocols";
+var taskStore = /* @__PURE__ */ new Map();
+var _a2aKeyStore = null;
+var _storeKeyMap = /* @__PURE__ */ new Map();
+function setA2AKeyStore(store) {
+  _a2aKeyStore = store;
+}
+async function refreshStoreKeyMap() {
+  if (!_a2aKeyStore) return;
+  _storeKeyMap = await _a2aKeyStore.loadIntoMap();
+}
+function parseEnvKeyMap() {
+  const keysEnv = process.env.A2A_API_KEYS || "";
+  const defaultTenantId = process.env.A2A_DEFAULT_TENANT_ID || "a2a-default-tenant";
+  const defaultProjectId = process.env.A2A_DEFAULT_PROJECT_ID || "";
+  const defaultWorkspaceId = process.env.A2A_DEFAULT_WORKSPACE_ID || "";
+  const map = /* @__PURE__ */ new Map();
+  if (keysEnv) {
+    keysEnv.split(",").forEach((entry) => {
+      const trimmed = entry.trim();
+      if (!trimmed) return;
+      const parts = trimmed.split(":");
+      const key = parts[0];
+      if (!key) return;
+      map.set(key, {
+        key,
+        tenantId: parts[1]?.trim() || defaultTenantId,
+        projectId: parts[2]?.trim() || defaultProjectId || void 0,
+        workspaceId: parts[3]?.trim() || defaultWorkspaceId || void 0
+      });
+    });
+  }
+  return map;
+}
+function getA2AConfig() {
+  const envMap = parseEnvKeyMap();
+  const apiKeyMap = new Map([..._storeKeyMap, ...envMap]);
+  return {
+    agentName: process.env.A2A_AGENT_NAME || "Axiom Lattice Agent",
+    agentDescription: process.env.A2A_AGENT_DESCRIPTION || "AI agent powered by Axiom Lattice framework",
+    organization: process.env.A2A_ORGANIZATION || "Axiom Lattice",
+    organizationUrl: process.env.A2A_ORGANIZATION_URL || "https://axiom-lattice.ai",
+    version: process.env.A2A_VERSION || "1.0.0",
+    defaultAssistantId: process.env.A2A_DEFAULT_AGENT_ID || "",
+    defaultTenantId: process.env.A2A_DEFAULT_TENANT_ID || "a2a-default-tenant",
+    defaultProjectId: process.env.A2A_DEFAULT_PROJECT_ID || "",
+    defaultWorkspaceId: process.env.A2A_DEFAULT_WORKSPACE_ID || "",
+    apiKeyMap
+  };
+}
+function authenticateA2A(request) {
+  const config = getA2AConfig();
+  const noAuthRequired = config.apiKeyMap.size === 0;
+  const token = request.headers.authorization?.startsWith("Bearer ") ? request.headers.authorization.substring(7) : request.headers["x-api-key"];
+  if (!token) {
+    return {
+      authenticated: noAuthRequired,
+      tenantId: config.defaultTenantId,
+      projectId: config.defaultProjectId || void 0,
+      workspaceId: config.defaultWorkspaceId || void 0
+    };
+  }
+  const entry = config.apiKeyMap.get(token);
+  if (entry) {
+    return {
+      authenticated: true,
+      apiKey: token,
+      tenantId: entry.tenantId,
+      projectId: entry.projectId,
+      workspaceId: entry.workspaceId,
+      source: request.headers.authorization?.startsWith("Bearer ") ? "bearer" : "x-api-key"
+    };
+  }
+  return { authenticated: false };
+}
+function requireAuth(request, reply) {
+  const auth = authenticateA2A(request);
+  if (!auth.authenticated) {
+    reply.status(401).send({
+      error: "Unauthorized",
+      message: "Valid API key required via Bearer token or X-API-Key header"
+    });
+  }
+  return auth;
+}
+function buildAgentCard(baseUrl) {
+  const config = getA2AConfig();
+  return {
+    name: config.agentName,
+    description: config.agentDescription,
+    url: `${baseUrl}/api/a2a`,
+    provider: {
+      organization: config.organization,
+      url: config.organizationUrl
+    },
+    version: config.version,
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: false
+    },
+    defaultInputModes: ["text", "text/plain"],
+    defaultOutputModes: ["text", "text/plain", "text/markdown"],
+    skills: []
+  };
+}
+function extractTextFromParts(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+function buildTextPart(text) {
+  return { type: "text", text };
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function streamChunksAsA2A(stream, taskId, sendEvent, onInterrupt) {
+  let accumulatedText = "";
+  for await (const chunk of stream) {
+    const chunkText = chunk.data?.content || "";
+    const chunkType = chunk.type;
+    if (chunkType === MessageChunkTypes.INTERRUPT) {
+      sendEvent("status-update", {
+        id: taskId,
+        status: {
+          state: "input-required",
+          message: {
+            role: "agent",
+            parts: [buildTextPart(accumulatedText)]
+          },
+          timestamp: isoNow()
+        },
+        final: false
+      });
+      onInterrupt?.();
+      continue;
+    }
+    if (chunkType === MessageChunkTypes.AI || chunkType === MessageChunkTypes.TOOL) {
+      if (chunkText) {
+        accumulatedText += chunkText;
+        sendEvent("status-update", {
+          id: taskId,
+          status: {
+            state: "working",
+            message: {
+              role: "agent",
+              parts: [buildTextPart(chunkText)]
+            },
+            timestamp: isoNow()
+          },
+          final: false
+        });
+      }
+    }
+  }
+  return accumulatedText;
+}
+async function getTaskStatus(taskId) {
+  const record = taskStore.get(taskId);
+  if (!record) return null;
+  return {
+    id: record.id,
+    status: {
+      state: record.status,
+      timestamp: record.updatedAt
+    },
+    artifacts: [],
+    history: record.history
+  };
+}
+async function handleAgentCard(request, reply) {
+  const protocol = request.headers["x-forwarded-proto"] || request.protocol;
+  const host = request.hostname;
+  const baseUrl = `${protocol}://${host}`;
+  const card = buildAgentCard(baseUrl);
+  reply.status(200).send(card);
+}
+async function handleTasksGet(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  const task = await getTaskStatus(request.params.taskId);
+  if (!task) {
+    reply.status(404).send({ error: "Task not found" });
+    return;
+  }
+  reply.status(200).send(task);
+}
+async function handleTasksSend(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  const config = getA2AConfig();
+  const body = request.body;
+  if (!body.message || !body.message.parts || body.message.parts.length === 0) {
+    reply.status(400).send({ error: "message.parts is required" });
+    return;
+  }
+  const text = extractTextFromParts(body.message.parts);
+  if (!text.trim()) {
+    reply.status(400).send({ error: "message must contain text content" });
+    return;
+  }
+  const assistantId = request.headers["x-a2a-agent-id"] || config.defaultAssistantId;
+  if (!assistantId) {
+    reply.status(500).send({
+      error: "No agent configured",
+      message: "Set A2A_DEFAULT_AGENT_ID env var or provide x-a2a-agent-id header"
+    });
+    return;
+  }
+  const taskId = body.id || v4();
+  const threadId = v4();
+  const tenantId = auth.tenantId || config.defaultTenantId;
+  const now = isoNow();
+  const record = {
+    id: taskId,
+    threadId,
+    assistantId,
+    tenantId,
+    projectId: auth.projectId || void 0,
+    workspaceId: auth.workspaceId || void 0,
+    status: "working",
+    createdAt: now,
+    updatedAt: now,
+    history: [
+      {
+        role: "user",
+        parts: body.message.parts
+      }
+    ]
+  };
+  taskStore.set(taskId, record);
+  let agent;
+  try {
+    agent = agentInstanceManager.getAgent({
+      assistant_id: assistantId,
+      thread_id: threadId,
+      tenant_id: tenantId,
+      workspace_id: auth.workspaceId || void 0,
+      project_id: auth.projectId || void 0
+    });
+  } catch (err) {
+    record.status = "failed";
+    record.updatedAt = isoNow();
+    reply.status(500).send({
+      id: taskId,
+      error: "Failed to initialize agent",
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+  reply.hijack();
+  reply.raw.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "Access-Control-Allow-Origin": "*"
+  });
+  const sendEvent = (event, data) => {
+    reply.raw.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+  };
+  try {
+    const result = await agent.addMessage({
+      input: { message: text }
+    });
+    record.messageId = result.messageId;
+    const stream = agent.chunkStream(result.messageId, [
+      MessageChunkTypes.MESSAGE_COMPLETED
+    ]);
+    const accumulatedText = await streamChunksAsA2A(stream, taskId, sendEvent, () => {
+      record.status = "input-required";
+      record.updatedAt = isoNow();
+    });
+    record.status = "completed";
+    record.updatedAt = isoNow();
+    record.history.push({
+      role: "agent",
+      parts: [buildTextPart(accumulatedText)]
+    });
+    sendEvent("status-update", {
+      id: taskId,
+      status: {
+        state: "completed",
+        timestamp: isoNow()
+      },
+      final: true
+    });
+  } catch (err) {
+    record.status = "failed";
+    record.updatedAt = isoNow();
+    sendEvent("error", {
+      code: "EXECUTION_ERROR",
+      message: err instanceof Error ? err.message : String(err)
+    });
+    sendEvent("status-update", {
+      id: taskId,
+      status: {
+        state: "failed",
+        timestamp: isoNow()
+      },
+      final: true
+    });
+  } finally {
+    reply.raw.end();
+  }
+}
+async function handleTasksCancel(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  const { taskId } = request.params;
+  const record = taskStore.get(taskId);
+  if (!record) {
+    reply.status(404).send({ error: "Task not found" });
+    return;
+  }
+  if (record.status === "completed" || record.status === "failed" || record.status === "canceled") {
+    reply.status(409).send({
+      error: "Task is already in a terminal state",
+      task: { id: record.id, status: record.status }
+    });
+    return;
+  }
+  try {
+    const agent = agentInstanceManager.getAgent({
+      assistant_id: record.assistantId,
+      thread_id: record.threadId,
+      tenant_id: record.tenantId,
+      workspace_id: record.workspaceId,
+      project_id: record.projectId
+    });
+    await agent.abort();
+  } catch (err) {
+    console.warn({
+      event: "a2a:cancel:no_agent",
+      taskId,
+      threadId: record.threadId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  record.status = "canceled";
+  record.updatedAt = isoNow();
+  reply.status(200).send({
+    id: taskId,
+    status: {
+      state: "canceled",
+      timestamp: record.updatedAt
+    }
+  });
+}
+async function handleTasksStream(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  const { taskId } = request.params;
+  const record = taskStore.get(taskId);
+  if (!record) {
+    reply.status(404).send({ error: "Task not found" });
+    return;
+  }
+  let agent;
+  try {
+    agent = agentInstanceManager.getAgent({
+      assistant_id: record.assistantId,
+      thread_id: record.threadId,
+      tenant_id: record.tenantId,
+      workspace_id: record.workspaceId,
+      project_id: record.projectId
+    });
+  } catch {
+    reply.status(404).send({
+      error: "Agent session not found. The task may have already completed."
+    });
+    return;
+  }
+  reply.hijack();
+  reply.raw.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "Access-Control-Allow-Origin": "*"
+  });
+  const sendEvent = (event, data) => {
+    reply.raw.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+  };
+  if (!record.messageId) {
+    sendEvent("status-update", {
+      id: taskId,
+      status: {
+        state: record.status,
+        timestamp: record.updatedAt
+      },
+      final: true
+    });
+    reply.raw.end();
+    return;
+  }
+  try {
+    const stream = agent.chunkStream(record.messageId, [
+      MessageChunkTypes.MESSAGE_COMPLETED
+    ]);
+    await streamChunksAsA2A(stream, taskId, sendEvent);
+    sendEvent("status-update", {
+      id: taskId,
+      status: {
+        state: record.status,
+        timestamp: record.updatedAt
+      },
+      final: true
+    });
+  } catch (err) {
+    sendEvent("error", {
+      code: "STREAM_ERROR",
+      message: err instanceof Error ? err.message : String(err)
+    });
+  } finally {
+    reply.raw.end();
+  }
+}
+async function handleApiKeyList(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  if (!_a2aKeyStore) {
+    reply.status(501).send({ error: "Key store not configured" });
+    return;
+  }
+  const records = await _a2aKeyStore.list({
+    tenantId: request.query.tenantId,
+    limit: request.query.limit ? parseInt(request.query.limit, 10) : void 0,
+    offset: request.query.offset ? parseInt(request.query.offset, 10) : void 0
+  });
+  reply.status(200).send({
+    success: true,
+    data: {
+      records: records.map((r) => ({ ...r, key: r.key.slice(0, 8) + "..." })),
+      total: records.length
+    }
+  });
+}
+async function handleApiKeyCreate(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  if (!_a2aKeyStore) {
+    reply.status(501).send({ error: "Key store not configured" });
+    return;
+  }
+  const body = request.body;
+  const tenantId = body.tenantId || request.headers["x-tenant-id"] || auth.tenantId;
+  const projectId = body.projectId || request.headers["x-project-id"] || auth.projectId || "default";
+  const workspaceId = body.workspaceId || request.headers["x-workspace-id"] || auth.workspaceId;
+  if (!tenantId) {
+    reply.status(400).send({
+      error: "tenantId is required",
+      message: "Provide via body.tenantId, x-tenant-id header, or authenticate with a scoped API key"
+    });
+    return;
+  }
+  const record = await _a2aKeyStore.create({
+    tenantId,
+    projectId,
+    workspaceId,
+    label: body.label
+  });
+  await refreshStoreKeyMap();
+  reply.status(201).send({ success: true, data: record });
+}
+async function handleApiKeyDelete(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  if (!_a2aKeyStore) {
+    reply.status(501).send({ error: "Key store not configured" });
+    return;
+  }
+  await _a2aKeyStore.delete(request.params.id);
+  await refreshStoreKeyMap();
+  reply.status(200).send({ success: true });
+}
+async function handleApiKeyDisable(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  if (!_a2aKeyStore) {
+    reply.status(501).send({ error: "Key store not configured" });
+    return;
+  }
+  await _a2aKeyStore.disable(request.params.id);
+  await refreshStoreKeyMap();
+  reply.status(200).send({ success: true });
+}
+async function handleApiKeyEnable(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  if (!_a2aKeyStore) {
+    reply.status(501).send({ error: "Key store not configured" });
+    return;
+  }
+  await _a2aKeyStore.enable(request.params.id);
+  await refreshStoreKeyMap();
+  reply.status(200).send({ success: true });
+}
+async function handleApiKeyRotate(request, reply) {
+  const auth = requireAuth(request, reply);
+  if (!auth.authenticated) return;
+  if (!_a2aKeyStore) {
+    reply.status(501).send({ error: "Key store not configured" });
+    return;
+  }
+  const record = await _a2aKeyStore.rotate(request.params.id);
+  await refreshStoreKeyMap();
+  reply.status(200).send({ success: true, data: record });
+}
+function registerA2ARoutes(app) {
+  app.get("/api/a2a/.well-known/agent.json", handleAgentCard);
+  app.get("/api/a2a/.well-known/agent-card.json", handleAgentCard);
+  app.post(
+    "/api/a2a/tasks/send",
+    handleTasksSend
+  );
+  app.get(
+    "/api/a2a/tasks/:taskId",
+    handleTasksGet
+  );
+  app.get(
+    "/api/a2a/tasks/:taskId/stream",
+    handleTasksStream
+  );
+  app.post(
+    "/api/a2a/tasks/:taskId/cancel",
+    handleTasksCancel
+  );
+  app.get(
+    "/api/a2a/keys",
+    handleApiKeyList
+  );
+  app.post(
+    "/api/a2a/keys",
+    handleApiKeyCreate
+  );
+  app.delete(
+    "/api/a2a/keys/:id",
+    handleApiKeyDelete
+  );
+  app.post(
+    "/api/a2a/keys/:id/disable",
+    handleApiKeyDisable
+  );
+  app.post(
+    "/api/a2a/keys/:id/enable",
+    handleApiKeyEnable
+  );
+  app.post(
+    "/api/a2a/keys/:id/rotate",
+    handleApiKeyRotate
+  );
+}
+export {
+  refreshStoreKeyMap,
+  registerA2ARoutes,
+  setA2AKeyStore
+};
+//# sourceMappingURL=a2a-ERG5RMUW.mjs.map