@vercel/connect 2.3.1 → 2.3.3

package/dist/eve/connection-authorization.d.ts

@@ -77,6 +77,12 @@ export interface EveAuthorizationOptions {
      *   Vercel Connect app.
      */
     readonly principalType?: 'app' | 'user';
+    /**
+     * Stable service identifier included in eve's external-resource snapshot.
+     * Set this when the connection should participate in Connect manifest
+     * generation; connector-only runtime usage may leave it unset.
+     */
+    readonly service?: string;
     /**
      * Extra parameters forwarded to every `getTokenResponse` /
      * `startAuthorization` call, minus `subject` — the helper derives
@@ -194,6 +200,10 @@ export type EveAuthorizationInput = string | EveAuthorizationOptions;
  * URL) can resolve UID → `scl_...` against the Vercel Connect API;
  * both forms address the same connector.
  *
+ * Newer helpers may include a complete external-resource requirement for
+ * Eve's build tooling. It remains optional so existing connector-only metadata
+ * assignments stay source-compatible.
+ *
  * The marker is purely metadata — it does not influence the runtime
  * token-fetching identity, which continues to be driven by the
  * `getToken` / `startAuthorization` / `completeAuthorization`
@@ -201,7 +211,15 @@ export type EveAuthorizationInput = string | EveAuthorizationOptions;
  * also sent as the managed OAuth UID.
  */
 export interface VercelConnectMetadata {
+    /** Raw connector UID or service-connector key passed to the helper. */
     readonly connector: string;
+    /** Complete credential requirement consumed by eve build tooling. */
+    readonly requirement?: {
+        readonly method?: string;
+        readonly reference: string;
+        readonly service: string;
+        readonly subjectTypes: readonly ('app' | 'user')[];
+    };
 }
 /**
  * Augments the standard Eve authorization shape with the

package/dist/eve/connection-authorization.js

@@ -34,7 +34,16 @@ import { ConnectError, ConnectorInstallationRequiredError, deleteTokenCacheEntry
 import { provisionEveOAuthConnector } from './provision-oauth-connector.js';
 export function connect(input) {
     const options = normalizeAuthorizationOptions(input);
-    const vercelConnect = { connector: options.connector };
+    const requirement = options.service === undefined
+        ? undefined
+        : {
+            reference: `connector:${options.connector}`,
+            service: options.service,
+            subjectTypes: [options.principalType ?? 'user'],
+        };
+    const vercelConnect = requirement === undefined
+        ? { connector: options.connector }
+        : { connector: options.connector, requirement };
     const evict = makeEvict(options);
     if (options.principalType === 'app') {
         return { ...buildNonInteractiveDefinition(options), vercelConnect, evict };

package/dist/eve/slack-credentials.d.ts

@@ -1,5 +1,6 @@
 import type { SlackChannelCredentials } from 'eve/channels/slack';
 import { type ConnectOptions, type ConnectTokenParams } from '../index.js';
+import type { VercelConnectMetadata } from './connection-authorization.js';
 /**
  * Token parameters accepted by {@link connectSlackCredentials}.
  *
@@ -43,4 +44,6 @@ export type ConnectSlackCredentialsParams = Omit<ConnectTokenParams, 'subject'>;
  * connectSlackCredentials("scl_...", { installationId: workspaceId });
  * ```
  */
-export declare function connectSlackCredentials(connector: string, params?: ConnectSlackCredentialsParams, options?: ConnectOptions): SlackChannelCredentials;
+export declare function connectSlackCredentials(connector: string, params?: ConnectSlackCredentialsParams, options?: ConnectOptions): SlackChannelCredentials & {
+    readonly vercelConnect: VercelConnectMetadata;
+};

package/dist/eve/slack-credentials.js

@@ -38,5 +38,14 @@ export function connectSlackCredentials(connector, params = {}, options) {
     return {
         botToken: () => getToken(connector, { ...params, subject: { type: 'app' } }, options),
         webhookVerifier: vercelOidc(),
+        vercelConnect: {
+            connector,
+            requirement: {
+                method: 'slack',
+                reference: `connector:${connector}`,
+                service: 'slack',
+                subjectTypes: ['app'],
+            },
+        },
     };
 }

package/dist/internal/connect-manifest.d.ts

@@ -0,0 +1,46 @@
+export declare const CONNECT_MANIFEST_KIND = "vercel-connect-manifest";
+export declare const CONNECT_MANIFEST_VERSION = 1;
+export type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+export type JsonValue = boolean | null | number | string | readonly JsonValue[] | JsonObject;
+export type ConnectSubjectType = 'app' | 'user';
+export type ConnectInterface = {
+    readonly protocol: 'mcp' | 'openapi';
+    readonly url: string;
+} | {
+    readonly npm: string;
+    readonly protocol: 'custom';
+    readonly url: string;
+};
+export interface ConnectRequirement {
+    readonly connect: {
+        readonly manifest: JsonObject;
+        readonly service: string;
+        readonly subjectTypes: readonly ConnectSubjectType[];
+        readonly type?: string;
+    };
+    readonly interfaces: readonly ConnectInterface[];
+    readonly target: string;
+    readonly triggers: readonly {
+        readonly path: string;
+    }[];
+    readonly uses: readonly {
+        readonly kind: 'channel' | 'connection';
+        readonly logicalPath: string;
+        readonly name: string;
+    }[];
+}
+export interface ConnectManifest {
+    readonly generator: {
+        readonly name: string;
+        readonly version: string;
+    };
+    readonly kind: typeof CONNECT_MANIFEST_KIND;
+    readonly requirements: readonly ConnectRequirement[];
+    readonly schemaVersion: typeof CONNECT_MANIFEST_VERSION;
+}
+export declare function createConnectManifest(input: {
+    readonly generator: ConnectManifest['generator'];
+    readonly requirements: readonly ConnectRequirement[];
+}): ConnectManifest;

package/dist/internal/connect-manifest.js

@@ -0,0 +1,10 @@
+export const CONNECT_MANIFEST_KIND = 'vercel-connect-manifest';
+export const CONNECT_MANIFEST_VERSION = 1;
+export function createConnectManifest(input) {
+    return {
+        generator: input.generator,
+        kind: CONNECT_MANIFEST_KIND,
+        requirements: input.requirements,
+        schemaVersion: CONNECT_MANIFEST_VERSION,
+    };
+}

package/dist/internal/eve-manifest.d.ts

@@ -0,0 +1,2 @@
+import { type ConnectManifest } from './connect-manifest.js';
+export declare function createConnectManifestFromEve(input: unknown): ConnectManifest;

package/dist/internal/eve-manifest.js

@@ -0,0 +1,195 @@
+import { createConnectManifest, } from './connect-manifest.js';
+import { RFC_7591_MANIFEST } from './provider-manifest.js';
+const EVE_SNAPSHOT_KIND = 'eve-external-resources';
+const EVE_SNAPSHOT_VERSION = 1;
+export function createConnectManifestFromEve(input) {
+    const snapshot = parseEveSnapshot(input);
+    return createConnectManifest({
+        generator: snapshot.generator,
+        requirements: collectConnectRequirements(snapshot.resources),
+    });
+}
+function collectConnectRequirements(resources) {
+    const requirements = new Map();
+    for (const resource of resources) {
+        const next = toConnectRequirement(resource);
+        const current = requirements.get(next.target);
+        if (current === undefined) {
+            requirements.set(next.target, next);
+            continue;
+        }
+        assertCompatibleRequirements(current, next);
+        requirements.set(next.target, {
+            ...current,
+            interfaces: appendDistinct(current.interfaces, next.interfaces),
+            triggers: appendDistinct(current.triggers, next.triggers),
+            uses: appendDistinct(current.uses, next.uses),
+        });
+    }
+    return [...requirements.values()];
+}
+function assertCompatibleRequirements(current, next) {
+    const target = current.target;
+    if (current.connect.service !== next.connect.service) {
+        throw conflictingRequirement(target, 'service');
+    }
+    if (current.connect.type !== next.connect.type) {
+        throw conflictingRequirement(target, 'method');
+    }
+    if (canonicalJson([...current.connect.subjectTypes].sort()) !==
+        canonicalJson([...next.connect.subjectTypes].sort())) {
+        throw conflictingRequirement(target, 'subjectTypes');
+    }
+    if (canonicalJson(current.connect.manifest) !==
+        canonicalJson(next.connect.manifest)) {
+        throw conflictingRequirement(target, 'provider manifest');
+    }
+}
+function conflictingRequirement(target, field) {
+    return new Error(`Conflicting declarations for credential target "${target}": ${field} must agree.`);
+}
+function appendDistinct(current, additional) {
+    const seen = new Set(current.map(value => canonicalJson(value)));
+    return [
+        ...current,
+        ...additional.filter(value => {
+            const key = canonicalJson(value);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        }),
+    ];
+}
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(item => canonicalJson(item)).join(',')}]`;
+    }
+    if (value !== null && typeof value === 'object') {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map(key => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'undefined';
+}
+function toConnectRequirement(resource) {
+    return {
+        connect: {
+            manifest: resource.kind === 'channel' ? resource.manifest : RFC_7591_MANIFEST,
+            service: resource.credentials.service,
+            subjectTypes: resource.credentials.subjectTypes,
+            ...(resource.credentials.method === undefined
+                ? {}
+                : { type: resource.credentials.method }),
+        },
+        interfaces: resource.kind === 'connection'
+            ? [{ protocol: resource.protocol.type, url: resource.protocol.url }]
+            : [],
+        target: resource.credentials.reference,
+        triggers: resource.kind === 'channel' ? [resource.route] : [],
+        uses: [
+            {
+                kind: resource.kind,
+                logicalPath: resource.logicalPath,
+                name: resource.name,
+            },
+        ],
+    };
+}
+function parseEveSnapshot(input) {
+    const snapshot = record(input, 'snapshot');
+    if (snapshot.kind !== EVE_SNAPSHOT_KIND ||
+        snapshot.schemaVersion !== EVE_SNAPSHOT_VERSION) {
+        throw new Error('Expected an eve-external-resources snapshot with schemaVersion 1.');
+    }
+    const generator = record(snapshot.generator, 'snapshot.generator');
+    if (generator.name !== 'eve')
+        throw new Error('Expected snapshot.generator.name to be "eve".');
+    const version = nonEmptyString(generator.version, 'snapshot.generator.version');
+    if (!Array.isArray(snapshot.resources))
+        throw new Error('Expected snapshot.resources to be an array.');
+    return {
+        generator: { name: 'eve', version },
+        kind: EVE_SNAPSHOT_KIND,
+        resources: snapshot.resources.map((value, index) => parseResource(value, index)),
+        schemaVersion: EVE_SNAPSHOT_VERSION,
+    };
+}
+function parseResource(value, index) {
+    const path = `snapshot.resources[${index}]`;
+    const resource = record(value, path);
+    const kind = resource.kind;
+    if (kind !== 'channel' && kind !== 'connection') {
+        throw new Error(`Expected ${path}.kind to be "channel" or "connection".`);
+    }
+    const common = {
+        credentials: parseCredentials(resource.credentials, `${path}.credentials`),
+        logicalPath: nonEmptyString(resource.logicalPath, `${path}.logicalPath`),
+        name: nonEmptyString(resource.name, `${path}.name`),
+    };
+    if (kind === 'connection') {
+        const protocol = record(resource.protocol, `${path}.protocol`);
+        const type = protocol.type;
+        if (type !== 'mcp' && type !== 'openapi') {
+            throw new Error(`Expected ${path}.protocol.type to be "mcp" or "openapi".`);
+        }
+        return {
+            ...common,
+            kind,
+            protocol: {
+                type,
+                url: nonEmptyString(protocol.url, `${path}.protocol.url`),
+            },
+        };
+    }
+    const route = record(resource.route, `${path}.route`);
+    return {
+        ...common,
+        kind,
+        logicalPath: common.logicalPath,
+        manifest: jsonObject(resource.manifest, `${path}.manifest`),
+        name: common.name,
+        route: { path: nonEmptyString(route.path, `${path}.route.path`) },
+    };
+}
+function parseCredentials(value, path) {
+    const credentials = record(value, path);
+    if (!Array.isArray(credentials.subjectTypes) ||
+        credentials.subjectTypes.length === 0) {
+        throw new Error(`Expected ${path}.subjectTypes to be a non-empty array.`);
+    }
+    const subjectTypes = credentials.subjectTypes.map((value, index) => {
+        if (value !== 'app' && value !== 'user') {
+            throw new Error(`Expected ${path}.subjectTypes[${index}] to be "app" or "user".`);
+        }
+        return value;
+    });
+    const method = optionalNonEmptyString(credentials.method, `${path}.method`);
+    return {
+        ...(method === undefined ? {} : { method }),
+        reference: nonEmptyString(credentials.reference, `${path}.reference`),
+        service: nonEmptyString(credentials.service, `${path}.service`),
+        subjectTypes,
+    };
+}
+function jsonObject(value, path) {
+    const parsed = JSON.parse(JSON.stringify(value));
+    return record(parsed, path);
+}
+function optionalNonEmptyString(value, path) {
+    return value === undefined ? undefined : nonEmptyString(value, path);
+}
+function nonEmptyString(value, path) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`Expected ${path} to be a non-empty string.`);
+    }
+    return value;
+}
+function record(value, path) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Expected ${path} to be an object.`);
+    }
+    return value;
+}

