@vellumai/vellum-gateway 0.8.2 → 0.8.3

package/ARCHITECTURE.md

@@ -298,7 +298,7 @@ The assistant runtime reads this URL via the centralized `public-ingress-urls.ts
 
 Velay is a platform-managed tunnel for assistant-hosted HTTP and WebSocket traffic. When it is active, Velay publishes the registered public assistant URL to `ingress.publicBaseUrl` and marks it with `ingress.publicBaseUrlManagedBy: "velay"`.
 
-When `VELAY_BASE_URL` is present in the gateway environment, the gateway creates `VelayTunnelClient` but starts it only after Twilio setup has been started in the workspace. On boot, existing Twilio credentials or existing `twilio.accountSid` / `twilio.phoneNumber` config count as prior setup, and successful credential setup persists `twilio.setupStarted: true` for future boots. Before credential-backed startup side effects run, the gateway clears any stale Velay-managed `ingress.publicBaseUrl`; if setup has not started, it does this without opening a tunnel. The client registers with Velay over `GET /v1/register` using the assistant API key, then receives a `registered` frame containing a public assistant URL such as `https://velay.vellum.ai/<assistant-id>`. The gateway writes that URL to `ingress.publicBaseUrl`. When the tunnel disconnects, it clears that value only if the Velay ownership marker is still present and the URL still matches what the tunnel published, leaving manual URLs intact.
+When `VELAY_BASE_URL` is present in the gateway environment, the gateway creates `VelayTunnelClient` but starts it only after Twilio setup has been started in the workspace. The Twilio setup skill writes `twilio.setupStarted: true` at the beginning of setup so the tunnel can open while credentials and phone-number selection are still in progress. On boot, existing Twilio credentials or existing `twilio.accountSid` / `twilio.phoneNumber` config also count as prior setup. Before credential-backed startup side effects run, the gateway clears any stale Velay-managed `ingress.publicBaseUrl`; if setup has not started, it does this without opening a tunnel. The client registers with Velay over `GET /v1/register` using the assistant API key, then receives a `registered` frame containing a public assistant URL such as `https://velay.vellum.ai/<assistant-id>`. If Vellum platform credentials change while the tunnel is already running or waiting on backoff, the gateway asks the client to reconnect with fresh credentials instead of waiting for process restart. The gateway writes the registered URL to `ingress.publicBaseUrl`. When the tunnel disconnects, it clears that value only if the Velay ownership marker is still present and the URL still matches what the tunnel published, leaving manual URLs intact.
 
 Velay forwards both HTTP request frames and WebSocket frames into the local gateway loopback listener:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/vellum-gateway",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/config-file-watcher.test.ts

@@ -42,6 +42,31 @@ function makeEvent(
   };
 }
 
