The Open Framework for Building Agents
import { readFileSync } from "node:fs";
import { describe, expect, it, vi } from "vitest";
import {
buildConnectionInstall,
buildConnectionSetup,
renderConnectionVariants,
} from "./connection-setup";
import { getIntegration } from "./data";
import { integrationMarkdown } from "./discovery";
import sentConnection from "../../registry/connections/sent";
// Connect's runtime pulls in channel auth; these tests exercise only the authored approval policy.
vi.mock("@vercel/connect/eve", () => ({
connect: () => ({ getToken: async () => ({ token: "" }) }),
}));
describe("Browser Use connection setup", () => {
it("generates server-side header authentication without Connect", () => {
const integration = getIntegration("browser-use")!;
const setup = buildConnectionSetup(integration);
const quickStart = setup.variants["mcp:apiKey"];
expect(quickStart).toContain('"x-browser-use-api-key": process.env.BROWSER_USE_API_KEY!');
expect(quickStart).not.toContain("@vercel/connect");
expect(buildConnectionInstall(integration)).toContain("eve add connection/browser-use");
expect(renderConnectionVariants(setup, setup.configureVariants)).toContain(
"BROWSER_USE_API_KEY=your_api_key",
);
});
it("keeps Connect setup for OAuth connections", () => {
const integration = getIntegration("linear")!;
const quickStart = buildConnectionSetup(integration).variants["mcp:user"];
expect(quickStart).toContain("@vercel/connect/eve");
expect(buildConnectionInstall(integration)).toContain("eve add connection/linear");
});
});
describe("Firecrawl connection setup", () => {
it("renders bearer authentication for cost-sensitive tools", () => {
const integration = getIntegration("firecrawl")!;
expect(integration.quickStart).toContain(
"Authorization: `Bearer ${process.env.FIRECRAWL_API_KEY!}`",
);
expect(buildConnectionInstall(integration)).toContain("eve add connection/firecrawl");
});
it("shows the installed connection file in the gallery", () => {
const source = readFileSync(
new URL("../../registry/connections/firecrawl.ts", import.meta.url),
"utf8",
);
expect(getIntegration("firecrawl")!.quickStart).toContain(source.trim());
});
});
describe("Agentcard connection setup", () => {
it("uses the standard connector name for the native Vercel Connect service", () => {
const integration = getIntegration("agentcard")!;
const setup = buildConnectionSetup(integration);
const quickStart = setup.variants["mcp:user"];
expect(quickStart).toContain("Agentcard: the agent's wallet.");
expect(quickStart).toContain('auth: connect("agentcard")');
expect(quickStart).not.toContain("AGENTCARD_CONNECTOR");
expect(setup.configureVariants["mcp:user"]).toContain("vercel connect create agentcard");
expect(setup.configureVariants["mcp:user"]).not.toContain("--name");
});
});
describe("Context connection setup", () => {
it("keeps the connector UID separate from its creation arguments", () => {
const integration = getIntegration("context")!;
const setup = buildConnectionSetup(integration);
expect(setup.variants["mcp:user"]).toContain('auth: connect("context")');
expect(setup.configureVariants["mcp:user"]).toContain(
"vercel connect create mcp.context.dev --name context",
);
});
});
describe("FLORA connection setup", () => {
it("uses the published MCP URL, Connect connector name, and approval gate", () => {
const integration = getIntegration("flora")!;
const setup = buildConnectionSetup(integration);
expect(setup.variants["mcp:user"]).toContain('url: "https://agents.flora.ai/mcp"');
expect(setup.variants["mcp:user"]).toContain('auth: connect("agents.flora.ai/flora")');
expect(setup.configureVariants["mcp:user"]).toContain(
"vercel connect create agents.flora.ai/mcp --name flora",
);
expect(integrationMarkdown(integration)).toContain("approval: always()");
});
it("shows the installed connection file in the gallery", () => {
const source = readFileSync(
new URL("../../registry/connections/flora.ts", import.meta.url),
"utf8",
);
expect(getIntegration("flora")!.quickStart).toContain(source.trim());
});
});
describe("Sent connection setup", () => {
it("preserves the installed tool boundary in the gallery setup", () => {
const integration = getIntegration("sent")!;
const setup = buildConnectionSetup(integration);
const quickStart = integration.quickStart!;
expect(setup.authModes).toEqual(["user"]);
expect(setup.variants["mcp:user"]).toContain('url: "https://mcp.sent.dm/mcp"');
expect(setup.variants["mcp:user"]).toContain('auth: connect("sent")');
expect(setup.configureVariants["mcp:user"]).toContain(
"vercel connect create mcp.sent.dm --name sent",
);
expect(buildConnectionInstall(integration)).toContain("eve add connection/sent");
expect(quickStart).toContain("approval: ({ toolName }) =>");
expect(quickStart).toContain('? "user-approval"');
expect(quickStart).toContain(': "not-applicable"');
const { tools } = sentConnection;
if (!tools || !("allow" in tools)) {
throw new Error("Sent requires a tool allowlist.");
}
for (const toolName of tools.allow) {
expect(quickStart).toContain(`"${toolName}"`);
}
expect(integrationMarkdown(integration)).toContain(quickStart);
});
});
describe("Neon connection setup", () => {
it("generates the registry install and Vercel Connect configuration", () => {
const integration = getIntegration("neon")!;
const setup = buildConnectionSetup(integration);
const quickStart = setup.variants["mcp:app"];
expect(buildConnectionInstall(integration)).toContain("eve add connection/neon");
expect(quickStart).toContain('url: "https://mcp.neon.tech/mcp"');
expect(quickStart).toContain('auth: connect({ connector: "neon/neon", principalType: "app" })');
expect(setup.configureVariants["mcp:app"]).toContain("vercel connect create neon");
expect(setup.configureVariants["mcp:app"]).not.toContain("--name");
});
});
describe("Sanity connection setup", () => {
it("documents automatic MCP registration and user OAuth for Sanity", () => {
const integration = getIntegration("sanity")!;
const setup = buildConnectionSetup(integration);
expect(buildConnectionInstall(integration)).toContain("eve add connection/sanity");
expect(setup.variants["mcp:user"]).toContain('url: "https://mcp.sanity.io"');
expect(setup.variants["mcp:user"]).toContain('auth: connect("sanity/sanity")');
expect(integrationMarkdown(integration)).toContain(
"vercel connect create sanity --name sanity --connection-method mcp",
);
});
});
describe("Shopify connection setup", () => {
it("uses hand-authored sections without generating authentication variants", () => {
const integration = getIntegration("shopify")!;
const setup = buildConnectionSetup(integration);
expect(setup.protocols).toEqual(["mcp"]);
expect(setup.authModes).toEqual([]);
expect(setup.variants).toEqual({});
expect(setup.configureVariants).toEqual({});
expect(integration.quickStart).toContain("defineMcpClientConnection");
expect(integration.quickStart).toContain('process.env.EVE_DEV === "1"');
expect(integration.quickStart).not.toContain("process.env.NODE_ENV");
expect(integration.configure).toContain("SHOPIFY_STORE_DOMAIN");
expect(integration.configure).not.toContain("UCP_AGENT_PROFILE_URL");
});
});
describe("Kernel extension setup", () => {
it("uses Kernel's eve extension with Vercel Connect", () => {
const integration = getIntegration("kernel")!;
expect(integration.type).toBe("extension");
expect(integration.install).toContain("eve add extension/kernel");
expect(integration.quickStart).toContain('kernel({ connect: "kernel/kernel-mcp" })');
expect(integration.configure).toContain("KERNEL_API_KEY");
expect(integration.relatedResources?.map((resource) => resource.href)).toEqual([
"https://vercel.com/kb/guide/build-a-browser-agent",
"https://vercel.com/kb/guide/software-factory-browser",
]);
});
});
describe("Nimble extension setup", () => {
it("documents the API-key mount and approval-gated billable-run boundary", () => {
const integration = getIntegration("nimble")!;
expect(integration.type).toBe("extension");
expect(integration.install).toContain("eve add extension/nimble");
expect(integration.quickStart).toContain("NIMBLE_API_KEY");
expect(integration.quickStart).toContain('import nimble from "@nimble-way/eve"');
expect(integration.quickStart).toContain("agent/extensions/nimble/extension.ts");
expect(integration.quickStart).toContain("require approval for every Agent API run");
expect(integration.configure).toContain("untrusted third-party content");
expect(integration.configure).toContain("billable, non-idempotent");
expect(integration.configure).toContain("requires approval for every call");
});
});
describe("Vercel MCP connection setup", () => {
it("offers user OAuth and shared app credential setup", () => {
const integration = getIntegration("vercel")!;
const setup = buildConnectionSetup(integration);
const userQuickStart = setup.variants["mcp:user"];
const appQuickStart = setup.variants["mcp:app"];
expect(setup.authModes).toEqual(["user", "app"]);
expect(userQuickStart).toContain('url: "https://mcp.vercel.com"');
expect(userQuickStart).toContain('auth: connect("vercel")');
expect(appQuickStart).toContain(
'auth: connect({ connector: "vercel/your-connector", principalType: "app" })',
);
const userConfigure = setup.configureVariants["mcp:user"];
const appConfigure = setup.configureVariants["mcp:app"];
expect(userConfigure).toContain("vercel connect create vercel --name vercel");
expect(userConfigure).toContain("Select None");
expect(userConfigure).not.toContain("create api-key");
expect(appConfigure).toContain("vercel connect create api-key --name vercel");
expect(appConfigure).not.toContain("Select None");
expect(appConfigure).toContain(
"[Vercel token](https://vercel.com/kb/guide/how-do-i-use-a-vercel-api-access-token)",
);
expect(appConfigure).toContain("copy the returned connector UID into the App example");
expect(appConfigure).toContain("token still belongs to the user who created it");
const configure = renderConnectionVariants(setup, setup.configureVariants);
expect(configure).toContain("### MCP · User");
expect(configure).toContain("### MCP · App");
expect(configure).not.toContain("vercel connect attach");
});
});