package/dist/internal/provider-manifest.d.ts

@@ -0,0 +1,3 @@
+export declare const RFC_7591_MANIFEST: {
+    readonly $type: "https://datatracker.ietf.org/doc/html/rfc7591";
+};

package/dist/internal/provider-manifest.js

@@ -0,0 +1,3 @@
+export const RFC_7591_MANIFEST = {
+    $type: 'https://datatracker.ietf.org/doc/html/rfc7591',
+};

package/dist/manifest/index.d.ts

@@ -0,0 +1,2 @@
+export { createConnectManifestFromEve as experimental_createConnectManifestFromEveResources } from '../internal/eve-manifest.js';
+export type { ConnectManifest as experimental_ConnectManifest } from '../internal/connect-manifest.js';

package/dist/manifest/index.js

@@ -0,0 +1 @@
+export { createConnectManifestFromEve as experimental_createConnectManifestFromEveResources } from '../internal/eve-manifest.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/connect",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "license": "Apache-2.0",
   "type": "module",
   "repository": {
@@ -21,6 +21,10 @@
       "types": "./dist/eve/index.d.ts",
       "default": "./dist/eve/index.js"
     },
+    "./manifest": {
+      "types": "./dist/manifest/index.d.ts",
+      "default": "./dist/manifest/index.js"
+    },
     "./betterauth": {
       "types": "./dist/betterauth/index.d.ts",
       "default": "./dist/betterauth/index.js"
@@ -46,7 +50,7 @@
     "dist"
   ],
   "dependencies": {
-    "@vercel/oidc": "3.8.8"
+    "@vercel/oidc": "3.8.9"
   },
   "peerDependencies": {
     "@ai-sdk/mcp": "^1 || ^2",