+function makeManualIntervalTimer() {
+  let intervalFn: (() => void) | undefined;
+  let cleared = false;
+  type IntervalHandle = ReturnType<typeof setInterval>;
+  const timer = 1 as unknown as IntervalHandle;
+  return {
+    timerApi: {
+      setInterval: (fn: () => void, _delayMs: number) => {
+        intervalFn = fn;
+        return timer;
+      },
+      clearInterval: (_timer: IntervalHandle) => {
+        cleared = true;
+      },
+    },
+    runInterval: () => {
+      if (!intervalFn) {
+        throw new Error("interval was not scheduled");
+      }
+      intervalFn();
+    },
+    isCleared: () => cleared,
+  };
+}
+
 afterEach(() => {
   try {
     if (existsSync(configPath)) unlinkSync(configPath);
@@ -51,6 +76,38 @@ afterEach(() => {
 });
 
 describe("ConfigFileWatcher", () => {
+  test("polls config changes when file watcher events are missed", () => {
+    const events: ConfigChangeEvent[] = [];
+    const timer = makeManualIntervalTimer();
+    const watcher = new ConfigFileWatcher(
+      (event) => {
+        events.push(event);
+      },
+      { pollIntervalMs: 10, timerApi: timer.timerApi },
+    );
+
+    try {
+      watcher.start();
+      writeConfig({
+        twilio: {
+          setupStarted: true,
+        },
+      });
+
+      timer.runInterval();
+
+      expect(events).toHaveLength(1);
+      expect(events[0].changedKeys).toEqual(new Set(["twilio"]));
+      expect(events[0].changedFields.get("twilio")).toEqual(
+        new Set(["setupStarted"]),
+      );
+    } finally {
+      watcher.stop();
+    }
+
+    expect(timer.isCleared()).toBe(true);
+  });
+
   test("reports shallow ingress fields changed by Velay-managed URL writes", () => {
     writeConfig({
       ingress: {

package/src/__tests__/route-schema-guard.test.ts

@@ -8,6 +8,7 @@ import {
   TWILIO_STATUS_WEBHOOK_PATH,
   TWILIO_VOICE_WEBHOOK_PATH,
 } from "@vellumai/service-contracts/twilio-ingress";
+import { A2A_AGENT_CARD_PATH } from "../http/routes/a2a-routes.js";
 import { buildSchema } from "../schema.js";
 
 /** A route extracted from source: path + optional HTTP method. */
@@ -17,6 +18,7 @@ interface ExtractedRoute {
 }
 
 const ROUTE_PATH_CONSTANTS: Record<string, string> = {
+  A2A_AGENT_CARD_PATH,
   TWILIO_CONNECT_ACTION_WEBHOOK_PATH,
   TWILIO_MEDIA_STREAM_WEBHOOK_PATH,
   TWILIO_RELAY_WEBHOOK_PATH,
@@ -169,6 +171,8 @@ const EXCLUDED_FROM_SCHEMA = new Set([
   "catch-all",
   // Loopback-only pairing endpoint — not part of the public gateway API
   "/v1/pair",
+  // A2A agent card discovery — read-only, unauthenticated per spec
+  "/.well-known/agent-card.json",
 ]);
 
 // ── Schema paths that don't map to a discrete route definition ──

package/src/__tests__/twilio-webhooks.test.ts

@@ -826,6 +826,53 @@ describe("Twilio webhook signature with canonical ingress base URL", () => {
     });
   });
 
+  test("uses platform callback assistant ID for Twilio websocket URL", async () => {
+    const assistantId = "019e2d0d-f355-744c-a12c-d7e7dcefcf1e";
+    fetchMock = mock(
+      async () =>
+        new Response(
+          '<?xml version="1.0" encoding="UTF-8"?><Response><Connect>' +
+            '<ConversationRelay url="wss://__VELLUM_PUBLIC_BASE_URL__/webhooks/twilio/relay?token=__VELLUM_RELAY_TOKEN__"/>' +
+            "</Connect></Response>",
+          {
+            status: 200,
+            headers: { "Content-Type": "text/xml" },
+          },
+        ),
+    );
+
+    const handler = createTwilioVoiceWebhookHandler(
+      makeConfig({ velayBaseUrl: "https://velay-staging.vellum.ai" }),
+      makeCaches(),
+    );
+
+    const platformCallbackUrl =
+      `https://staging-platform.vellum.ai/v1/gateway/callbacks/${assistantId}` +
+      "/webhooks/twilio/voice?callSessionId=platform-wss-test";
+    const localUrl =
+      "http://localhost:7830/webhooks/twilio/voice?callSessionId=platform-wss-test";
+    const params = { CallSid: "CA-platform-wss" };
+    const signature = computeSignature(platformCallbackUrl, params, AUTH_TOKEN);
+    const req = new Request(localUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "X-Twilio-Signature": signature,
+        "X-Vellum-Ingress-URL": platformCallbackUrl,
+      },
+      body: new URLSearchParams(params).toString(),
+    });
+
+    const res = await handler(req);
+    expect(res.status).toBe(200);
+    const body = await res.text();
+    expect(body).toContain(
+      `url="wss://velay-staging.vellum.ai/${assistantId}/webhooks/twilio/relay?`,
+    );
+    expect(body).not.toContain("__VELLUM_PUBLIC_BASE_URL__");
+    expect(body).not.toContain("staging-platform.vellum.ai");
+  });
+
   test("platform proxy URL takes priority over configured ingress", async () => {
     fetchMock = mock(
       async () =>

package/src/auth/ipc-route-policy.ts

@@ -223,6 +223,12 @@ const POLICY_TABLE: PolicyEntry[] = [
   ["updateHeartbeatConfig", ["settings.write"]],
 
   // Integrations / ingress
+  [
+    "integrations_a2a_invite_complete_post",
+    ["internal.write"],
+    ["svc_gateway"],
+  ],
+  ["integrations_a2a_invite_redeem_post", ["internal.write"], ["svc_gateway"]],
   ["integrations_ingress_config_get", ["settings.read"]],
   ["integrations_ingress_config_put", ["settings.write"]],
   ["integrations_oauth_start_post", ["settings.write"]],

package/src/channels/inbound-event.ts

@@ -10,7 +10,7 @@ import type { ChannelId } from "./types.js";
 
 export type InboundChannelId = Extract<
   ChannelId,
-  "telegram" | "whatsapp" | "slack" | "email"
+  "telegram" | "whatsapp" | "slack" | "email" | "a2a"
 >;
 
 interface InboundEventBase<C extends InboundChannelId> {
@@ -59,9 +59,11 @@ export type TelegramInboundEvent = InboundEventBase<"telegram">;
 export type WhatsAppInboundEvent = InboundEventBase<"whatsapp">;
 export type SlackInboundEvent = InboundEventBase<"slack">;
 export type EmailInboundEvent = InboundEventBase<"email">;
+export type A2aInboundEvent = InboundEventBase<"a2a">;
 
 export type GatewayInboundEvent =
   | TelegramInboundEvent
   | WhatsAppInboundEvent
   | SlackInboundEvent
-  | EmailInboundEvent;
+  | EmailInboundEvent
+  | A2aInboundEvent;

package/src/channels/types.ts

@@ -5,6 +5,7 @@ export const CHANNEL_IDS = [
   "whatsapp",
   "slack",
   "email",
+  "a2a",
 ] as const;
 
 export type ChannelId = (typeof CHANNEL_IDS)[number];
@@ -30,6 +31,7 @@ export const INTERFACE_IDS = [
   "whatsapp",
   "slack",
   "email",
+  "a2a",
 ] as const;
 
 export type InterfaceId = (typeof INTERFACE_IDS)[number];

package/src/config-file-watcher.ts

@@ -15,6 +15,14 @@ import { getLogger } from "./logger.js";
 const log = getLogger("config-file-watcher");
 
 const DEBOUNCE_MS = 500;
+const FALLBACK_POLL_MS = 1_000;
+
+type IntervalHandle = ReturnType<typeof setInterval>;
+
+type TimerApi = {
+  setInterval: (fn: () => void, delayMs: number) => IntervalHandle;
+  clearInterval: (timer: IntervalHandle) => void;
+};
 
 export type ConfigChangeEvent = {
   /** Full parsed config.json data. */
@@ -32,16 +40,27 @@ export type ConfigChangeCallback = (event: ConfigChangeEvent) => void;
 
 export class ConfigFileWatcher {
   private watcher: FSWatcher | null = null;
+  private pollTimer: IntervalHandle | null = null;
   private watchingDirectory = false;
   private debounceTimer: ReturnType<typeof setTimeout> | null = null;
   private lastSerialized: Map<string, string> = new Map();
   private lastValues: Map<string, unknown> = new Map();
   private callback: ConfigChangeCallback;
   private configPath: string;
+  private pollIntervalMs: number;
+  private timerApi: TimerApi;
 
-  constructor(callback: ConfigChangeCallback) {
+  constructor(
+    callback: ConfigChangeCallback,
+    opts?: { pollIntervalMs?: number; timerApi?: TimerApi },
+  ) {
     this.callback = callback;
     this.configPath = getConfigPath();
+    this.pollIntervalMs = opts?.pollIntervalMs ?? FALLBACK_POLL_MS;
+    this.timerApi = opts?.timerApi ?? {
+      setInterval,
+      clearInterval,
+    };
   }
 
   start(): void {
@@ -77,6 +96,8 @@ export class ConfigFileWatcher {
         "Failed to start config file watcher",
       );
     }
+
+    this.startFallbackPolling();
   }
 
   stop(): void {
@@ -84,12 +105,34 @@ export class ConfigFileWatcher {
       clearTimeout(this.debounceTimer);
       this.debounceTimer = null;
     }
+    if (this.pollTimer) {
+      this.timerApi.clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
     if (this.watcher) {
       this.watcher.close();
       this.watcher = null;
     }
   }
 
+  private startFallbackPolling(): void {
+    if (this.pollIntervalMs <= 0 || this.pollTimer) return;
+
+    this.pollTimer = this.timerApi.setInterval(() => {
+      this.pollOnce();
+
+      if (this.watchingDirectory && existsSync(this.configPath)) {
+        this.upgradeWatcher();
+      }
+    }, this.pollIntervalMs);
+    (this.pollTimer as { unref?: () => void }).unref?.();
+
+    log.info(
+      { intervalMs: this.pollIntervalMs },
+      "Polling config file for missed change events",
+    );
+  }
+
   private scheduleCheck(): void {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);

package/src/feature-flag-registry.json

@@ -9,14 +9,6 @@
       "description": "Automatically trigger conversation analysis on the same cadence as memory extraction (batch threshold, idle debounce, end-of-conversation). The analysis agent has full tool access and writes back to memory and skills without user approval.",
       "defaultEnabled": false
     },
-    {
-      "id": "memory-retrospective",
-      "scope": "assistant",
-      "key": "memory-retrospective",
-      "label": "Memory retrospective pass",
-      "description": "Run a focused, memory-only retrospective during active conversations and at conversation lifecycle. The retrospective agent re-reads the messages added since the last successful run, dedupes against memory/archive/, and calls `remember` for what wasn't captured in the moment. Enabling this also relaxes the in-conversation pressure to call `remember` (lighter PKB reminder + relaxed tool description) so the assistant can stay present and trust the retrospective as the backstop.",
-      "defaultEnabled": false
-    },
     {
       "id": "user-hosted-enabled",
       "scope": "client",
@@ -33,6 +25,14 @@
       "description": "When enabled, the Local hosting option uses Docker under the hood for sandboxed execution, hiding the separate Docker card",
       "defaultEnabled": false
     },
+    {
+      "id": "a2a-channel",
+      "scope": "assistant",
+      "key": "a2a-channel",
+      "label": "A2A Channel",
+      "description": "Enable the A2A (Agent-to-Agent) channel for inter-assistant communication via the open A2A protocol",
+      "defaultEnabled": false
+    },
     {
       "id": "email-channel",
       "scope": "assistant",
@@ -145,6 +145,14 @@
       "description": "Show a speaker button on assistant messages to generate and play the message as audio via Fish Audio TTS",
       "defaultEnabled": false
     },
+    {
+      "id": "openai-compatible-endpoints",
+      "scope": "assistant",
+      "key": "openai-compatible-endpoints",
+      "label": "OpenAI-Compatible Endpoints",
+      "description": "Enable user-configured OpenAI-compatible inference endpoints with custom base URLs and model identifiers",
+      "defaultEnabled": false
+    },
     {
       "id": "backward-releases",
       "scope": "assistant",
@@ -281,14 +289,6 @@
       "description": "Enable the app-control skill (per-app screenshot + raw input bypassing AX tree)",
       "defaultEnabled": false
     },
-    {
-      "id": "species-migration",
-      "scope": "assistant",
-      "key": "species-migration",
-      "label": "Species Migration",
-      "description": "Enable the Species Migration skill for migrating from OpenClaw, Hermes, Manus, and other assistant species into Vellum.",
-      "defaultEnabled": false
-    },
     {
       "id": "analyze-conversation",
       "scope": "assistant",
@@ -322,19 +322,11 @@
       "defaultEnabled": false
     },
     {
-      "id": "provider-deepseek",
-      "scope": "assistant",
-      "key": "provider-deepseek",
-      "label": "DeepSeek Provider",
-      "description": "Enable the DeepSeek direct API provider and its models (V4 Pro, V4 Flash) in the provider picker and model selection UI",
-      "defaultEnabled": false
-    },
-    {
-      "id": "provider-minimax",
-      "scope": "assistant",
-      "key": "provider-minimax",
-      "label": "MiniMax Provider",
-      "description": "Enable the MiniMax direct API provider and its models (M2.7, M2.5, M2.1, M2, and highspeed variants) in the provider picker and model selection UI",
+      "id": "velvet-theme",
+      "scope": "client",
+      "key": "velvet-theme",
+      "label": "Velvet Theme",
+      "description": "Show the Velvet theme option in the macOS appearance settings. Velvet is a dark-mode variant with red/pink accent colors.",
       "defaultEnabled": false
     }
   ]

package/src/http/routes/a2a-routes.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// --- Workspace dir mock -----------------------------------------------------
+
+let testWorkspaceDir: string;
+
+mock.module("../../credential-reader.js", () => ({
+  getWorkspaceDir: () => testWorkspaceDir,
+}));
+
+// Import after mocks are registered
+const { createAgentCardHandler } = await import("./a2a-routes.js");
+
+// --- Helpers ---------------------------------------------------------------
+
+function makeConfigFileCache(overrides?: {
+  a2aEnabled?: boolean;
+  publicBaseUrl?: string;
+}) {
+  const data: Record<string, Record<string, unknown>> = {
+    a2a: { enabled: overrides?.a2aEnabled ?? false },
+    ingress: {
+      publicBaseUrl: overrides?.publicBaseUrl ?? "https://example.com",
+    },
+  };
+
+  return {
+    getBoolean: (section: string, field: string) => {
+      const val = data[section]?.[field];
+      return typeof val === "boolean" ? val : undefined;
+    },
+    getString: (section: string, field: string) => {
+      const val = data[section]?.[field];
+      return typeof val === "string" ? val : undefined;
+    },
+  } as import("../../config-file-cache.js").ConfigFileCache;
+}
+
+// --- Setup / teardown -------------------------------------------------------
+
+beforeEach(() => {
+  testWorkspaceDir = mkdtempSync(join(tmpdir(), "a2a-test-"));
+});
+
+afterEach(() => {
+  rmSync(testWorkspaceDir, { recursive: true, force: true });
+});
+
+// --- Tests -----------------------------------------------------------------
+
+describe("Agent Card", () => {
+  it("returns 404 when A2A is not enabled", async () => {
+    const configFile = makeConfigFileCache({ a2aEnabled: false });
+    const handler = createAgentCardHandler(configFile);
+
+    const res = await handler(
+      new Request("http://localhost:7830/.well-known/agent-card.json"),
+    );
+
+    expect(res.status).toBe(404);
+    const body = (await res.json()) as { error: string };
+    expect(body.error).toContain("not enabled");
+  });
+
+  it("serves agent card with fallback name when no IDENTITY.md", async () => {
+    const configFile = makeConfigFileCache({
+      a2aEnabled: true,
+      publicBaseUrl: "https://my-assistant.example.com",
+    });
+    const handler = createAgentCardHandler(configFile);
+
+    const res = await handler(
+      new Request("http://localhost:7830/.well-known/agent-card.json"),
+    );
+
+    expect(res.status).toBe(200);
+    const card = (await res.json()) as {
+      name: string;
+      supported_interfaces: Array<{ url: string }>;
+      capabilities: { push_notifications: boolean };
+    };
+    expect(card.name).toBe("Vellum Assistant");
+    expect(card.supported_interfaces[0].url).toBe(
+      "https://my-assistant.example.com/a2a/message:send",
+    );
+    expect(card.capabilities.push_notifications).toBe(true);
+  });
+
+  it("reads assistant name from IDENTITY.md", async () => {
+    const promptsDir = join(testWorkspaceDir, "prompts");
+    mkdirSync(promptsDir, { recursive: true });
+    writeFileSync(
+      join(promptsDir, "IDENTITY.md"),
+      "**Name:** Alice\n\nA helpful research assistant.",
+    );
+
+    const configFile = makeConfigFileCache({
+      a2aEnabled: true,
+      publicBaseUrl: "https://alice.example.com",
+    });
+    const handler = createAgentCardHandler(configFile);
+
+    const res = await handler(
+      new Request("http://localhost:7830/.well-known/agent-card.json"),
+    );
+
+    expect(res.status).toBe(200);
+    const card = (await res.json()) as { name: string; description: string };
+    expect(card.name).toBe("Alice");
+    expect(card.description).toBe("Alice — a Vellum AI assistant");
+  });
+
+  it("returns 503 when no public base URL is configured", async () => {
+    const configFile = makeConfigFileCache({
+      a2aEnabled: true,
+      publicBaseUrl: "",
+    });
+    const handler = createAgentCardHandler(configFile);
+
+    const res = await handler(
+      new Request("http://localhost:7830/.well-known/agent-card.json"),
+    );
+
+    expect(res.status).toBe(503);
+  });
+});

package/src/http/routes/a2a-routes.ts

@@ -0,0 +1,121 @@
+/**
+ * A2A agent card discovery endpoint:
+ * - GET /.well-known/agent-card.json — agent card for peer discovery
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { ConfigFileCache } from "../../config-file-cache.js";
+import { getWorkspaceDir } from "../../credential-reader.js";
+import { getLogger } from "../../logger.js";
+
+const log = getLogger("a2a-routes");
+
+// ── A2A protocol constants (duplicated to avoid cross-package import) ──
+
+const A2A_AGENT_CARD_PATH = "/.well-known/agent-card.json";
+
+// ── Agent card builder ──────────────────────────────────────────────
+
+interface AgentCard {
+  name: string;
+  description: string;
+  version: string;
+  supported_interfaces: Array<{
+    url: string;
+    protocol_binding: string;
+    protocol_version: string;
+  }>;
+  capabilities: {
+    streaming: boolean;
+    push_notifications: boolean;
+    extended_agent_card: boolean;
+  };
+  default_input_modes: string[];
+  default_output_modes: string[];
+  skills: Array<{
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+  }>;
+}
+
+function buildAgentCard(baseUrl: string, assistantName: string): AgentCard {
+  return {
+    name: assistantName,
+    description: `${assistantName} — a Vellum AI assistant`,
+    version: "1.0.0",
+    supported_interfaces: [
+      {
+        url: `${baseUrl}/a2a/message:send`,
+        protocol_binding: "JSONRPC",
+        protocol_version: "1.0",
+      },
+    ],
+    capabilities: {
+      streaming: false,
+      push_notifications: true,
+      extended_agent_card: false,
+    },
+    default_input_modes: ["text/plain"],
+    default_output_modes: ["text/plain"],
+    skills: [
+      {
+        id: "conversation",
+        name: "General conversation",
+        description: "Send a message and receive a response",
+        tags: ["chat"],
+      },
+    ],
+  };
+}
+
+// ── Identity helpers ───────────────────────────────────────────────
+
+function readAssistantName(): string {
+  try {
+    const wsDir = getWorkspaceDir();
+    const identityPath = join(wsDir, "prompts", "IDENTITY.md");
+    if (!existsSync(identityPath)) return "Vellum Assistant";
+    const content = readFileSync(identityPath, "utf-8");
+    const match = content.match(/\*\*Name:\*\*\s*(.+)/);
+    return match?.[1]?.trim() || "Vellum Assistant";
+  } catch {
+    return "Vellum Assistant";
+  }
+}
+
+// ── Route handler factory ──────────────────────────────────────────
+
+export function createAgentCardHandler(configFile: ConfigFileCache) {
+  return async (_req: Request): Promise<Response> => {
+    const enabled = configFile.getBoolean("a2a", "enabled") ?? false;
+    if (!enabled) {
+      return Response.json(
+        { error: "A2A channel is not enabled" },
+        { status: 404 },
+      );
+    }
+
+    const publicBaseUrl =
+      configFile.getString("ingress", "publicBaseUrl") ?? "";
+    if (!publicBaseUrl) {
+      log.warn("Agent card requested but no public base URL configured");
+      return Response.json(
+        { error: "Public ingress URL not configured" },
+        { status: 503 },
+      );
+    }
+
+    const assistantName = readAssistantName();
+    const card = buildAgentCard(publicBaseUrl, assistantName);
+
+    return Response.json(card, {
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+}
+
+export { A2A_AGENT_CARD_PATH };