@vercel/connect 0.8.0 → 1.0.0

package/dist/authorization.d.ts

@@ -7,6 +7,12 @@ export interface ConnectAuthorizationOptions {
     expiresInMs?: number;
     /** OAuth prompt value to pass to the connector's authorization server. */
     prompt?: string;
+    /**
+     * Region to send the request to, e.g. `sfo1`. Defaults to the
+     * `VERCEL_REGION` environment variable; override it to target a
+     * different region.
+     */
+    region?: string;
 }
 export interface ConnectAuthorizationResponse {
     request: string;

package/dist/authorization.js

@@ -1,5 +1,7 @@
 import { getVercelOidcToken } from '@vercel/oidc';
 import { isDetachedInteractiveAuth, validateCallbackUrl, validateWebhookUrl, } from './internal/url-validation.js';
+import { withDefaultScopes } from './internal/default-scopes.js';
+import { resolveBaseUrl } from './internal/base-url.js';
 export async function startAuthorization(connector, params, options) {
     if (!connector) {
         throw new Error('connector is required');
@@ -12,13 +14,14 @@ export async function startAuthorization(connector, params, options) {
         validateWebhookUrl(options.webhook);
     }
     const vercelToken = options?.vercelToken ?? (await getVercelOidcToken());
-    const endpoint = `https://api.vercel.com/v1/connect/authorize/${encodeURIComponent(connector)}`;
+    const baseUrl = resolveBaseUrl(options);
+    const endpoint = `${baseUrl}/v1/connect/authorize/${encodeURIComponent(connector)}`;
     const deviceCode = options?.deviceCode ?? (detachedInteractiveAuth ? true : undefined);
     const returnUrl = !detachedInteractiveAuth && options?.callbackUrl !== undefined
         ? { returnUrl: options.callbackUrl }
         : {};
     const body = {
-        ...params,
+        ...withDefaultScopes(params),
         ...returnUrl,
         ...(options?.webhook !== undefined && { webhook: options.webhook }),
         ...(deviceCode !== undefined && {

package/dist/chat/index.d.ts

@@ -21,10 +21,11 @@
  * ```
  */
 export { createConnectWebhookVerifier, type ConnectWebhookVerifier, type ConnectWebhookVerifierOptions, } from './webhook-verifier.js';
-export type { ConnectDiscordAdapterConfig, ConnectGitHubAdapterConfig, ConnectLinearAdapterConfig, ConnectNotionAdapterConfig, ConnectTelegramAdapterConfig, ConnectTokenResolver, } from './types.js';
+export type { ConnectDiscordAdapterConfig, ConnectGitHubAdapterConfig, ConnectLinearAdapterConfig, ConnectLinqAdapterConfig, ConnectLinqCredentials, 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 { connectLinqAdapter, type ConnectLinqAdapterParams, } from './linq-adapter.js';
 export { connectNotionAdapter, type ConnectNotionAdapterParams, } from './notion-adapter.js';
 export { connectTelegramAdapter, type ConnectTelegramAdapterParams, } from './telegram-adapter.js';

package/dist/chat/index.js

@@ -25,5 +25,6 @@ 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 { connectLinqAdapter, } from './linq-adapter.js';
 export { connectNotionAdapter, } from './notion-adapter.js';
 export { connectTelegramAdapter, } from './telegram-adapter.js';

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

@@ -0,0 +1,37 @@
+import { type ConnectOptions, type ConnectTokenParams } from '../index.js';
+import type { ConnectLinqAdapterConfig } from './types.js';
+/**
+ * Token parameters accepted by {@link connectLinqAdapter}.
+ *
+ * Mirrors {@link ConnectTokenParams} from `@vercel/connect`, minus `subject`.
+ * Linq credentials are app-scoped, so this helper always uses
+ * `{ type: 'app' }`.
+ */
+export type ConnectLinqAdapterParams = Omit<ConnectTokenParams, 'subject'>;
+/**
+ * Build a Linq adapter config fragment backed by a Vercel Connect connector.
+ *
+ * Spread the result into `createLinqAdapter` from `@linqapp/chat-sdk-adapter`:
+ *
+ * ```ts
+ * import { createLinqAdapter } from '@linqapp/chat-sdk-adapter';
+ * import { connectLinqAdapter } from '@vercel/connect/chat';
+ *
+ * createLinqAdapter({
+ *   ...connectLinqAdapter('linq/my-agent'),
+ * });
+ * ```
+ *
+ * Linq's SDK calls its Bearer credential `apiKey`; the lazy `credentials`
+ * provider supplies the app-scoped Connect token through that field only when
+ * the adapter needs it.
+ *
+ * Connect retains Linq's webhook signing secret and verifies trigger-forwarded
+ * webhooks before attaching a Vercel OIDC token. `webhookVerifier` validates
+ * that OIDC token, replacing Linq's native HMAC check.
+ *
+ * The optional `params` and `options` arguments mirror the signature of
+ * {@link getTokenResponse}, allowing callers to pass through fields like
+ * `installationId`, `scopes`, or `validityBufferMs`.
+ */
+export declare function connectLinqAdapter(connector: string, params?: ConnectLinqAdapterParams, options?: ConnectOptions): ConnectLinqAdapterConfig;

package/dist/chat/linq-adapter.js

@@ -0,0 +1,37 @@
+import { getTokenResponse, } from '../index.js';
+import { createConnectWebhookVerifier } from './webhook-verifier.js';
+/**
+ * Build a Linq adapter config fragment backed by a Vercel Connect connector.
+ *
+ * Spread the result into `createLinqAdapter` from `@linqapp/chat-sdk-adapter`:
+ *
+ * ```ts
+ * import { createLinqAdapter } from '@linqapp/chat-sdk-adapter';
+ * import { connectLinqAdapter } from '@vercel/connect/chat';
+ *
+ * createLinqAdapter({
+ *   ...connectLinqAdapter('linq/my-agent'),
+ * });
+ * ```
+ *
+ * Linq's SDK calls its Bearer credential `apiKey`; the lazy `credentials`
+ * provider supplies the app-scoped Connect token through that field only when
+ * the adapter needs it.
+ *
+ * Connect retains Linq's webhook signing secret and verifies trigger-forwarded
+ * webhooks before attaching a Vercel OIDC token. `webhookVerifier` validates
+ * that OIDC token, replacing Linq's native HMAC check.
+ *
+ * The optional `params` and `options` arguments mirror the signature of
+ * {@link getTokenResponse}, allowing callers to pass through fields like
+ * `installationId`, `scopes`, or `validityBufferMs`.
+ */
+export function connectLinqAdapter(connector, params = {}, options) {
+    return {
+        credentials: async () => {
+            const response = await getTokenResponse(connector, { ...params, subject: { type: 'app' } }, options);
+            return { apiKey: response.token };
+        },
+        webhookVerifier: createConnectWebhookVerifier(),
+    };
+}

package/dist/chat/types.d.ts

@@ -38,6 +38,24 @@ export interface ConnectLinearAdapterConfig {
     accessToken: ConnectTokenResolver;
     webhookVerifier: ConnectWebhookVerifier;
 }
+/**
+ * Credentials resolved lazily by the Linq Chat SDK adapter.
+ *
+ * Structurally matches the return value of its `credentials` option.
+ */
+export interface ConnectLinqCredentials {
+    apiKey: string;
+}
+/**
+ * Partial Linq adapter config backed by Vercel Connect.
+ *
+ * Structurally matches the `credentials` and `webhookVerifier` options of
+ * `createLinqAdapter` from `@linqapp/chat-sdk-adapter`.
+ */
+export interface ConnectLinqAdapterConfig {
+    credentials: () => Promise<ConnectLinqCredentials>;
+    webhookVerifier: (request: Request, rawBody: Uint8Array) => Promise<unknown> | unknown;
+}
 /**
  * Partial Notion adapter config backed by Vercel Connect.
  *

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

@@ -9,7 +9,7 @@ import { verifyVercelOidcToken } from '@vercel/oidc';
  * subpath stay decoupled from `@chat-adapter/*` while remaining
  * structurally compatible.
  */
-export type ConnectWebhookVerifier = (request: Request, body: string) => Promise<unknown> | unknown;
+export type ConnectWebhookVerifier = (request: Request, body: string | Uint8Array) => Promise<unknown> | unknown;
 /**
  * Options forwarded to {@link verifyVercelOidcToken}. Defaults to
  * matching `project_id` / `environment` against the current Vercel

package/dist/connector.js

@@ -1,5 +1,6 @@
 import { getVercelOidcToken } from '@vercel/oidc';
 import { createConnectErrorFromResponse, } from './token.js';
+import { resolveBaseUrl } from './internal/base-url.js';
 /**
  * Fetch a connector's metadata from Vercel Connect.
  *
@@ -11,7 +12,8 @@ import { createConnectErrorFromResponse, } from './token.js';
  */
 export async function getConnectorMetadata(connector, options) {
     const vercelToken = options?.vercelToken ?? (await getVercelOidcToken());
-    const endpoint = `https://api.vercel.com/v1/connect/connectors/${encodeURIComponent(connector)}`;
+    const baseUrl = resolveBaseUrl(options);
+    const endpoint = `${baseUrl}/v1/connect/connectors/${encodeURIComponent(connector)}`;
     const response = await fetch(endpoint, {
         method: 'GET',
         headers: {

package/dist/eve/index.d.ts

@@ -11,5 +11,6 @@ export { CONNECT_OAUTH_ISSUER, connectOAuth, type ConnectOAuthAudienceEnvironmen
 export { connectDiscordCredentials, type ConnectDiscordCredentialsParams, } from './discord-credentials.js';
 export { connectGitHubCredentials, type ConnectGitHubCredentialsParams, } from './github-credentials.js';
 export { connectLinearCredentials, type ConnectLinearCredentialsParams, } from './linear-credentials.js';
+export { connectLinqCredentials, type ConnectLinqCredentials, type ConnectLinqCredentialsParams, } from './linq-credentials.js';
 export { connectPhotonCredentials, type ConnectPhotonCredentialProvider, type PhotonCredentials, type ConnectPhotonCredentialsParams, } from './photon-credentials.js';
 export { connectSlackCredentials, type ConnectSlackCredentialsParams, } from './slack-credentials.js';

package/dist/eve/index.js

@@ -11,5 +11,6 @@ export { CONNECT_OAUTH_ISSUER, connectOAuth, } from './connect-oauth.js';
 export { connectDiscordCredentials, } from './discord-credentials.js';
 export { connectGitHubCredentials, } from './github-credentials.js';
 export { connectLinearCredentials, } from './linear-credentials.js';
+export { connectLinqCredentials, } from './linq-credentials.js';
 export { connectPhotonCredentials, } from './photon-credentials.js';
 export { connectSlackCredentials, } from './slack-credentials.js';

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

@@ -0,0 +1,34 @@
+import { vercelOidc } from 'eve/channels/auth';
+import { type ConnectOptions, type ConnectTokenParams } from '../index.js';
+/** Linq channel credentials returned by {@link connectLinqCredentials}. */
+export interface ConnectLinqCredentials {
+    /** Short-lived API key for outbound Linq API calls. */
+    apiKey: () => Promise<string>;
+    /** Verifies webhooks forwarded by Vercel Connect. */
+    webhookVerifier: ReturnType<typeof vercelOidc>;
+}
+/**
+ * Token parameters accepted by {@link connectLinqCredentials}.
+ *
+ * Mirrors {@link ConnectTokenParams} from `@vercel/connect`, minus `subject`.
+ * Linq credentials are app-scoped, so this helper always uses
+ * `{ type: 'app' }`.
+ */
+export type ConnectLinqCredentialsParams = Omit<ConnectTokenParams, 'subject'>;
+/**
+ * Build Linq channel credentials backed by a Vercel Connect connector.
+ *
+ * The API-key resolver keeps token rotation delegated to Connect.
+ * `webhookVerifier` validates the Vercel OIDC token Connect attaches after it
+ * has verified and forwarded the provider webhook.
+ *
+ * ```ts
+ * import { connectLinqCredentials } from '@vercel/connect/eve';
+ * import { linqChannel } from 'eve/channels/linq';
+ *
+ * export default linqChannel({
+ *   credentials: connectLinqCredentials('linq/my-agent'),
+ * });
+ * ```
+ */
+export declare function connectLinqCredentials(connector: string, params?: ConnectLinqCredentialsParams, options?: ConnectOptions): ConnectLinqCredentials;

package/dist/eve/linq-credentials.js

@@ -0,0 +1,24 @@
+import { vercelOidc } from 'eve/channels/auth';
+import { getToken, } from '../index.js';
+/**
+ * Build Linq channel credentials backed by a Vercel Connect connector.
+ *
+ * The API-key resolver keeps token rotation delegated to Connect.
+ * `webhookVerifier` validates the Vercel OIDC token Connect attaches after it
+ * has verified and forwarded the provider webhook.
+ *
+ * ```ts
+ * import { connectLinqCredentials } from '@vercel/connect/eve';
+ * import { linqChannel } from 'eve/channels/linq';
+ *
+ * export default linqChannel({
+ *   credentials: connectLinqCredentials('linq/my-agent'),
+ * });
+ * ```
+ */
+export function connectLinqCredentials(connector, params = {}, options) {
+    return {
+        apiKey: () => getToken(connector, { ...params, subject: { type: 'app' } }, options),
+        webhookVerifier: vercelOidc(),
+    };
+}

package/dist/eve/provision-oauth-connector.js

@@ -1,6 +1,7 @@
 import { getVercelOidcToken } from '@vercel/oidc';
 import { ConnectError, createConnectErrorFromResponse } from '../token.js';
-const MANAGED_OAUTH_CONNECTOR_ENDPOINT = 'https://api.vercel.com/v1/connect/connectors/managed/oauth';
+import { resolveBaseUrl } from '../internal/base-url.js';
+const MANAGED_OAUTH_CONNECTOR_PATH = '/v1/connect/connectors/managed/oauth';
 const RESERVED_UID_PATTERN = /^(vc\/|[^/]*\.vercel\.com\/)/;
 const ALLOWED_RESERVED_UID_PREFIXES = ['mcp.vercel.com/'];
 const RESERVED_ID_PREFIXES = ['scl_', 'sca_', 'store_', 'ir_'];
@@ -12,9 +13,11 @@ export async function provisionEveOAuthConnector({ connector, connection, connec
         return;
     }
     const vercelToken = connectOptions?.vercelToken ?? (await getVercelOidcToken());
+    const endpoint = `${resolveBaseUrl(connectOptions)}${MANAGED_OAUTH_CONNECTOR_PATH}`;
     const cacheKey = JSON.stringify({
         connector,
         serverUrl,
+        endpoint,
         token: await tokenCacheKeyPart(vercelToken),
     });
     let promise = provisionCache.get(cacheKey);
@@ -23,6 +26,7 @@ export async function provisionEveOAuthConnector({ connector, connection, connec
             connector,
             serverUrl,
             vercelToken,
+            endpoint,
         }).catch(error => {
             if (isNonOAuthConnectorConflict(error)) {
                 return;
@@ -80,8 +84,8 @@ function isNonOAuthConnectorConflict(error) {
         error.status === 409 &&
         /not an OAuth connector/i.test(error.message));
 }
-async function provisionManagedOAuthConnector({ connector, serverUrl, vercelToken, }) {
-    const response = await fetch(MANAGED_OAUTH_CONNECTOR_ENDPOINT, {
+async function provisionManagedOAuthConnector({ connector, serverUrl, vercelToken, endpoint, }) {
+    const response = await fetch(endpoint, {
         method: 'POST',
         headers: {
             Accept: 'application/json',

package/dist/installation.d.ts

@@ -7,6 +7,12 @@ export interface ConnectInstallationOptions {
     tenantId?: string;
     deviceCode?: boolean;
     expiresInMs?: number;
+    /**
+     * Region to send the request to, e.g. `sfo1`. Defaults to the
+     * `VERCEL_REGION` environment variable; override it to target a
+     * different region.
+     */
+    region?: string;
 }
 export interface ConnectInstallationResponse {
     request: string;

package/dist/installation.js

@@ -1,6 +1,7 @@
 import { getVercelOidcToken } from '@vercel/oidc';
 import { isDetachedInteractiveAuth, validateCallbackUrl, validateWebhookUrl, } from './internal/url-validation.js';
 import { createConnectErrorFromResponse } from './token.js';
+import { resolveBaseUrl } from './internal/base-url.js';
 /**
  * Create an operator installation request for an app-scoped connector.
  *
@@ -19,7 +20,8 @@ export async function experimental_startInstallation(connector, params = {}, opt
         validateWebhookUrl(options.webhook);
     }
     const vercelToken = options?.vercelToken ?? (await getVercelOidcToken());
-    const endpoint = `https://api.vercel.com/v1/connect/install/${encodeURIComponent(connector)}`;
+    const baseUrl = resolveBaseUrl(options);
+    const endpoint = `${baseUrl}/v1/connect/install/${encodeURIComponent(connector)}`;
     const deviceCode = options?.deviceCode ?? (detachedInteractiveAuth ? true : undefined);
     const returnUrl = !detachedInteractiveAuth && options?.returnUrl !== undefined
         ? { returnUrl: options.returnUrl }

package/dist/internal/base-url.d.ts

@@ -0,0 +1,10 @@
+/** Base URL for the Vercel API when no region is available. */
+export declare const API_BASE_URL = "https://api.vercel.com";
+/**
+ * Resolves the Vercel API base URL for a region. The region comes from the
+ * `region` argument, then the `VERCEL_REGION` environment variable; without
+ * either, requests go to the global {@link API_BASE_URL}.
+ */
+export declare function resolveBaseUrl({ region }?: {
+    region?: string;
+}): string;

package/dist/internal/base-url.js

@@ -0,0 +1,12 @@
+import { readNonEmptyEnv } from './env.js';
+/** Base URL for the Vercel API when no region is available. */
+export const API_BASE_URL = 'https://api.vercel.com';
+/**
+ * Resolves the Vercel API base URL for a region. The region comes from the
+ * `region` argument, then the `VERCEL_REGION` environment variable; without
+ * either, requests go to the global {@link API_BASE_URL}.
+ */
+export function resolveBaseUrl({ region } = {}) {
+    const resolved = region ?? readNonEmptyEnv('VERCEL_REGION');
+    return resolved ? `https://api-${resolved}.vercel.com` : API_BASE_URL;
+}

package/dist/internal/default-scopes.d.ts

@@ -0,0 +1,2 @@
+import type { ConnectTokenParams } from '../token.js';
+export declare function withDefaultScopes(params: ConnectTokenParams): ConnectTokenParams;

package/dist/internal/default-scopes.js

@@ -0,0 +1,3 @@
+export function withDefaultScopes(params) {
+    return params.scopes === undefined ? { ...params, scopes: ['*'] } : params;
+}

package/dist/token.d.ts

@@ -27,8 +27,8 @@ export interface ConnectTokenParams {
     installationId?: string;
     audience?: string[];
     /**
-     * Access scopes to request. Use `['*']` to request the default scopes for
-     * the specified subject type.
+     * Access scopes to request. Defaults to `['*']`, which requests the default
+     * scopes for the specified subject type.
      */
     scopes?: string[];
     resources?: string[];
@@ -103,6 +103,12 @@ export interface ConnectOptions {
      * a stale bearer.
      */
     forceRefresh?: boolean;
+    /**
+     * Region to send the request to, e.g. `sfo1`. Defaults to the
+     * `VERCEL_REGION` environment variable; override it to target a
+     * different region.
+     */
+    region?: string;
 }
 export declare function getToken(connector: string, params: ConnectTokenParams, options?: ConnectOptions): Promise<string>;
 export declare function getTokenResponse(connector: string, params: ConnectTokenParams, options?: ConnectOptions): Promise<ConnectTokenResponse>;

package/dist/token.js

@@ -1,4 +1,6 @@
 import { getVercelOidcToken } from '@vercel/oidc';
+import { resolveBaseUrl } from './internal/base-url.js';
+import { withDefaultScopes } from './internal/default-scopes.js';
 export class ConnectError extends Error {
     code;
     status;
@@ -36,8 +38,9 @@ export async function getToken(connector, params, options) {
     return token;
 }
 export async function getTokenResponse(connector, params, options) {
-    const bufferMs = params.validityBufferMs ?? DEFAULT_VALIDITY_BUFFER_MS;
-    const cacheKey = tokenCacheKey(connector, params);
+    const requestParams = withDefaultScopes(params);
+    const bufferMs = requestParams.validityBufferMs ?? DEFAULT_VALIDITY_BUFFER_MS;
+    const cacheKey = tokenCacheKey(connector, requestParams);
     if (options?.forceRefresh) {
         cache.delete(cacheKey);
     }
@@ -53,7 +56,8 @@ export async function getTokenResponse(connector, params, options) {
         }
     }
     const vercelToken = options?.vercelToken ?? (await getVercelOidcToken());
-    const endpoint = `https://api.vercel.com/v1/connect/token/${encodeURIComponent(connector)}`;
+    const baseUrl = resolveBaseUrl(options);
+    const endpoint = `${baseUrl}/v1/connect/token/${encodeURIComponent(connector)}`;
     const response = await fetch(endpoint, {
         method: 'POST',
         headers: {
@@ -61,7 +65,7 @@ export async function getTokenResponse(connector, params, options) {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${vercelToken}`,
         },
-        body: JSON.stringify(params),
+        body: JSON.stringify(requestParams),
     });
     if (!response.ok) {
         throw await createConnectErrorFromResponse(response, 'Failed to get token');
@@ -75,7 +79,8 @@ export async function getTokenResponse(connector, params, options) {
 }
 export async function revokeToken(connector, params, options) {
     const vercelToken = options?.vercelToken ?? (await getVercelOidcToken());
-    const endpoint = `https://api.vercel.com/v1/connect/connectors/${encodeURIComponent(connector)}/tokens`;
+    const baseUrl = resolveBaseUrl(options);
+    const endpoint = `${baseUrl}/v1/connect/connectors/${encodeURIComponent(connector)}/tokens`;
     const response = await fetch(endpoint, {
         method: 'DELETE',
         headers: {
@@ -108,7 +113,7 @@ export async function revokeToken(connector, params, options) {
  * call. No-op when no matching entry exists.
  */
 export function deleteTokenCacheEntry(connector, params) {
-    cache.delete(tokenCacheKey(connector, params));
+    cache.delete(tokenCacheKey(connector, withDefaultScopes(params)));
 }
 const DEFAULT_VALIDITY_BUFFER_MS = 30_000;
 const MAX_CACHE_SIZE = 100;

package/package.json

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