Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

[2/3] feat(eve): delegate Connect manifest compilation (#3469)

Ben Pankowcd82f57e61b4
diff --git a/.changeset/olive-wolves-visit.md b/.changeset/olive-wolves-visit.md
new file mode 100644
index 000000000..59acf0fa5
--- /dev/null
+++ b/.changeset/olive-wolves-visit.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Compile Connect-backed channels and connections into a generic external-resource snapshot, then delegate final manifest creation to the installed @vercel/connect compiler.
diff --git a/packages/eve/package.json b/packages/eve/package.json
index 00435afdd..e42c6cf23 100644
--- a/packages/eve/package.json
+++ b/packages/eve/package.json
@@ -530,6 +530,7 @@
"@opentelemetry/otlp-transformer": "0.214.0",
"@opentelemetry/sdk-trace-base": "catalog:",
"@photon-ai/chat-adapter-imessage": "3.2.0",
+ "@slack/web-api": "7.19.0",
"@standard-schema/spec": "1.1.0",
"@sveltejs/kit": "^2.0.0",
"@types/json-schema": "7.0.15",
diff --git a/packages/eve/src/channel/compiled-channel.ts b/packages/eve/src/channel/compiled-channel.ts
index e4f71489b..0acd5d7d4 100644
--- a/packages/eve/src/channel/compiled-channel.ts
+++ b/packages/eve/src/channel/compiled-channel.ts
@@ -10,8 +10,10 @@ import type { TypedReceiveTarget } from "#channel/receive-target.js";
import type { RouteDefinition } from "#channel/routes.js";
import type { Session } from "#channel/session.js";
import type { SessionAuthContext, TurnPolicy } from "#channel/types.js";
+import type { JsonObject } from "#shared/json.js";
export const CHANNEL_SENTINEL = "eve:channel" as const;
+const CHANNEL_BUILD_METADATA = Symbol.for("eve.channel.buildMetadata");
const CHANNEL_INSTRUMENTATION_KIND = Symbol.for("eve.channel.instrumentationKind");
const CHANNEL_INSTRUMENTATION_KINDS = Symbol.for("eve.channel.instrumentationKinds");
@@ -25,6 +27,13 @@ const channelInstrumentationKindGlobal = globalThis as ChannelInstrumentationKin
channelInstrumentationKindGlobal[CHANNEL_INSTRUMENTATION_KINDS] ??= new Map();
const channelInstrumentationKinds = channelInstrumentationKindGlobal[CHANNEL_INSTRUMENTATION_KINDS];
+export interface ChannelBuildMetadata {
+ readonly externalCredentials?: unknown;
+ readonly manifest?: JsonObject;
+}
+
+export type ChannelBuildMetadataFactory = (channelName: string) => ChannelBuildMetadata;
+
/** Structural identity shared by public authored channels and compiled channels. */
export interface ChannelReference<
TReceiveTarget = Record<string, unknown>,
@@ -60,6 +69,29 @@ export function isCompiledChannel(value: unknown): value is CompiledChannel {
);
}
+export function getChannelBuildMetadata(
+ value: unknown,
+ channelName: string,
+): ChannelBuildMetadata | undefined {
+ if (!isCompiledChannel(value)) return undefined;
+ const factory = Reflect.get(value, CHANNEL_BUILD_METADATA);
+ return typeof factory === "function"
+ ? (factory as ChannelBuildMetadataFactory)(channelName)
+ : undefined;
+}
+
+export function setChannelBuildMetadata(
+ channel: unknown,
+ factory: ChannelBuildMetadataFactory,
+): void {
+ if (!isCompiledChannel(channel)) throw new TypeError("Expected a compiled channel.");
+ Object.defineProperty(channel, CHANNEL_BUILD_METADATA, {
+ configurable: true,
+ enumerable: false,
+ value: factory,
+ });
+}
+
export function getChannelInstrumentationKind(value: unknown): string | undefined {
if (!isCompiledChannel(value)) {
return undefined;
diff --git a/packages/eve/src/compiler/manifest.ts b/packages/eve/src/compiler/manifest.ts
index 855d55378..e481f836b 100644
--- a/packages/eve/src/compiler/manifest.ts
+++ b/packages/eve/src/compiler/manifest.ts
@@ -13,6 +13,7 @@ import type { ChannelRouteMethod } from "#public/definitions/channel.js";
import type { NormalizedChannelCorsOptions } from "#channel/cors.js";
import type { InternalInstructionsDefinition } from "#shared/instructions-definition.js";
import { jsonObjectSchema } from "#shared/json-schemas.js";
+import type { JsonObject } from "#shared/json.js";
import type { Node } from "#shared/node.js";
import type {
MarkdownSourceRef,
@@ -28,6 +29,7 @@ import {
type AgentBuildDefinition,
type ModelRouting,
} from "#shared/agent-definition.js";
+import type { VercelConnectMetadata } from "#shared/vercel-connect-metadata.js";
import type { InternalToolDefinition } from "#tools/definition.js";
import type { CompiledToolBehavior } from "#tools/behavior.js";
import type {
@@ -55,7 +57,7 @@ export const ROOT_COMPILED_AGENT_NODE_ID = "__root__";
/**
* Current compiled manifest schema version.
*/
-export const COMPILED_AGENT_MANIFEST_VERSION = 51;
+export const COMPILED_AGENT_MANIFEST_VERSION = 52;
/**
* Compiled channel entry preserved in the compiled manifest.
@@ -89,6 +91,8 @@ export interface CompiledChannelDefinition {
* channel leaves CORS untouched.
*/
readonly cors?: NormalizedChannelCorsOptions;
+ readonly manifest?: JsonObject;
+ readonly vercelConnect?: VercelConnectMetadata;
}
/**
@@ -488,6 +492,21 @@ const compiledChannelCorsSchema = z
})
.strict() satisfies z.ZodType<NormalizedChannelCorsOptions>;
+const compiledVercelConnectMetadataSchema = z
+ .object({
+ connector: z.string(),
+ requirement: z
+ .object({
+ method: z.string().optional(),
+ reference: z.string(),
+ service: z.string(),
+ subjectTypes: z.array(z.enum(["app", "user"])).readonly(),
+ })
+ .strict()
+ .optional(),
+ })
+ .strict() satisfies z.ZodType<VercelConnectMetadata>;
+
const compiledChannelDefinitionSchema = z
.object({
kind: z.literal("channel"),
@@ -500,6 +519,8 @@ const compiledChannelDefinitionSchema = z
exportName: z.string().optional(),
adapterKind: z.string().optional(),
cors: compiledChannelCorsSchema.optional(),
+ manifest: jsonObjectSchema.optional(),
+ vercelConnect: compiledVercelConnectMetadataSchema.optional(),
})
.strict();
@@ -780,12 +801,7 @@ const compiledConnectionDefinitionSchema = z
* or opaque service-connector key (`"scl_..."`); both forms address
* the same connector on the Vercel Connect side.
*/
- vercelConnect: z
- .object({
- connector: z.string(),
- })
- .strict()
- .optional(),
+ vercelConnect: compiledVercelConnectMetadataSchema.optional(),
})
.strict();
diff --git a/packages/eve/src/compiler/normalize-channel.ts b/packages/eve/src/compiler/normalize-channel.ts
index 3b05da643..cee259c3c 100644
--- a/packages/eve/src/compiler/normalize-channel.ts
+++ b/packages/eve/src/compiler/normalize-channel.ts
@@ -1,6 +1,8 @@
import { stripLogicalPathExtension } from "#discover/filesystem.js";
import type { ChannelSourceRef } from "#discover/manifest.js";
import { normalizeChannelDefinition } from "#internal/authored-definition/channel.js";
+import { getChannelBuildMetadata } from "#channel/compiled-channel.js";
+import { extractVercelConnectMetadata } from "#shared/vercel-connect-metadata.js";
import { type ChannelRouteMethod, isDisabledRouteSentinel } from "#public/definitions/channel.js";
import type { CompiledChannelDefinition } from "#compiler/manifest.js";
import { readWorkflowFunctionId } from "#internal/workflow/reference.js";
@@ -49,6 +51,8 @@ export async function compileChannelDefinition(
`Expected the channel export "${source.exportName ?? "default"}" from "${source.logicalPath}" to match the public eve shape.`,
);
+ const buildMetadata = getChannelBuildMetadata(definition, channelName);
+
for (const route of definition.routes) {
if (readWorkflowFunctionId(route.handler) !== undefined) {
throw new Error(
@@ -69,6 +73,8 @@ export async function compileChannelDefinition(
exportName: source.exportName,
adapterKind: extractAdapterKind(definition.adapter),
cors: definition.cors,
+ manifest: buildMetadata?.manifest,
+ vercelConnect: extractVercelConnectMetadata(buildMetadata?.externalCredentials),
})),
kind: "channel",
};
diff --git a/packages/eve/src/compiler/normalize-connection.ts b/packages/eve/src/compiler/normalize-connection.ts
index 8481d054d..e42887065 100644
--- a/packages/eve/src/compiler/normalize-connection.ts
+++ b/packages/eve/src/compiler/normalize-connection.ts
@@ -12,6 +12,7 @@ import {
type ModuleBackedDefinitionLoadOptions,
} from "#compiler/normalize-helpers.js";
import { readConnectionProtocol } from "#public/definitions/connections/protocol.js";
+import { extractVercelConnectMetadata } from "#shared/vercel-connect-metadata.js";
import {
ALLOWED_DYNAMIC_CONNECTION_EVENTS,
assertResolverOnlyDynamicSentinel,
@@ -114,36 +115,14 @@ export async function compileConnectionDefinition(
auth = normalized.auth;
}
- const vercelConnect = extractVercelConnectMarker(auth);
+ const vercelConnect = extractVercelConnectMetadata(
+ auth === null || typeof auth !== "object"
+ ? undefined
+ : (auth as { readonly vercelConnect?: unknown }).vercelConnect,
+ );
if (vercelConnect !== undefined) {
compiled.vercelConnect = vercelConnect;
}
return { definition: compiled, kind: "connection" };
}
-
-/**
- * Reads the optional `vercelConnect: { connector: string }` marker that
- * `@vercel/connect/eve`'s `connect()` helper attaches to its returned
- * authorization definition. Returns the parsed marker when present and
- * shaped correctly, otherwise `undefined`.
- *
- * The compiler does not import `@vercel/connect/eve` (it should not
- * depend on a specific auth provider). Detection is duck-typed against
- * the structural marker contract — any object with a non-empty
- * `vercelConnect.connector` string is recognized.
- */
-function extractVercelConnectMarker(auth: unknown): { readonly connector: string } | undefined {
- if (auth === null || typeof auth !== "object") {
- return undefined;
- }
- const marker = (auth as { vercelConnect?: unknown }).vercelConnect;
- if (marker === null || typeof marker !== "object") {
- return undefined;
- }
- const connector = (marker as { connector?: unknown }).connector;
- if (typeof connector !== "string" || connector.length === 0) {
- return undefined;
- }
- return { connector };
-}
diff --git a/packages/eve/src/framework/sources/registry.ts b/packages/eve/src/framework/sources/registry.ts
index 361f18b9b..0943e1e53 100644
--- a/packages/eve/src/framework/sources/registry.ts
+++ b/packages/eve/src/framework/sources/registry.ts
@@ -9,7 +9,7 @@ import {
type ProgrammaticModuleNamespace,
} from "#compiler/source-graph.js";
-const revision = `eve@${resolveInstalledPackageInfo().version}:compiled-manifest-v50`;
+const revision = `eve@${resolveInstalledPackageInfo().version}:compiled-manifest-v52`;
const localDefaults = defineProgrammaticAgentSource({
id: "eve:defaults",
diff --git a/packages/eve/src/internal/authored-definition/connection.test.ts b/packages/eve/src/internal/authored-definition/connection.test.ts
index 1c64bad43..0ca2bc608 100644
--- a/packages/eve/src/internal/authored-definition/connection.test.ts
+++ b/packages/eve/src/internal/authored-definition/connection.test.ts
@@ -143,8 +143,16 @@ describe("normalizeMcpClientConnectionDefinition", () => {
validInput({
auth: {
getToken: async () => ({ token: "x" }),
- principalType: "app",
- vercelConnect: { connector: "oauth/mcp-linear-app" },
+ principalType: "user",
+ vercelConnect: {
+ connector: "oauth/mcp-linear-app",
+ requirement: {
+ reference: "connector:oauth/mcp-linear-app",
+ service: "linear",
+ subjectTypes: ["user"],
+ method: "oauth",
+ },
+ },
},
}),
MSG,
@@ -152,6 +160,12 @@ describe("normalizeMcpClientConnectionDefinition", () => {
expect((result.auth as Record<string, unknown>).vercelConnect).toEqual({
connector: "oauth/mcp-linear-app",
+ requirement: {
+ reference: "connector:oauth/mcp-linear-app",
+ service: "linear",
+ subjectTypes: ["user"],
+ method: "oauth",
+ },
});
});
diff --git a/packages/eve/src/internal/external-resources-snapshot.test.ts b/packages/eve/src/internal/external-resources-snapshot.test.ts
index 2618607a8..674e533ad 100644
--- a/packages/eve/src/internal/external-resources-snapshot.test.ts
+++ b/packages/eve/src/internal/external-resources-snapshot.test.ts
@@ -27,7 +27,10 @@ const resources: readonly ExternalResource[] = [
},
kind: "channel",
logicalPath: "channels/slack.ts",
- manifest: { display_information: { name: "Support" } },
+ manifest: {
+ $type: "https://docs.slack.dev/reference/app-manifest/",
+ display_information: { name: "Support" },
+ },
name: "slack",
route: { path: "/eve/v1/slack" },
},
diff --git a/packages/eve/src/internal/external-resources.scenario.test.ts b/packages/eve/src/internal/external-resources.scenario.test.ts
new file mode 100644
index 000000000..cc73c4f73
--- /dev/null
+++ b/packages/eve/src/internal/external-resources.scenario.test.ts
@@ -0,0 +1,167 @@
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "vitest";
+
+import { createConnectManifest } from "#internal/external-resources.js";
+import { createExternalResourcesSnapshot } from "#internal/external-resources-snapshot.js";
+import { resolveScenarioPackageVersion, useScenarioApp } from "#internal/testing/scenario-app.js";
+import { runPnpmCommand } from "#internal/testing/run-pnpm-command.js";
+
+async function createAppWithCompiler(source: string): Promise<string> {
+ const appRoot = await mkdtemp(join(tmpdir(), "eve-connect-compiler-"));
+ const packageRoot = join(appRoot, "node_modules", "@vercel", "connect");
+ await mkdir(join(packageRoot, "dist", "manifest"), { recursive: true });
+ await writeFile(
+ join(packageRoot, "package.json"),
+ JSON.stringify({
+ exports: { "./manifest": "./dist/manifest/index.js" },
+ name: "@vercel/connect",
+ type: "module",
+ }),
+ );
+ await writeFile(join(packageRoot, "dist", "manifest", "index.js"), source);
+ return appRoot;
+}
+
+const snapshot = createExternalResourcesSnapshot({
+ generatorVersion: "1.2.3",
+ resources: [
+ {
+ credentials: {
+ reference: "connector:linear/my-agent",
+ service: "linear",
+ subjectTypes: ["user"],
+ },
+ kind: "connection",
+ logicalPath: "connections/linear.ts",
+ name: "linear",
+ protocol: { type: "mcp", url: "https://mcp.linear.app/mcp" },
+ },
+ ],
+});
+
+describe("Connect manifest compiler handoff", () => {
+ const scenarioApp = useScenarioApp();
+
+ it("emits a manifest from the installed Connect compiler during a real build", async () => {
+ const connectVersion = await resolveScenarioPackageVersion("@vercel/connect");
+ const app = await scenarioApp({
+ dependencies: { "@vercel/connect": connectVersion },
+ files: {
+ "agent/agent.ts": [
+ 'import { defineAgent } from "eve";',
+ "",
+ 'export default defineAgent({ model: "openai/gpt-5-mini" });',
+ "",
+ ].join("\n"),
+ "agent/channels/slack.ts": [
+ 'import { connectSlackCredentials } from "@vercel/connect/eve";',
+ 'import { slackChannel } from "eve/channels/slack";',
+ "",
+ "export default slackChannel({",
+ ' credentials: connectSlackCredentials("slack/manifest-test"),',
+ "});",
+ "",
+ ].join("\n"),
+ "agent/connections/linear.ts": [
+ 'import { connect } from "@vercel/connect/eve";',
+ 'import { defineMcpClientConnection } from "eve/connections";',
+ "",
+ "export default defineMcpClientConnection({",
+ " auth: connect({",
+ ' connector: "linear/manifest-test",',
+ ' service: "linear",',
+ " }),",
+ ' description: "Linear issues and projects.",',
+ ' url: "https://mcp.linear.app/mcp",',
+ "});",
+ "",
+ ].join("\n"),
+ "agent/instructions.md": "Help with Slack and Linear.\n",
+ },
+ installDependencies: true,
+ name: "connect-manifest-build",
+ });
+
+ await runPnpmCommand({
+ args: ["exec", "eve", "build", "--skip-sandbox-prewarm"],
+ cwd: app.appRoot,
+ });
+
+ const manifest = JSON.parse(
+ await readFile(join(app.appRoot, ".output", "vercel-connect-manifest.json"), "utf8"),
+ ) as { requirements: unknown[] };
+
+ expect(manifest).toMatchObject({
+ generator: { name: "eve" },
+ kind: "vercel-connect-manifest",
+ requirements: [
+ {
+ connect: { service: "linear", subjectTypes: ["user"] },
+ interfaces: [{ protocol: "mcp", url: "https://mcp.linear.app/mcp" }],
+ target: "connector:linear/manifest-test",
+ triggers: [],
+ uses: [{ kind: "connection", logicalPath: "connections/linear.ts", name: "linear" }],
+ },
+ {
+ connect: {
+ manifest: {
+ $type: "https://docs.slack.dev/reference/app-manifest/",
+ display_information: { name: "slack" },
+ features: { bot_user: { display_name: "slack" } },
+ oauth_config: {
+ scopes: { bot: expect.arrayContaining(["app_mentions:read", "chat:write"]) },
+ },
+ settings: {
+ event_subscriptions: { bot_events: ["app_mention"] },
+ },
+ },
+ service: "slack",
+ subjectTypes: ["app"],
+ type: "slack",
+ },
+ interfaces: [],
+ target: "connector:slack/manifest-test",
+ triggers: [{ path: "/eve/v1/slack" }],
+ uses: [{ kind: "channel", logicalPath: "channels/slack.ts", name: "slack" }],
+ },
+ ],
+ schemaVersion: 1,
+ });
+ });
+
+ it("returns compiler JSON", async () => {
+ const appRoot = await createAppWithCompiler(
+ "export function experimental_createConnectManifestFromEveResources() { return { ok: true }; }\n",
+ );
+
+ await expect(createConnectManifest({ appRoot, snapshot })).resolves.toEqual({ ok: true });
+ });
+
+ it("surfaces compiler failures with recovery guidance", async () => {
+ const appRoot = await createAppWithCompiler(
+ 'export function experimental_createConnectManifestFromEveResources() { throw new Error("unsupported snapshot"); }\n',
+ );
+
+ await expect(createConnectManifest({ appRoot, snapshot })).rejects.toThrow(
+ "Failed to create the Connect manifest: unsupported snapshot. Update @vercel/connect and rerun `eve build`.",
+ );
+ });
+
+ it("rejects a package without the compiler export", async () => {
+ const appRoot = await createAppWithCompiler("export {};\n");
+
+ await expect(createConnectManifest({ appRoot, snapshot })).rejects.toThrow(
+ /missing experimental_createConnectManifestFromEveResources export/,
+ );
+ });
+
+ it("skips compiler resolution when there are no resources", async () => {
+ const empty = createExternalResourcesSnapshot({ generatorVersion: "1.2.3", resources: [] });
+
+ await expect(
+ createConnectManifest({ appRoot: "/missing", snapshot: empty }),
+ ).resolves.toBeUndefined();
+ });
+});
diff --git a/packages/eve/src/internal/external-resources.test.ts b/packages/eve/src/internal/external-resources.test.ts
new file mode 100644
index 000000000..a64c1c076
--- /dev/null
+++ b/packages/eve/src/internal/external-resources.test.ts
@@ -0,0 +1,205 @@
+import { describe, expect, it } from "vitest";
+
+import { buildExternalResourcesSnapshot } from "#internal/external-resources.js";
+
+describe("external resources", () => {
+ it("projects complete connection and channel requirements", () => {
+ const snapshot = buildExternalResourcesSnapshot({
+ generatorVersion: "1.2.3",
+ manifest: {
+ connections: [
+ {
+ connectionName: "linear",
+ logicalPath: "connections/linear.ts",
+ protocol: "mcp",
+ url: "https://mcp.linear.app/mcp",
+ vercelConnect: {
+ connector: "linear/my-agent",
+ requirement: {
+ reference: "connector:linear/my-agent",
+ service: "linear",
+ subjectTypes: ["user"],
+ method: "oauth",
+ },
+ },
+ },
+ {
+ connectionName: "legacy",
+ logicalPath: "connections/legacy.ts",
+ protocol: "mcp",
+ url: "https://example.com/mcp",
+ vercelConnect: { connector: "legacy" },
+ },
+ ],
+ subagents: [],
+ channelRoutes: {
+ effective: [
+ {
+ adapterKind: "slack",
+ logicalPath: "channels/slack.ts",
+ manifest: {
+ $type: "https://docs.slack.dev/reference/app-manifest/",
+ display_information: { name: "slack" },
+ },
+ name: "slack",
+ urlPath: "/eve/v1/slack",
+ vercelConnect: {
+ connector: "slack/my-agent",
+ requirement: {
+ reference: "connector:slack/my-agent",
+ service: "slack",
+ subjectTypes: ["app"],
+ method: "slack",
+ },
+ },
+ },
+ ],
+ },
+ } as never,
+ });
+
+ expect(snapshot).toEqual({
+ generator: { name: "eve", version: "1.2.3" },
+ kind: "eve-external-resources",
+ resources: [
+ {
+ protocol: { type: "mcp", url: "https://mcp.linear.app/mcp" },
+ credentials: {
+ method: "oauth",
+ reference: "connector:linear/my-agent",
+ service: "linear",
+ subjectTypes: ["user"],
+ },
+ kind: "connection",
+ logicalPath: "connections/linear.ts",
+ name: "linear",
+ },
+ {
+ credentials: {
+ method: "slack",
+ reference: "connector:slack/my-agent",
+ service: "slack",
+ subjectTypes: ["app"],
+ },
+ kind: "channel",
+ logicalPath: "channels/slack.ts",
+ manifest: {
+ $type: "https://docs.slack.dev/reference/app-manifest/",
+ display_information: { name: "slack" },
+ },
+ name: "slack",
+ route: { path: "/eve/v1/slack" },
+ },
+ ],
+ schemaVersion: 1,
+ });
+ });
+
+ it("prepends the public route prefix to channel routes", () => {
+ const manifest = {
+ channelRoutes: {
+ effective: [
+ {
+ adapterKind: "custom",
+ logicalPath: "channels/slack.ts",
+ manifest: {
+ $type: "https://docs.slack.dev/reference/app-manifest/",
+ display_information: { name: "slack" },
+ },
+ name: "slack",
+ urlPath: "/eve/v1/slack",
+ vercelConnect: {
+ connector: "slack/support",
+ requirement: {
+ reference: "connector:slack/support",
+ service: "slack",
+ subjectTypes: ["app"],
+ method: "slack",
+ },
+ },
+ },
+ ],
+ },
+ connections: [],
+ subagents: [],
+ } as never;
+
+ const snapshot = buildExternalResourcesSnapshot({
+ generatorVersion: "1.2.3",
+ manifest,
+ publicRoutePrefix: "/eve/agents/support",
+ });
+
+ expect(snapshot.resources[0]).toMatchObject({
+ route: { path: "/eve/agents/support/eve/v1/slack" },
+ });
+ });
+
+ it("rejects Connect-backed OpenAPI connections without an explicit baseUrl", () => {
+ const manifest = {
+ channelRoutes: { effective: [] },
+ connections: [
+ {
+ connectionName: "example",
+ logicalPath: "connections/example.ts",
+ protocol: "openapi",
+ url: "",
+ vercelConnect: {
+ connector: "example",
+ requirement: {
+ reference: "connector:example",
+ service: "example",
+ subjectTypes: ["user"],
+ },
+ },
+ },
+ ],
+ subagents: [],
+ } as never;
+
+ expect(() => buildExternalResourcesSnapshot({ generatorVersion: "1.2.3", manifest })).toThrow(
+ 'Connect-backed OpenAPI connection "example" must set baseUrl explicitly.',
+ );
+ });
+
+ it("includes requirements declared by nested subagents", () => {
+ const requirement = {
+ reference: "connector:linear/worker",
+ service: "linear",
+ subjectTypes: ["user" as const],
+ method: "oauth",
+ };
+ const manifest = {
+ channelRoutes: { effective: [] },
+ connections: [],
+ subagents: [
+ {
+ agent: {
+ channelRoutes: { effective: [] },
+ connections: [
+ {
+ connectionName: "linear",
+ logicalPath: "subagents/worker/connections/linear.ts",
+ protocol: "mcp",
+ url: "https://mcp.linear.app/mcp",
+ vercelConnect: { connector: "linear/worker", requirement },
+ },
+ ],
+ },
+ },
+ ],
+ } as never;
+
+ expect(
+ buildExternalResourcesSnapshot({ generatorVersion: "1.2.3", manifest }).resources,
+ ).toEqual([
+ {
+ protocol: { type: "mcp", url: "https://mcp.linear.app/mcp" },
+ credentials: requirement,
+ kind: "connection",
+ logicalPath: "subagents/worker/connections/linear.ts",
+ name: "linear",
+ },
+ ]);
+ });
+});
diff --git a/packages/eve/src/internal/external-resources.ts b/packages/eve/src/internal/external-resources.ts
new file mode 100644
index 000000000..241b14f96
--- /dev/null
+++ b/packages/eve/src/internal/external-resources.ts
@@ -0,0 +1,111 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import type { CompiledAgentManifest } from "#compiler/manifest.js";
+import {
+ createExternalResourcesSnapshot,
+ type ExternalResource,
+ type ExternalResourcesSnapshot,
+} from "#internal/external-resources-snapshot.js";
+import { parseJsonObject, type JsonObject } from "#shared/json.js";
+
+export const CONNECT_MANIFEST_FILENAME = "vercel-connect-manifest.json";
+
+export function buildExternalResourcesSnapshot(input: {
+ readonly generatorVersion: string;
+ readonly manifest: CompiledAgentManifest;
+ readonly publicRoutePrefix?: string;
+}): ExternalResourcesSnapshot {
+ const resources: ExternalResource[] = [];
+ const manifests = [input.manifest, ...input.manifest.subagents.map((subagent) => subagent.agent)];
+ for (const manifest of manifests) {
+ collectExternalResources(manifest, resources, input.publicRoutePrefix);
+ }
+ return createExternalResourcesSnapshot({ generatorVersion: input.generatorVersion, resources });
+}
+
+function collectExternalResources(
+ manifest: Pick<CompiledAgentManifest, "channelRoutes" | "connections">,
+ resources: ExternalResource[],
+ publicRoutePrefix: string | undefined,
+): void {
+ for (const connection of manifest.connections) {
+ const credentials = connection.vercelConnect?.requirement;
+ if (credentials === undefined) continue;
+ if (connection.protocol === "openapi" && connection.url.length === 0) {
+ throw new Error(
+ `Connect-backed OpenAPI connection "${connection.connectionName}" must set baseUrl explicitly.`,
+ );
+ }
+ resources.push({
+ credentials,
+ kind: "connection",
+ logicalPath: connection.logicalPath,
+ name: connection.connectionName,
+ protocol: { type: connection.protocol, url: connection.url },
+ });
+ }
+ for (const channel of manifest.channelRoutes.effective) {
+ const credentials = channel.vercelConnect?.requirement;
+ if (credentials === undefined || channel.manifest === undefined) continue;
+ resources.push({
+ credentials,
+ kind: "channel",
+ logicalPath: channel.logicalPath,
+ manifest: channel.manifest,
+ name: channel.name,
+ route: { path: `${publicRoutePrefix ?? ""}${channel.urlPath}` },
+ });
+ }
+}
+
+export async function emitConnectManifest(input: {
+ readonly appRoot: string;
+ readonly generatorVersion: string;
+ readonly manifest: CompiledAgentManifest;
+ readonly outputDirectory: string;
+ readonly publicRoutePrefix?: string;
+}): Promise<void> {
+ const snapshot = buildExternalResourcesSnapshot(input);
+ const manifest = await createConnectManifest({ appRoot: input.appRoot, snapshot });
+ if (manifest === undefined) return;
+ await mkdir(input.outputDirectory, { recursive: true });
+ await writeFile(
+ join(input.outputDirectory, CONNECT_MANIFEST_FILENAME),
+ `${JSON.stringify(manifest, null, 2)}\n`,
+ );
+}
+
+export async function createConnectManifest(input: {
+ readonly appRoot: string;
+ readonly snapshot: ExternalResourcesSnapshot;
+}): Promise<JsonObject | undefined> {
+ if (input.snapshot.resources.length === 0) return undefined;
+ const require = createRequire(join(input.appRoot, "package.json"));
+ let modulePath: string;
+ try {
+ modulePath = require.resolve("@vercel/connect/manifest");
+ } catch {
+ throw new Error(
+ "Connect-backed resources require @vercel/connect with manifest compiler support. Install or update @vercel/connect, then rerun `eve build`.",
+ );
+ }
+ try {
+ const compiler = (await import(pathToFileURL(modulePath).href)) as {
+ readonly experimental_createConnectManifestFromEveResources?: (snapshot: unknown) => unknown;
+ };
+ if (typeof compiler.experimental_createConnectManifestFromEveResources !== "function") {
+ throw new TypeError("missing experimental_createConnectManifestFromEveResources export");
+ }
+ return parseJsonObject(
+ compiler.experimental_createConnectManifestFromEveResources(input.snapshot),
+ );
+ } catch (error) {
+ const detail = error instanceof Error ? error.message : String(error);
+ throw new Error(
+ `Failed to create the Connect manifest: ${detail}. Update @vercel/connect and rerun \`eve build\`.`,
+ );
+ }
+}
diff --git a/packages/eve/src/internal/nitro/host/build-application.ts b/packages/eve/src/internal/nitro/host/build-application.ts
index 97153b5f1..14ea9b75c 100644
--- a/packages/eve/src/internal/nitro/host/build-application.ts
+++ b/packages/eve/src/internal/nitro/host/build-application.ts
@@ -4,7 +4,10 @@ import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
import { build as buildNitro, copyPublicAssets, prepare, prerender } from "nitro/builder";
import type { Nitro } from "nitro/types";
-import { resolvePackageSourceFilePath } from "#internal/application/package.js";
+import {
+ resolveInstalledPackageInfo,
+ resolvePackageSourceFilePath,
+} from "#internal/application/package.js";
import {
prepareEveVersionedCacheDirectory,
writeEveVersionedCacheMetadata,
@@ -31,6 +34,7 @@ import {
} from "#internal/workflow-bundle/vercel-workflow-output.js";
import { createProductionApplicationNitro } from "#internal/nitro/host/create-application-nitro.js";
import { emitVercelAgentSummary } from "#internal/nitro/host/build-vercel-agent-summary.js";
+import { emitConnectManifest } from "#internal/external-resources.js";
import { tryReadExtensionBuildConfig } from "#internal/nitro/host/build-extension.js";
import { copyHostMiddlewareFunctions } from "#internal/nitro/host/copy-host-middleware.js";
import { normalizeVercelServiceCrons } from "#internal/nitro/host/normalize-vercel-service-crons.js";
@@ -389,6 +393,15 @@ async function buildApplicationInWorkspace(
outputPath: workspace.publication.summary.stagedPath,
}),
);
+ await measureBuildPhase(profiler, "connect-manifest.emit", () =>
+ emitConnectManifest({
+ appRoot: preparedHost.appRoot,
+ generatorVersion: resolveInstalledPackageInfo().version,
+ manifest: preparedHost.compileResult.manifest,
+ outputDirectory: workspace.publication.output.stagedDir,
+ publicRoutePrefix,
+ }),
+ );
if (!isVercelBuild) {
await measureBuildPhase(profiler, "compiler-artifacts.stage", () =>
stageProductionCompilerArtifacts({
diff --git a/packages/eve/src/internal/testing/scenario-app.ts b/packages/eve/src/internal/testing/scenario-app.ts
index a4e55cf59..4758a5bf5 100644
--- a/packages/eve/src/internal/testing/scenario-app.ts
+++ b/packages/eve/src/internal/testing/scenario-app.ts
@@ -4,6 +4,7 @@ import {
cp,
mkdir,
mkdtemp,
+ readFile,
readdir,
rm,
writeFile,
@@ -221,6 +222,31 @@ function resolvePackageVersion(packageName: string): string {
return manifest.version;
}
+export async function resolveScenarioPackageVersion(packageName: string): Promise<string> {
+ let currentPath = dirname(require.resolve(packageName));
+
+ while (true) {
+ try {
+ const manifest = JSON.parse(await readFile(join(currentPath, "package.json"), "utf8")) as {
+ name?: unknown;
+ version?: unknown;
+ };
+
+ if (manifest.name === packageName && typeof manifest.version === "string") {
+ return manifest.version;
+ }
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+ }
+
+ const parentPath = dirname(currentPath);
+ if (parentPath === currentPath) {
+ throw new Error(`Could not find the installed package manifest for ${packageName}.`);
+ }
+ currentPath = parentPath;
+ }
+}
+
async function writeDescriptorDirectories(input: {
readonly appRoot: string;
readonly descriptor: ScenarioAppDescriptor;
diff --git a/packages/eve/src/public/channels/slack/app-manifest.test.ts b/packages/eve/src/public/channels/slack/app-manifest.test.ts
new file mode 100644
index 000000000..c09c739fb
--- /dev/null
+++ b/packages/eve/src/public/channels/slack/app-manifest.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+
+import {
+ buildSlackAppManifest,
+ defineSlackAppManifest,
+} from "#public/channels/slack/app-manifest.js";
+
+describe("Slack app manifests", () => {
+ it("builds the native baseline manifest", () => {
+ expect(buildSlackAppManifest(defineSlackAppManifest({}), "support")).toEqual({
+ $type: "https://docs.slack.dev/reference/app-manifest/",
+ display_information: { name: "support" },
+ features: {
+ app_home: {
+ home_tab_enabled: false,
+ messages_tab_enabled: true,
+ messages_tab_read_only_enabled: false,
+ },
+ bot_user: { display_name: "support" },
+ },
+ oauth_config: { scopes: { bot: ["app_mentions:read", "chat:write"] } },
+ settings: {
+ event_subscriptions: { bot_events: ["app_mention"] },
+ org_deploy_enabled: false,
+ socket_mode_enabled: false,
+ token_rotation_enabled: false,
+ },
+ });
+ });
+
+ it("uses a configured bot name and enforces Slack's app name limit", () => {
+ const definition = defineSlackAppManifest({ botName: "x".repeat(40) });
+
+ expect(buildSlackAppManifest(definition, "support")).toMatchObject({
+ display_information: { name: "x".repeat(35) },
+ features: { bot_user: { display_name: "x".repeat(35) } },
+ });
+ });
+});
diff --git a/packages/eve/src/public/channels/slack/app-manifest.ts b/packages/eve/src/public/channels/slack/app-manifest.ts
new file mode 100644
index 000000000..3840db7ad
--- /dev/null
+++ b/packages/eve/src/public/channels/slack/app-manifest.ts
@@ -0,0 +1,46 @@
+import type { AppsManifestCreateArguments } from "@slack/web-api";
+
+import { parseJsonObject, type JsonObject } from "#shared/json.js";
+
+export const SLACK_APP_MANIFEST_TYPE = "https://docs.slack.dev/reference/app-manifest/";
+
+export interface SlackAppManifestBuildDefinition {
+ readonly build: (channelName: string) => JsonObject;
+}
+
+export function defineSlackAppManifest(input: {
+ readonly botName?: string;
+}): SlackAppManifestBuildDefinition {
+ return {
+ build(channelName) {
+ const name = (input.botName ?? channelName).slice(0, 35);
+ const manifest = {
+ $type: SLACK_APP_MANIFEST_TYPE,
+ display_information: { name },
+ features: {
+ app_home: {
+ home_tab_enabled: false,
+ messages_tab_enabled: true,
+ messages_tab_read_only_enabled: false,
+ },
+ bot_user: { display_name: name },
+ },
+ oauth_config: { scopes: { bot: ["app_mentions:read", "chat:write"] } },
+ settings: {
+ event_subscriptions: { bot_events: ["app_mention"] },
+ org_deploy_enabled: false,
+ socket_mode_enabled: false,
+ token_rotation_enabled: false,
+ },
+ } satisfies AppsManifestCreateArguments["manifest"];
+ return manifest;
+ },
+ };
+}
+
+export function buildSlackAppManifest(value: unknown, channelName: string): JsonObject | undefined {
+ if (value === null || typeof value !== "object") return undefined;
+ const build = (value as { readonly build?: unknown }).build;
+ if (typeof build !== "function") return undefined;
+ return parseJsonObject(build(channelName));
+}
diff --git a/packages/eve/src/public/channels/slack/slackChannel.test.ts b/packages/eve/src/public/channels/slack/slackChannel.test.ts
index ee1766927..31f810928 100644
--- a/packages/eve/src/public/channels/slack/slackChannel.test.ts
+++ b/packages/eve/src/public/channels/slack/slackChannel.test.ts
@@ -4,7 +4,11 @@ import { afterAll, afterEach, beforeEach, describe, expect, it, onTestFinished,
import { buildAdapterContext } from "#channel/adapter-context.js";
import { callAdapterEventHandler, type ChannelAdapter } from "#channel/adapter.js";
-import { isCompiledChannel, type CompiledChannel } from "#channel/compiled-channel.js";
+import {
+ getChannelBuildMetadata,
+ isCompiledChannel,
+ type CompiledChannel,
+} from "#channel/compiled-channel.js";
import type { ChannelFrom, ChannelSource } from "#channel/channel-operations.js";
import { isHttpRouteDefinition } from "#channel/routes.js";
import { ContextContainer, contextStorage } from "#context/container.js";
@@ -492,6 +496,23 @@ describe("slackChannel()", () => {
expect(channel).toMatchObject({ turnPolicy: "queue" });
});
+ it("preserves Connect credential metadata for compilation", () => {
+ const vercelConnect = {
+ connector: "slack/my-agent",
+ requirement: {
+ reference: "connector:slack/my-agent",
+ service: "slack",
+ subjectTypes: ["app" as const],
+ method: "slack",
+ },
+ };
+ const credentials = { botToken: "xoxb-test", vercelConnect };
+
+ expect(getChannelBuildMetadata(slackChannel({ credentials }), "slack")).toMatchObject({
+ externalCredentials: vercelConnect,
+ });
+ });
+
it("classifies from durable state through the audience hook", () => {
const adapter = withState(getAdapter(slackChannel()), { audience: "private" });
diff --git a/packages/eve/src/public/channels/slack/slackChannel.ts b/packages/eve/src/public/channels/slack/slackChannel.ts
index 32ae546c9..79603764f 100644
--- a/packages/eve/src/public/channels/slack/slackChannel.ts
+++ b/packages/eve/src/public/channels/slack/slackChannel.ts
@@ -8,8 +8,9 @@ import type {
} from "#channel/channel-operations.js";
import { defaultDeliverResult } from "#channel/adapter.js";
import type { Session, SessionHandle } from "#channel/session.js";
-import { setChannelActivityRenderers } from "#channel/compiled-channel.js";
-import type { SessionAuthContext, TurnPolicy, TaskDeliveryPolicy } from "#channel/types.js";
+import { setChannelActivityRenderers, setChannelBuildMetadata } from "#channel/compiled-channel.js";
+import type { SessionAuthContext, TaskDeliveryPolicy, TurnPolicy } from "#channel/types.js";
+import type { VercelConnectMetadata } from "#shared/vercel-connect-metadata.js";
import type { CardElement } from "#compiled/chat/index.js";
import type { SessionContext } from "#public/definitions/callback-context.js";
import type { ChannelContinuationOps } from "#public/definitions/channel.js";
@@ -70,6 +71,7 @@ import {
} from "#public/channels/slack/thread.js";
import { buildSlackAuthContext, slackUserIdFromAuthContext } from "#public/channels/slack/auth.js";
import { SLACK_CHANNEL_DEFAULT_ROUTE } from "#public/channels/slack/constants.js";
+import { defineSlackAppManifest } from "#public/channels/slack/app-manifest.js";
import { handleInteractionPost } from "#public/channels/slack/interactions.js";
import {
bindSlackSessionOperations,
@@ -303,6 +305,8 @@ export interface SlackChannelCredentials {
* integrations (e.g. Connect) that authenticate webhooks out-of-band.
*/
readonly webhookVerifier?: SlackWebhookVerifier;
+ /** Build-time metadata supplied by Vercel Connect credential helpers. */
+ readonly vercelConnect?: VercelConnectMetadata;
}
/** Target accepted by `ctx.to(slack, target)` from route and schedule handlers. */
@@ -1061,6 +1065,12 @@ export function slackChannel(config: SlackChannelConfig = {}): SlackChannel {
},
renderers: activityRenderers,
});
+ const credentials = config.credentials as { readonly vercelConnect?: unknown } | undefined;
+ const manifest = defineSlackAppManifest({ botName: config.botName });
+ setChannelBuildMetadata(channel, (channelName) => ({
+ externalCredentials: credentials?.vercelConnect,
+ manifest: manifest.build(channelName),
+ }));
return channel;
}
diff --git a/packages/eve/src/shared/validate-authorization.ts b/packages/eve/src/shared/validate-authorization.ts
index b39034e74..92c98734e 100644
--- a/packages/eve/src/shared/validate-authorization.ts
+++ b/packages/eve/src/shared/validate-authorization.ts
@@ -9,6 +9,7 @@ import type {
InteractiveAuthorizationDefinition,
NonInteractiveAuthorizationDefinition,
} from "#shared/connection-types.js";
+import { extractVercelConnectMetadata } from "#shared/vercel-connect-metadata.js";
/**
* Validates that authored `auth` conforms to the connection auth contract.
@@ -93,7 +94,7 @@ export function normalizeAuthorizationSpec(
}
const auth = authorization as Record<string, unknown>;
- const vercelConnect = extractVercelConnectMarker(auth.vercelConnect);
+ const vercelConnect = extractVercelConnectMetadata(auth.vercelConnect);
const displayName = auth.displayName as string | undefined;
const evict =
typeof auth.evict === "function" ? (auth.evict as AuthorizationDefinition["evict"]) : undefined;
@@ -123,25 +124,3 @@ export function normalizeAuthorizationSpec(
if (evict !== undefined) nonInteractive = { ...nonInteractive, evict };
return nonInteractive;
}
-
-/**
- * Reads the optional `vercelConnect: { connector: string }` marker
- * attached by `@vercel/connect/eve`'s `connect()` helper. Returns the
- * parsed marker when present and well-formed, otherwise `undefined`.
- *
- * The runtime uses the marker for Connect-specific authorization behavior,
- * while downstream tooling can attribute the auth back to a Vercel Connect
- * connector without inspecting `getToken`'s closure state. Validation is
- * lenient (a malformed marker is dropped, not thrown) so a misbehaving auth
- * provider can't fail an otherwise-valid connection.
- */
-function extractVercelConnectMarker(value: unknown): { readonly connector: string } | undefined {
- if (value === null || typeof value !== "object") {
- return undefined;
- }
- const connector = (value as { connector?: unknown }).connector;
- if (typeof connector !== "string" || connector.length === 0) {
- return undefined;
- }
- return { connector };
-}
diff --git a/packages/eve/src/shared/vercel-connect-metadata.test.ts b/packages/eve/src/shared/vercel-connect-metadata.test.ts
new file mode 100644
index 000000000..95a9dbead
--- /dev/null
+++ b/packages/eve/src/shared/vercel-connect-metadata.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+
+import { extractVercelConnectMetadata } from "#shared/vercel-connect-metadata.js";
+
+const metadata = {
+ connector: "slack/my-agent",
+ requirement: {
+ reference: "connector:slack/my-agent",
+ service: "slack",
+ subjectTypes: ["app"],
+ method: "slack",
+ },
+};
+
+describe("extractVercelConnectMetadata", () => {
+ it("preserves a valid helper marker", () => {
+ expect(extractVercelConnectMetadata(metadata)).toEqual(metadata);
+ });
+
+ it("preserves requirements without a credential method", () => {
+ const { method: _method, ...requirement } = metadata.requirement;
+
+ expect(extractVercelConnectMetadata({ ...metadata, requirement })).toEqual({
+ connector: metadata.connector,
+ requirement,
+ });
+ });
+
+ it("preserves connector-only markers for runtime authorization", () => {
+ expect(extractVercelConnectMetadata({ connector: metadata.connector })).toEqual({
+ connector: metadata.connector,
+ });
+ });
+
+ it("drops malformed requirements while preserving the runtime connector", () => {
+ expect(
+ extractVercelConnectMetadata({
+ ...metadata,
+ requirement: { ...metadata.requirement, service: "" },
+ }),
+ ).toEqual({ connector: metadata.connector });
+ });
+});
diff --git a/packages/eve/src/shared/vercel-connect-metadata.ts b/packages/eve/src/shared/vercel-connect-metadata.ts
new file mode 100644
index 000000000..2c9bef05f
--- /dev/null
+++ b/packages/eve/src/shared/vercel-connect-metadata.ts
@@ -0,0 +1,58 @@
+interface ExternalCredentialRequirement {
+ readonly method?: string;
+ readonly reference: string;
+ readonly service: string;
+ readonly subjectTypes: readonly ("app" | "user")[];
+}
+
+export interface VercelConnectMetadata {
+ readonly connector: string;
+ readonly requirement?: ExternalCredentialRequirement;
+}
+
+export function extractVercelConnectMetadata(value: unknown): VercelConnectMetadata | undefined {
+ if (value === null || typeof value !== "object") return undefined;
+ const { connector, requirement } = value as {
+ readonly connector?: unknown;
+ readonly requirement?: unknown;
+ };
+ if (typeof connector !== "string" || connector.length === 0) return undefined;
+ const parsedRequirement = extractCredentialRequirement(requirement);
+ return parsedRequirement === undefined
+ ? { connector }
+ : { connector, requirement: parsedRequirement };
+}
+
+function extractCredentialRequirement(value: unknown): ExternalCredentialRequirement | undefined {
+ if (value === null || typeof value !== "object") return undefined;
+ const { method, reference, service, subjectTypes } = value as {
+ readonly method?: unknown;
+ readonly reference?: unknown;
+ readonly service?: unknown;
+ readonly subjectTypes?: unknown;
+ };
+ if (
+ typeof reference !== "string" ||
+ reference.length === 0 ||
+ typeof service !== "string" ||
+ service.length === 0 ||
+ !Array.isArray(subjectTypes) ||
+ subjectTypes.length === 0 ||
+ !subjectTypes.every((subjectType) => subjectType === "app" || subjectType === "user") ||
+ (method !== undefined && (typeof method !== "string" || method.length === 0))
+ ) {
+ return undefined;
+ }
+ const parsed: {
+ method?: string;
+ reference: string;
+ service: string;
+ subjectTypes: ("app" | "user")[];
+ } = {
+ reference,
+ service,
+ subjectTypes,
+ };
+ if (typeof method === "string") parsed.method = method;
+ return parsed;
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b1dff9f2f..a09afcfc5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -207,8 +207,8 @@ catalogs:
specifier: 19.2.3
version: 19.2.3
'@vercel/connect':
- specifier: 2.2.0
- version: 2.2.0
+ specifier: 2.3.3
+ version: 2.3.3
'@vercel/otel':
specifier: 2.1.3
version: 2.1.3
@@ -1722,6 +1722,9 @@ importers:
'@photon-ai/chat-adapter-imessage':
specifier: 3.2.0
+ '@slack/web-api':
+ specifier: 7.19.0
'@standard-schema/spec':
specifier: 1.1.0
version: 1.1.0
@@ -1742,7 +1745,7 @@ importers:
version: 2.8.0
'@vercel/connect':
specifier: 'catalog:'
'@vercel/detect-agent':
specifier: 1.2.3
version: 1.2.3
@@ -1884,7 +1887,7 @@ importers:
dependencies:
'@vercel/connect':
specifier: 'catalog:'
eve:
specifier: workspace:*
version: link:../eve
@@ -7410,6 +7413,9 @@ packages:
'@vercel/[email protected]':
resolution: {integrity: sha512-KeSN2HBp8puZrj7kVjSEneDi9yBqW4nAD9AnhGhdYjGNpHl7IkXZVb3HnNe0WWc5+20RlUtmAGWNPQ8qP5QBhQ==}
+ '@vercel/[email protected]':
+ resolution: {integrity: sha512-kQLt5Pm8wKd7/imzDY9/9u0tf8OuRkAuXI+s7j057FSUrXapAmumJSKwDqnR4ZZqdWoUcNLlFAgVIAdiwcGTcw==}
+
'@vercel/[email protected]':
resolution: {integrity: sha512-kQF8LGie/Hbdq9/psJxLE7owRTcqMQMhgybU04gCeR7cbQAr5t8OrjefDNColJv1QSSucFt4pLwRiARVmlOnug==}
engines: {node: '>= 18'}
@@ -7464,6 +7470,32 @@ packages:
eve:
optional: true
+ '@vercel/[email protected]':
+ resolution: {integrity: sha512-Hu9BhaKgY7tBE4pYBKzlqQB0LHl805ht6Qb2EBPPP4sw7Zi/dJMqvsHFVhCqo9n0fcHo4H5vwMYXQ+pMXOhbHA==}
+ peerDependencies:
+ '@ai-sdk/mcp': ^1 || ^2
+ '@auth/core': '>=0.37.0'
+ '@chat-adapter/slack': ^4.0.0
+ '@modelcontextprotocol/sdk': ^1.29.0
+ ai: ^6 || ^7.0.0-beta.0
+ better-auth: '>=1.5.0'
+ eve: '>=0.39.1'
+ peerDependenciesMeta:
+ '@ai-sdk/mcp':
+ optional: true
+ '@auth/core':
+ optional: true
+ '@chat-adapter/slack':
+ optional: true
+ '@modelcontextprotocol/sdk':
+ optional: true
+ ai:
+ optional: true
+ better-auth:
+ optional: true
+ eve:
+ optional: true
+
'@vercel/[email protected]':
resolution: {integrity: sha512-VYNCgUc0nOmC4WJmWw9GkrKdfr8Zl4/rxhC5SvgacBgxiW9W/9NRttUoHHXV8xdII3MaRgkZZVX8Ikzc/Jmjag==}
engines: {node: '>=14'}
@@ -7523,6 +7555,10 @@ packages:
resolution: {integrity: sha512-aeq4/sgVh80zO6j2H+7FRfsG6NOXBrvzV1EEO8IdXPEJgwHIPakP+BFq3QmprsEQ18bIimds07kvaYhm2lehtg==}
engines: {node: '>= 20'}
+ '@vercel/[email protected]':
+ resolution: {integrity: sha512-TcbdH3YtGS2KU98T99dN4sbf+E4vbJZsJTRN97wKQ7QWQ0BR7U02QX3KN4+5GHxBtKTj1c5CnvTTitc2ZRad0A==}
+ engines: {node: '>= 20'}
+
'@vercel/[email protected]':
resolution: {integrity: sha512-Ofvzs9qhftRD1YMLuPnhbXjQZG6IKrJ9AmEKmRHRGfoWlV89ed2gAOkvddkFiZDFZJm2rrFNdeZKRVxoCdnWiw==}
engines: {node: ^18.19.0 || >=20.6.0}
@@ -16949,6 +16985,7 @@ snapshots:
'@cfworker/json-schema': 4.1.1
transitivePeerDependencies:
- supports-color
+ optional: true
'@modelcontextprotocol/[email protected]':
dependencies:
@@ -20988,6 +21025,11 @@ snapshots:
xdg-app-paths: 5.5.1
zod: 4.5.4
+ '@vercel/[email protected]':
+ dependencies:
+ xdg-app-paths: 5.5.1
+ zod: 4.5.4
+
'@vercel/[email protected]':
dependencies:
execa: 5.1.1
@@ -21016,13 +21058,25 @@ snapshots:
ai: 7.0.105([email protected])
eve: link:packages/eve
dependencies:
- '@vercel/oidc': 3.8.8
+ '@vercel/oidc': 3.8.9
+ optionalDependencies:
+ '@ai-sdk/mcp': 2.0.52([email protected])
+ '@auth/core': 0.41.2
+ '@modelcontextprotocol/sdk': 1.30.0(@cfworker/[email protected])([email protected])([email protected])
+ ai: 7.0.105([email protected])
+ eve: link:packages/eve
+
+ dependencies:
+ '@vercel/oidc': 3.8.9
optionalDependencies:
'@ai-sdk/mcp': 2.0.52([email protected])
'@auth/core': 0.41.2
+ '@modelcontextprotocol/sdk': 1.30.0(@cfworker/[email protected])([email protected])([email protected])
ai: 7.0.105([email protected])
@@ -21150,6 +21204,12 @@ snapshots:
'@vercel/cli-exec': 1.0.1
jose: 5.10.0
+ '@vercel/[email protected]':
+ dependencies:
+ '@vercel/cli-config': 0.3.0
+ '@vercel/cli-exec': 1.0.1
+ jose: 5.10.0
+
'@vercel/[email protected](@opentelemetry/[email protected])(@opentelemetry/[email protected])(@opentelemetry/[email protected](@opentelemetry/[email protected])([email protected]))(@opentelemetry/[email protected](@opentelemetry/[email protected]))(@opentelemetry/[email protected](@opentelemetry/[email protected]))(@opentelemetry/[email protected](@opentelemetry/[email protected]))(@opentelemetry/[email protected](@opentelemetry/[email protected]))':
dependencies:
'@opentelemetry/api': 1.9.1
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index ddaec0f0b..6be6aad00 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -42,7 +42,7 @@ catalog:
"@types/node": "24.13.3"
"@types/react": "19.2.15"
"@types/react-dom": "19.2.3"
- "@vercel/connect": "2.2.0"
+ "@vercel/connect": "2.3.3"
"@vercel/otel": "2.1.3"
"@vercel/sandbox": "3.3.0"
"@workflow/world-postgres": "5.0.0-beta.46"