@axiom-lattice/gateway 3.0.9 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "3.0.9",
+  "version": "4.0.0",
   "main": "dist/index.js",
   "files": [
     "dist"
@@ -19,6 +19,7 @@
   "license": "ISC",
   "description": "API Gateway for LangGraph agent-based applications",
   "dependencies": {
+    "@a2a-js/sdk": "^0.3.13",
     "@fastify/cors": "^11.0.0",
     "@fastify/http-proxy": "^9.5.0",
     "@fastify/multipart": "^9.4.0",
@@ -42,13 +43,14 @@
     "pino-pretty": "^13.0.0",
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
+    "tar": "^7.5.22",
     "uuid": "^9.0.1",
     "zod": "3.25.76",
-    "@axiom-lattice/cli-a2a": "0.1.10",
-    "@axiom-lattice/core": "3.1.1",
-    "@axiom-lattice/pg-stores": "2.0.9",
-    "@axiom-lattice/protocols": "3.0.4",
-    "@axiom-lattice/queue-redis": "1.0.58"
+    "@axiom-lattice/cli-a2a": "0.1.11",
+    "@axiom-lattice/core": "4.0.0",
+    "@axiom-lattice/pg-stores": "3.0.0",
+    "@axiom-lattice/protocols": "4.0.0",
+    "@axiom-lattice/queue-redis": "1.0.59"
   },
   "devDependencies": {
     "@types/bcrypt": "^6.0.0",

package/dist/a2a-QMHEH3ZT.mjs

@@ -1,615 +0,0 @@
-// 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 contextThreadMap = /* @__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, contextId, sendEvent, onInterrupt) {
-  let accumulatedText = "";
-  let interrupted = false;
-  for await (const chunk of stream) {
-    const chunkText = chunk.data?.content || "";
-    const chunkType = chunk.type;
-    if (chunkType === MessageChunkTypes.INTERRUPT) {
-      sendEvent("status-update", {
-        id: taskId,
-        contextId,
-        status: {
-          state: "input-required",
-          message: {
-            role: "agent",
-            parts: [buildTextPart(accumulatedText)]
-          },
-          timestamp: isoNow()
-        },
-        final: false
-      });
-      onInterrupt?.();
-      interrupted = true;
-      break;
-    }
-    if (chunkType === MessageChunkTypes.AI || chunkType === MessageChunkTypes.TOOL) {
-      if (chunkText) {
-        accumulatedText += chunkText;
-        sendEvent("status-update", {
-          id: taskId,
-          contextId,
-          status: {
-            state: "working",
-            message: {
-              role: "agent",
-              parts: [buildTextPart(chunkText)]
-            },
-            timestamp: isoNow()
-          },
-          final: false
-        });
-      }
-    }
-  }
-  return { text: accumulatedText, interrupted };
-}
-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 contextId = body.message.contextId;
-  const referenceTaskIds = body.message.referenceTaskIds;
-  const taskId = body.id || v4();
-  let threadId;
-  let resolvedReferenceTaskIds;
-  if (body.id) {
-    const existingTask = taskStore.get(body.id);
-    if (existingTask) {
-      if (existingTask.status === "input-required") {
-        threadId = existingTask.threadId;
-        resolvedReferenceTaskIds = referenceTaskIds;
-      } else if (existingTask.status === "completed" || existingTask.status === "failed" || existingTask.status === "canceled") {
-        threadId = v4();
-        resolvedReferenceTaskIds = referenceTaskIds ? [...referenceTaskIds, body.id] : [body.id];
-      } else {
-        threadId = v4();
-        resolvedReferenceTaskIds = referenceTaskIds;
-      }
-    } else {
-      threadId = v4();
-      resolvedReferenceTaskIds = referenceTaskIds ? [...referenceTaskIds, body.id] : [body.id];
-    }
-  } else if (contextId && contextThreadMap.has(contextId)) {
-    threadId = contextThreadMap.get(contextId);
-    console.warn({
-      event: "a2a:deprecated:contextId_thread_reuse",
-      message: "contextId-based thread reuse is deprecated; use referenceTaskIds and application-layer conversation state instead",
-      contextId,
-      threadId
-    });
-    resolvedReferenceTaskIds = referenceTaskIds;
-  } else {
-    threadId = v4();
-    resolvedReferenceTaskIds = referenceTaskIds;
-  }
-  const tenantId = auth.tenantId || config.defaultTenantId;
-  const now = isoNow();
-  const record = {
-    id: taskId,
-    threadId,
-    contextId,
-    referenceTaskIds: resolvedReferenceTaskIds,
-    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 { text: accumulatedText, interrupted } = await streamChunksAsA2A(stream, taskId, contextId, sendEvent, () => {
-      record.status = "input-required";
-      record.updatedAt = isoNow();
-    });
-    if (!interrupted) {
-      record.status = "completed";
-      record.updatedAt = isoNow();
-      record.history.push({
-        role: "agent",
-        parts: [buildTextPart(accumulatedText)]
-      });
-      sendEvent("status-update", {
-        id: taskId,
-        contextId,
-        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,
-      contextId,
-      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,
-      contextId: record.contextId,
-      status: {
-        state: record.status,
-        timestamp: record.updatedAt
-      },
-      final: true
-    });
-    reply.raw.end();
-    return;
-  }
-  try {
-    const stream = agent.chunkStream(record.messageId, [
-      MessageChunkTypes.MESSAGE_COMPLETED
-    ]);
-    const { interrupted } = await streamChunksAsA2A(stream, taskId, record.contextId, sendEvent);
-    if (!interrupted) {
-      sendEvent("status-update", {
-        id: taskId,
-        contextId: record.contextId,
-        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-QMHEH3ZT.mjs.map