@vercel/connect 0.6.2 → 0.8.0

package/README.md

@@ -5,7 +5,7 @@ SDK for obtaining scoped tokens for third-party services on behalf of apps or us
 Seven entrypoints, all ESM:
 
 - `@vercel/connect` — core token / authorization SDK
-- `@vercel/connect/chat` — adapter helpers for the [Chat SDK](https://chat-sdk.dev) (`chat`): `connectSlackAdapter`, `connectGitHubAdapter`, `connectLinearAdapter` (no Chat SDK dependency — returns structural config)
+- `@vercel/connect/chat` — adapter helpers for the [Chat SDK](https://chat-sdk.dev) (`chat`): `connectSlackAdapter`, `connectDiscordAdapter`, `connectGitHubAdapter`, `connectLinearAdapter`, `connectNotionAdapter`, `connectTelegramAdapter` (no Chat SDK dependency — returns structural config)
 - `@vercel/connect/ai-sdk` — [Vercel AI SDK](https://ai-sdk.dev) glue: re-exports `connectAuthProvider` for MCP transports (optional peers: `ai`, `@ai-sdk/mcp`)
 - `@vercel/connect/mcp` — canonical MCP-spec `OAuthClientProvider` for any MCP client (optional peer: `@ai-sdk/mcp`)
 - `@vercel/connect/eve` — adapter helpers for [Eve](https://github.com/vercel/eve) connections (optional peer: `eve`)
@@ -49,8 +49,8 @@ const { url } = await experimental_startInstallation(
 ### Chat SDK
 
 Spread the helper into the matching `create*Adapter` factory. Each helper
-wires both outbound app-scoped tokens and inbound Connect trigger-forwarded
-webhook verification (Vercel OIDC), so no provider secret lives in your env.
+wires outbound app-scoped tokens; trigger-capable providers also receive
+inbound Connect webhook verification via Vercel OIDC.
 
 ```ts
 import { createSlackAdapter } from '@chat-adapter/slack';
@@ -62,8 +62,12 @@ createSlackAdapter({
 });
 ```
 
-`connectGitHubAdapter` (`installationToken`) and `connectLinearAdapter`
-(`accessToken`) follow the same shape. See the
+`connectDiscordAdapter` (`botToken` and `applicationId`),
+`connectGitHubAdapter` (`installationToken`), and `connectLinearAdapter`
+(`accessToken`) follow the same shape. `connectNotionAdapter` supplies only the
+outbound `token`; native Notion webhooks still require
+`NOTION_VERIFICATION_TOKEN`. `connectTelegramAdapter` supplies only
+`botToken`; Telegram retains native webhook verification or polling. See the
 [Chat SDK integration guide](https://github.com/vercel/vercel/blob/main/packages/connect/docs/chat-integration.md)
 for connector setup, trigger forwarding, and per-platform examples.
 

package/dist/authorization.d.ts

@@ -5,6 +5,8 @@ export interface ConnectAuthorizationOptions {
     webhook?: string;
     deviceCode?: boolean;
     expiresInMs?: number;
+    /** OAuth prompt value to pass to the connector's authorization server. */
+    prompt?: string;
 }
 export interface ConnectAuthorizationResponse {
     request: string;

package/dist/authorization.js

@@ -27,6 +27,7 @@ export async function startAuthorization(connector, params, options) {
         ...(options?.expiresInMs !== undefined && {
             expiresInMs: options.expiresInMs,
         }),
+        ...(options?.prompt !== undefined && { prompt: options.prompt }),
     };
     const response = await fetch(endpoint, {
         method: 'POST',

package/dist/chat/discord-adapter.d.ts

@@ -0,0 +1,28 @@
+import { type ConnectOptions, type ConnectTokenParams } from '../index.js';
+import type { ConnectDiscordAdapterConfig } from './types.js';
+/**
+ * Token parameters accepted by {@link connectDiscordAdapter}.
+ *
+ * Mirrors {@link ConnectTokenParams} from `@vercel/connect`, minus
+ * `subject` — Discord bot tokens are app-scoped, so this helper pins the
+ * subject to `{ type: "app" }`.
+ */
+export type ConnectDiscordAdapterParams = Omit<ConnectTokenParams, 'subject'>;
+/**
+ * Build a Discord adapter config fragment backed by a Vercel Connect Discord
+ * Bot connector.
+ *
+ * The bot token and application id are resolved from the same Connect token
+ * response. The webhook verifier accepts interactions forwarded by Connect
+ * using Vercel OIDC, so the deployment does not need Discord's public key.
+ *
+ * ```ts
+ * import { createDiscordAdapter } from "@chat-adapter/discord";
+ * import { connectDiscordAdapter } from "@vercel/connect/chat";
+ *
+ * createDiscordAdapter({
+ *   ...connectDiscordAdapter("discord/my-bot"),
+ * });
+ * ```
+ */
+export declare function connectDiscordAdapter(connector: string, params?: ConnectDiscordAdapterParams, options?: ConnectOptions): ConnectDiscordAdapterConfig;

package/dist/chat/discord-adapter.js

@@ -0,0 +1,43 @@
+import { getTokenResponse, } from '../index.js';
+import { createConnectWebhookVerifier } from './webhook-verifier.js';
+/**
+ * Build a Discord adapter config fragment backed by a Vercel Connect Discord
+ * Bot connector.
+ *
+ * The bot token and application id are resolved from the same Connect token
+ * response. The webhook verifier accepts interactions forwarded by Connect
+ * using Vercel OIDC, so the deployment does not need Discord's public key.
+ *
+ * ```ts
+ * import { createDiscordAdapter } from "@chat-adapter/discord";
+ * import { connectDiscordAdapter } from "@vercel/connect/chat";
+ *
+ * createDiscordAdapter({
+ *   ...connectDiscordAdapter("discord/my-bot"),
+ * });
+ * ```
+ */
+export function connectDiscordAdapter(connector, params = {}, options) {
+    let pending;
+    function resolveCredentials() {
+        if (!pending) {
+            pending = getTokenResponse(connector, { ...params, subject: { type: 'app' } }, options)
+                .then(response => {
+                const applicationId = response.metadata?.applicationId;
+                if (typeof applicationId !== 'string' || applicationId.length === 0) {
+                    throw new Error(`Vercel Connect connector ${connector} did not return a Discord application id.`);
+                }
+                return { applicationId, botToken: response.token };
+            })
+                .finally(() => {
+                pending = undefined;
+            });
+        }
+        return pending;
+    }
+    return {
+        applicationId: async () => (await resolveCredentials()).applicationId,
+        botToken: async () => (await resolveCredentials()).botToken,
+        webhookVerifier: createConnectWebhookVerifier(),
+    };
+}

package/dist/chat/index.d.ts

@@ -4,7 +4,7 @@
  * Holds helpers that adapt the Vercel Connect SDK to the Chat SDK
  * (`chat`) platform adapters. Each helper returns a config fragment you
  * spread into the matching `create*Adapter` factory, wiring a Connect
- * connector for both outbound tokens (`getToken`) and inbound
+ * connector for both outbound credentials and inbound
  * trigger-forwarded webhooks (Vercel OIDC verification).
  *
  * The helpers stay decoupled from `@chat-adapter/*`: they return
@@ -21,7 +21,10 @@
  * ```
  */
 export { createConnectWebhookVerifier, type ConnectWebhookVerifier, type ConnectWebhookVerifierOptions, } from './webhook-verifier.js';
-export type { ConnectGitHubAdapterConfig, ConnectLinearAdapterConfig, ConnectTokenResolver, } from './types.js';
+export type { ConnectDiscordAdapterConfig, ConnectGitHubAdapterConfig, ConnectLinearAdapterConfig, ConnectNotionAdapterConfig, ConnectTelegramAdapterConfig, ConnectTokenResolver, } from './types.js';
+export { connectDiscordAdapter, type ConnectDiscordAdapterParams, } from './discord-adapter.js';
 export { connectSlackAdapter, type ConnectSlackAdapterConfig, type ConnectSlackAdapterParams, } from './slack-adapter.js';
 export { connectGitHubAdapter, type ConnectGitHubAdapterParams, } from './github-adapter.js';
 export { connectLinearAdapter, type ConnectLinearAdapterParams, } from './linear-adapter.js';
+export { connectNotionAdapter, type ConnectNotionAdapterParams, } from './notion-adapter.js';
+export { connectTelegramAdapter, type ConnectTelegramAdapterParams, } from './telegram-adapter.js';

package/dist/chat/index.js

@@ -4,7 +4,7 @@
  * Holds helpers that adapt the Vercel Connect SDK to the Chat SDK
  * (`chat`) platform adapters. Each helper returns a config fragment you
  * spread into the matching `create*Adapter` factory, wiring a Connect
- * connector for both outbound tokens (`getToken`) and inbound
+ * connector for both outbound credentials and inbound
  * trigger-forwarded webhooks (Vercel OIDC verification).
  *
  * The helpers stay decoupled from `@chat-adapter/*`: they return
@@ -21,6 +21,9 @@
  * ```
  */
 export { createConnectWebhookVerifier, } from './webhook-verifier.js';
+export { connectDiscordAdapter, } from './discord-adapter.js';
 export { connectSlackAdapter, } from './slack-adapter.js';
 export { connectGitHubAdapter, } from './github-adapter.js';
 export { connectLinearAdapter, } from './linear-adapter.js';
+export { connectNotionAdapter, } from './notion-adapter.js';
+export { connectTelegramAdapter, } from './telegram-adapter.js';

package/dist/chat/notion-adapter.d.ts

@@ -0,0 +1,28 @@
+import { type ConnectOptions, type ConnectTokenParams } from '../index.js';
+import type { ConnectNotionAdapterConfig } from './types.js';
+/**
+ * Token parameters accepted by {@link connectNotionAdapter}.
+ *
+ * Mirrors {@link ConnectTokenParams} from `@vercel/connect`, minus
+ * `subject` — Notion connection tokens are app-scoped, so this helper pins
+ * the subject to `{ type: "app" }`.
+ */
+export type ConnectNotionAdapterParams = Omit<ConnectTokenParams, 'subject'>;
+/**
+ * Build a Notion adapter config fragment backed by a Vercel Connect connector.
+ *
+ * The helper resolves outbound Notion API tokens only. Notion webhooks are
+ * delivered directly and must continue to use the adapter's native
+ * `verificationToken` / `NOTION_VERIFICATION_TOKEN` HMAC verification.
+ *
+ * ```ts
+ * import { createNotionAdapter } from "@chat-adapter/notion";
+ * import { connectNotionAdapter } from "@vercel/connect/chat";
+ *
+ * createNotionAdapter({
+ *   ...connectNotionAdapter("notion/acme-notion"),
+ *   verificationToken: process.env.NOTION_VERIFICATION_TOKEN,
+ * });
+ * ```
+ */
+export declare function connectNotionAdapter(connector: string, params?: ConnectNotionAdapterParams, options?: ConnectOptions): ConnectNotionAdapterConfig;

package/dist/chat/notion-adapter.js

@@ -0,0 +1,23 @@
+import { getToken, } from '../index.js';
+/**
+ * Build a Notion adapter config fragment backed by a Vercel Connect connector.
+ *
+ * The helper resolves outbound Notion API tokens only. Notion webhooks are
+ * delivered directly and must continue to use the adapter's native
+ * `verificationToken` / `NOTION_VERIFICATION_TOKEN` HMAC verification.
+ *
+ * ```ts
+ * import { createNotionAdapter } from "@chat-adapter/notion";
+ * import { connectNotionAdapter } from "@vercel/connect/chat";
+ *
+ * createNotionAdapter({
+ *   ...connectNotionAdapter("notion/acme-notion"),
+ *   verificationToken: process.env.NOTION_VERIFICATION_TOKEN,
+ * });
+ * ```
+ */
+export function connectNotionAdapter(connector, params = {}, options) {
+    return {
+        token: () => getToken(connector, { ...params, subject: { type: 'app' } }, options),
+    };
+}

package/dist/chat/telegram-adapter.d.ts

@@ -0,0 +1,29 @@
+import { type ConnectOptions, type ConnectTokenParams } from '../index.js';
+import type { ConnectTelegramAdapterConfig } from './types.js';
+/**
+ * Token parameters accepted by {@link connectTelegramAdapter}.
+ *
+ * Mirrors {@link ConnectTokenParams} from `@vercel/connect`, minus
+ * `subject` — Telegram bot tokens are app-scoped, so this helper pins the
+ * subject to `{ type: "app" }`.
+ */
+export type ConnectTelegramAdapterParams = Omit<ConnectTokenParams, 'subject'>;
+/**
+ * Build a Telegram adapter config fragment backed by a Vercel Connect
+ * connector.
+ *
+ * The helper resolves outbound Telegram Bot API tokens only. Telegram webhooks
+ * are delivered directly and must continue to use the adapter's native
+ * `secretToken` / `TELEGRAM_WEBHOOK_SECRET_TOKEN` verification, or polling.
+ *
+ * ```ts
+ * import { createTelegramAdapter } from "@chat-adapter/telegram";
+ * import { connectTelegramAdapter } from "@vercel/connect/chat";
+ *
+ * createTelegramAdapter({
+ *   ...connectTelegramAdapter("telegram/acme-telegram"),
+ *   secretToken: process.env.TELEGRAM_WEBHOOK_SECRET_TOKEN,
+ * });
+ * ```
+ */
+export declare function connectTelegramAdapter(connector: string, params?: ConnectTelegramAdapterParams, options?: ConnectOptions): ConnectTelegramAdapterConfig;

package/dist/chat/telegram-adapter.js

@@ -0,0 +1,24 @@
+import { getToken, } from '../index.js';
+/**
+ * Build a Telegram adapter config fragment backed by a Vercel Connect
+ * connector.
+ *
+ * The helper resolves outbound Telegram Bot API tokens only. Telegram webhooks
+ * are delivered directly and must continue to use the adapter's native
+ * `secretToken` / `TELEGRAM_WEBHOOK_SECRET_TOKEN` verification, or polling.
+ *
+ * ```ts
+ * import { createTelegramAdapter } from "@chat-adapter/telegram";
+ * import { connectTelegramAdapter } from "@vercel/connect/chat";
+ *
+ * createTelegramAdapter({
+ *   ...connectTelegramAdapter("telegram/acme-telegram"),
+ *   secretToken: process.env.TELEGRAM_WEBHOOK_SECRET_TOKEN,
+ * });
+ * ```
+ */
+export function connectTelegramAdapter(connector, params = {}, options) {
+    return {
+        botToken: () => getToken(connector, { ...params, subject: { type: 'app' } }, options),
+    };
+}

package/dist/chat/types.d.ts

@@ -6,6 +6,18 @@ import type { ConnectWebhookVerifier } from './webhook-verifier.js';
  * `@vercel/connect` SDK caches and refreshes server-side).
  */
 export type ConnectTokenResolver = () => Promise<string>;
+/**
+ * Partial Discord adapter config backed by Vercel Connect.
+ *
+ * Structurally matches the `applicationId`, `botToken`, and
+ * `webhookVerifier` options of `createDiscordAdapter` from
+ * `@chat-adapter/discord`.
+ */
+export interface ConnectDiscordAdapterConfig {
+    applicationId: ConnectTokenResolver;
+    botToken: ConnectTokenResolver;
+    webhookVerifier: ConnectWebhookVerifier;
+}
 /**
  * Partial GitHub adapter config backed by Vercel Connect.
  *
@@ -26,3 +38,23 @@ export interface ConnectLinearAdapterConfig {
     accessToken: ConnectTokenResolver;
     webhookVerifier: ConnectWebhookVerifier;
 }
+/**
+ * Partial Notion adapter config backed by Vercel Connect.
+ *
+ * Structurally matches the `token` option of `createNotionAdapter` from
+ * `@chat-adapter/notion`. Notion webhooks continue to use native HMAC
+ * verification and are not part of this config fragment.
+ */
+export interface ConnectNotionAdapterConfig {
+    token: ConnectTokenResolver;
+}
+/**
+ * Partial Telegram adapter config backed by Vercel Connect.
+ *
+ * Structurally matches the `botToken` option of `createTelegramAdapter` from
+ * `@chat-adapter/telegram`. Telegram webhooks continue to use native secret
+ * token verification and are not part of this config fragment.
+ */
+export interface ConnectTelegramAdapterConfig {
+    botToken: ConnectTokenResolver;
+}

package/dist/chat/webhook-verifier.d.ts

@@ -4,8 +4,8 @@ import { verifyVercelOidcToken } from '@vercel/oidc';
  * truthy value marks the request as verified; throwing (or returning a
  * falsy value) makes the adapter respond `401`.
  *
- * Mirrors the `webhookVerifier` option accepted by the Slack, GitHub,
- * and Linear adapters from the `chat` package, so the helpers in this
+ * Mirrors the `webhookVerifier` option accepted by the Slack, Discord,
+ * GitHub, and Linear adapters from the `chat` package, so the helpers in this
  * subpath stay decoupled from `@chat-adapter/*` while remaining
  * structurally compatible.
  */
@@ -25,8 +25,8 @@ export type ConnectWebhookVerifierOptions = Parameters<typeof verifyVercelOidcTo
  * the `Authorization` header. This verifier extracts that token and
  * validates it against Vercel's JWKS via
  * {@link verifyVercelOidcToken}, replacing the provider's native
- * signature check (Slack signing secret, GitHub webhook secret, Linear
- * webhook secret).
+ * signature check (Slack signing secret, Discord public key, GitHub webhook
+ * secret, Linear webhook secret).
  *
  * Trust boundary: by default the token must be issued by
  * `https://oidc.vercel.com` (issuer is hard-pinned) and match the

package/dist/chat/webhook-verifier.js

@@ -9,8 +9,8 @@ const BEARER_TOKEN_PATTERN = /^Bearer\s+(.+)$/i;
  * the `Authorization` header. This verifier extracts that token and
  * validates it against Vercel's JWKS via
  * {@link verifyVercelOidcToken}, replacing the provider's native
- * signature check (Slack signing secret, GitHub webhook secret, Linear
- * webhook secret).
+ * signature check (Slack signing secret, Discord public key, GitHub webhook
+ * secret, Linear webhook secret).
  *
  * Trust boundary: by default the token must be issued by
  * `https://oidc.vercel.com` (issuer is hard-pinned) and match the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/connect",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "license": "Apache-2.0",
   "type": "module",
   "repository": {
@@ -42,7 +42,7 @@
     "dist"
   ],
   "dependencies": {
-    "@vercel/oidc": "3.8.3"
+    "@vercel/oidc": "3.8.4"
   },
   "peerDependencies": {
     "@ai-sdk/mcp": "^1 || ^2",