integrate-sdk 0.5.7 → 0.5.9

package/README.md

@@ -26,44 +26,60 @@ npm install integrate-sdk
 bun add integrate-sdk
 ```
 
-## Quick Start
+## Quick Start (2 Files Only!)
 
-### Server-Side Setup
+### 1. Create Server Config
 
-First, create your server configuration with OAuth secrets:
+Define your OAuth providers once:
 
 ```typescript
 // lib/integrate-server.ts (server-side only!)
-import { createMCPServer, githubPlugin, gmailPlugin } from 'integrate-sdk/server';
+import {
+  createMCPServer,
+  githubPlugin,
+  gmailPlugin,
+} from "integrate-sdk/server";
 
-export const { client: serverClient, handlers } = createMCPServer({
+export const { client: serverClient } = createMCPServer({
   plugins: [
     githubPlugin({
       clientId: process.env.GITHUB_CLIENT_ID,
       clientSecret: process.env.GITHUB_CLIENT_SECRET,
-      scopes: ['repo', 'user'],
+      scopes: ["repo", "user"],
     }),
     gmailPlugin({
       clientId: process.env.GMAIL_CLIENT_ID,
       clientSecret: process.env.GMAIL_CLIENT_SECRET,
-      scopes: ['gmail.readonly'],
+      scopes: ["gmail.readonly"],
     }),
   ],
 });
 ```
 
-Create OAuth route (handles authorization automatically):
+### 2. Create Single Catch-All Route
+
+That's it! Just import and export:
 
 ```typescript
-// app/api/integrate/oauth/[action]/route.ts
-export * from 'integrate-sdk/oauth';
+// app/api/integrate/[...all]/route.ts
+import { serverClient } from "@/lib/integrate-server";
+import { toNextJsHandler } from "integrate-sdk/server";
+
+export const { POST, GET } = toNextJsHandler({
+  client: serverClient,  // Pass the client
+  redirectUrl: "/dashboard",
+});
 ```
 
+This imports your config from step 1 and handles ALL OAuth operations (authorize, callback, status, disconnect) in one file!
+
+### 3. Use in Your App
+
 Use the server client in API routes or server components:
 
 ```typescript
 // app/api/repos/route.ts
-import { serverClient } from '@/lib/integrate-server';
+import { serverClient } from "@/lib/integrate-server";
 
 export async function GET() {
   // Automatically connects on first call - no manual setup needed!
@@ -77,34 +93,35 @@ export async function GET() {
 Use in your client components (no secrets needed):
 
 ```typescript
-'use client';
-import { createMCPClient, githubPlugin } from 'integrate-sdk';
+"use client";
+import { createMCPClient, githubPlugin } from "integrate-sdk";
 
 const client = createMCPClient({
   plugins: [
     githubPlugin({
-      scopes: ['repo', 'user'],
+      scopes: ["repo", "user"],
       // No clientId or clientSecret needed!
     }),
   ],
-  oauthFlow: { mode: 'popup' },
+  oauthFlow: { mode: "popup" },
 });
 
 // Authorize user (opens popup)
-await client.authorize('github');
+await client.authorize("github");
 
 // Use the client - automatically connects!
 const result = await client.github.createIssue({
-  owner: 'owner',
-  repo: 'repo',
-  title: 'Bug report',
-  body: 'Description of the bug',
+  owner: "owner",
+  repo: "repo",
+  title: "Bug report",
+  body: "Description of the bug",
 });
 
-console.log('Issue created:', result);
+console.log("Issue created:", result);
 ```
 
 **That's it!** The SDK automatically:
+
 - ✅ Connects on first method call (no manual `connect()` needed)
 - ✅ Cleans up on exit (no manual `disconnect()` needed)
 - ✅ Manages OAuth tokens securely through your API routes
@@ -115,6 +132,7 @@ console.log('Issue created:', result);
 The SDK automatically manages connections for you - no manual `connect()` or `disconnect()` calls needed!
 
 **Features:**
+
 - **Lazy Connection**: Automatically connects on first method call
 - **Auto-Cleanup**: Cleans up on process exit
 - **Singleton Pattern**: Reuses connections efficiently (configurable)
@@ -124,25 +142,25 @@ The SDK automatically manages connections for you - no manual `connect()` or `di
 const client = createMCPClient({
   plugins: [
     githubPlugin({
-      scopes: ['repo', 'user'],
+      scopes: ["repo", "user"],
     }),
   ],
 });
 
 // Use immediately - no connect() needed!
-await client.authorize('github');
-await client.github.listRepos({ username: 'octocat' });
+await client.authorize("github");
+await client.github.listRepos({ username: "octocat" });
 
 // ✅ Want manual control? Use manual mode
 const manualClient = createMCPClient({
-  plugins: [githubPlugin({ scopes: ['repo'] })],
-  connectionMode: 'manual',
+  plugins: [githubPlugin({ scopes: ["repo"] })],
+  connectionMode: "manual",
   singleton: false,
 });
 
 await manualClient.connect();
-await manualClient.authorize('github');
-await manualClient.github.listRepos({ username: 'octocat' });
+await manualClient.authorize("github");
+await manualClient.github.listRepos({ username: "octocat" });
 await manualClient.disconnect();
 ```
 
@@ -165,7 +183,11 @@ Instead of generic tool calls, use typed methods with full autocomplete:
 
 ```typescript
 // ✅ New: Typed methods with autocomplete
-await client.github.createIssue({ owner: "user", repo: "project", title: "Bug" });
+await client.github.createIssue({
+  owner: "user",
+  repo: "project",
+  title: "Bug",
+});
 await client.gmail.sendEmail({ to: "user@example.com", subject: "Hello" });
 ```
 
@@ -180,14 +202,21 @@ await client.gmail.sendEmail({ to: "user@example.com", subject: "Hello" });
 
 ```typescript
 // 1. Typed plugin methods (recommended for built-in plugins like GitHub/Gmail)
-await client.github.createIssue({ owner: "user", repo: "project", title: "Bug" });
+await client.github.createIssue({
+  owner: "user",
+  repo: "project",
+  title: "Bug",
+});
 await client.gmail.sendEmail({ to: "user@example.com", subject: "Hello" });
 
 // 2. Typed server methods (for server-level tools)
 await client.server.listToolsByIntegration({ integration: "github" });
 
 // 3. Direct tool calls (for other server-supported integrations)
-await client._callToolByName("slack_send_message", { channel: "#general", text: "Hello" });
+await client._callToolByName("slack_send_message", {
+  channel: "#general",
+  text: "Hello",
+});
 ```
 
 ## OAuth Authorization
@@ -195,16 +224,18 @@ await client._callToolByName("slack_send_message", { channel: "#general", text:
 The SDK implements OAuth 2.0 Authorization Code Flow with PKCE for secure authorization.
 
 **Key Features:**
+
 - ✅ Popup or redirect flow modes
 - ✅ Session token management
 - ✅ Multiple provider support
 - ✅ PKCE security
 
 **Basic Usage:**
+
 ```typescript
 // Check authorization
-if (!await client.isAuthorized('github')) {
-  await client.authorize('github'); // Opens popup or redirects
+if (!(await client.isAuthorized("github"))) {
+  await client.authorize("github"); // Opens popup or redirects
 }
 
 // Use authorized client
@@ -212,6 +243,7 @@ const repos = await client.github.listOwnRepos({});
 ```
 
 For complete OAuth setup including:
+
 - Popup vs redirect flows
 - Session token management
 - Multiple providers
@@ -227,9 +259,13 @@ Access GitHub repositories, issues, pull requests, and more with type-safe metho
 
 ```typescript
 // Available methods
-await client.github.getRepo({ owner: 'facebook', repo: 'react' });
-await client.github.createIssue({ owner: 'user', repo: 'repo', title: 'Bug' });
-await client.github.listPullRequests({ owner: 'user', repo: 'repo', state: 'open' });
+await client.github.getRepo({ owner: "facebook", repo: "react" });
+await client.github.createIssue({ owner: "user", repo: "repo", title: "Bug" });
+await client.github.listPullRequests({
+  owner: "user",
+  repo: "repo",
+  state: "open",
+});
 await client.github.listOwnRepos({});
 ```
 
@@ -241,9 +277,13 @@ Send emails, manage labels, and search messages with type-safe methods.
 
 ```typescript
 // Available methods
-await client.gmail.sendEmail({ to: 'user@example.com', subject: 'Hello', body: 'Hi!' });
-await client.gmail.listEmails({ maxResults: 10, q: 'is:unread' });
-await client.gmail.searchEmails({ query: 'from:notifications@github.com' });
+await client.gmail.sendEmail({
+  to: "user@example.com",
+  subject: "Hello",
+  body: "Hi!",
+});
+await client.gmail.listEmails({ maxResults: 10, q: "is:unread" });
+await client.gmail.searchEmails({ query: "from:notifications@github.com" });
 ```
 
 [→ Gmail plugin documentation](https://integrate.dev/docs/plugins/gmail)
@@ -253,15 +293,15 @@ await client.gmail.searchEmails({ query: 'from:notifications@github.com' });
 Use `genericOAuthPlugin` to configure any server-supported integration:
 
 ```typescript
-import { genericOAuthPlugin } from 'integrate-sdk/server';
+import { genericOAuthPlugin } from "integrate-sdk/server";
 
 const slackPlugin = genericOAuthPlugin({
-  id: 'slack',
-  provider: 'slack',
+  id: "slack",
+  provider: "slack",
   clientId: process.env.SLACK_CLIENT_ID,
   clientSecret: process.env.SLACK_CLIENT_SECRET,
-  scopes: ['chat:write', 'channels:read'],
-  tools: ['slack_send_message', 'slack_list_channels'],
+  scopes: ["chat:write", "channels:read"],
+  tools: ["slack_send_message", "slack_list_channels"],
 });
 ```
 

package/dist/index.js

@@ -148,6 +148,102 @@ var init_errors = __esm(() => {
   };
 });
 
+// src/oauth/pkce.ts
+var exports_pkce = {};
+__export(exports_pkce, {
+  parseState: () => parseState,
+  generateStateWithReturnUrl: () => generateStateWithReturnUrl,
+  generateState: () => generateState,
+  generateCodeVerifier: () => generateCodeVerifier,
+  generateCodeChallenge: () => generateCodeChallenge
+});
+function generateCodeVerifier() {
+  const array = new Uint8Array(32);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(array);
+  } else {
+    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(array);
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(verifier);
+  let hashBuffer;
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
+    hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", data);
+  } else {
+    throw new Error("crypto.subtle.digest is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(new Uint8Array(hashBuffer));
+}
+function generateState() {
+  const array = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(array);
+  } else {
+    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(array);
+}
+function generateStateWithReturnUrl(returnUrl) {
+  const csrf = generateState();
+  const stateData = returnUrl ? { csrf, returnUrl } : { csrf };
+  const encoder = new TextEncoder;
+  const jsonBytes = encoder.encode(JSON.stringify(stateData));
+  return base64UrlEncode(jsonBytes);
+}
+function parseState(state) {
+  try {
+    const decoded = base64UrlDecode(state);
+    const parsed = JSON.parse(decoded);
+    if (typeof parsed === "string") {
+      return { csrf: parsed };
+    } else if (parsed && typeof parsed === "object") {
+      return {
+        csrf: parsed.csrf || state,
+        returnUrl: parsed.returnUrl
+      };
+    }
+    return { csrf: state };
+  } catch {
+    return { csrf: state };
+  }
+}
+function base64UrlEncode(array) {
+  let base64 = "";
+  if (typeof Buffer !== "undefined") {
+    base64 = Buffer.from(array).toString("base64");
+  } else {
+    const binary = String.fromCharCode(...array);
+    base64 = btoa(binary);
+  }
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlDecode(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4 !== 0) {
+    base64 += "=";
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(base64, "base64").toString("utf-8");
+  } else {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0;i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    const decoder = new TextDecoder;
+    return decoder.decode(bytes);
+  }
+}
+
 // src/protocol/jsonrpc.ts
 function parseMessage(message) {
   try {
@@ -369,95 +465,6 @@ function methodToToolName(methodName, pluginId) {
   const snakeCaseMethod = camelToSnake(methodName);
   return `${pluginId}_${snakeCaseMethod}`;
 }
-
-// src/oauth/pkce.ts
-function generateCodeVerifier() {
-  const array = new Uint8Array(32);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(array);
-  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
-    globalThis.crypto.getRandomValues(array);
-  } else {
-    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
-  }
-  return base64UrlEncode(array);
-}
-async function generateCodeChallenge(verifier) {
-  const encoder = new TextEncoder;
-  const data = encoder.encode(verifier);
-  let hashBuffer;
-  if (typeof crypto !== "undefined" && crypto.subtle) {
-    hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  } else if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
-    hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", data);
-  } else {
-    throw new Error("crypto.subtle.digest is not available. Please use Node.js 19+ or a modern browser.");
-  }
-  return base64UrlEncode(new Uint8Array(hashBuffer));
-}
-function generateState() {
-  const array = new Uint8Array(16);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(array);
-  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
-    globalThis.crypto.getRandomValues(array);
-  } else {
-    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
-  }
-  return base64UrlEncode(array);
-}
-function generateStateWithReturnUrl(returnUrl) {
-  const csrf = generateState();
-  const stateData = returnUrl ? { csrf, returnUrl } : { csrf };
-  const encoder = new TextEncoder;
-  const jsonBytes = encoder.encode(JSON.stringify(stateData));
-  return base64UrlEncode(jsonBytes);
-}
-function parseState(state) {
-  try {
-    const decoded = base64UrlDecode(state);
-    const parsed = JSON.parse(decoded);
-    if (typeof parsed === "string") {
-      return { csrf: parsed };
-    } else if (parsed && typeof parsed === "object") {
-      return {
-        csrf: parsed.csrf || state,
-        returnUrl: parsed.returnUrl
-      };
-    }
-    return { csrf: state };
-  } catch {
-    return { csrf: state };
-  }
-}
-function base64UrlEncode(array) {
-  let base64 = "";
-  if (typeof Buffer !== "undefined") {
-    base64 = Buffer.from(array).toString("base64");
-  } else {
-    const binary = String.fromCharCode(...array);
-    base64 = btoa(binary);
-  }
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-}
-function base64UrlDecode(str) {
-  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
-  while (base64.length % 4 !== 0) {
-    base64 += "=";
-  }
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(base64, "base64").toString("utf-8");
-  } else {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0;i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    const decoder = new TextDecoder;
-    return decoder.decode(bytes);
-  }
-}
-
 // src/oauth/window-manager.ts
 function isBrowser() {
   return typeof window !== "undefined" && typeof window.document !== "undefined";
@@ -1747,6 +1754,80 @@ function createNextOAuthHandler(config) {
           return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
         }
       };
+    },
+    toNextJsHandler(redirectConfig) {
+      const defaultRedirectUrl = redirectConfig?.redirectUrl || "/";
+      const errorRedirectUrl = redirectConfig?.errorRedirectUrl || "/auth-error";
+      return {
+        async POST(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const segments = params.all || [];
+          if (segments.length === 2 && segments[0] === "oauth") {
+            const action = segments[1];
+            if (action === "authorize") {
+              return handlers.authorize(req);
+            }
+            if (action === "callback") {
+              return handlers.callback(req);
+            }
+            if (action === "disconnect") {
+              return handlers.disconnect(req);
+            }
+            return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+          }
+          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+        },
+        async GET(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const segments = params.all || [];
+          if (segments.length === 2 && segments[0] === "oauth") {
+            const action = segments[1];
+            if (action === "status") {
+              return handlers.status(req);
+            }
+            if (action === "callback") {
+              const { searchParams } = new URL(req.url);
+              const code = searchParams.get("code");
+              const state = searchParams.get("state");
+              const error = searchParams.get("error");
+              const errorDescription = searchParams.get("error_description");
+              if (error) {
+                const errorMsg = errorDescription || error;
+                console.error("[OAuth Redirect] Error:", errorMsg);
+                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, req.url));
+              }
+              if (!code || !state) {
+                console.error("[OAuth Redirect] Missing code or state parameter");
+                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, req.url));
+              }
+              let returnUrl = defaultRedirectUrl;
+              try {
+                const { parseState: parseState2 } = await Promise.resolve().then(() => exports_pkce);
+                const stateData = parseState2(state);
+                if (stateData.returnUrl) {
+                  returnUrl = stateData.returnUrl;
+                }
+              } catch (e) {
+                try {
+                  const referrer = req.headers?.get?.("referer") || req.headers?.get?.("referrer");
+                  if (referrer) {
+                    const referrerUrl = new URL(referrer);
+                    const currentUrl = new URL(req.url);
+                    if (referrerUrl.origin === currentUrl.origin) {
+                      returnUrl = referrerUrl.pathname + referrerUrl.search;
+                    }
+                  }
+                } catch {}
+              }
+              const targetUrl = new URL(returnUrl, req.url);
+              targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+              return Response.redirect(targetUrl);
+            }
+            return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+          }
+          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+        }
+      };
     }
   };
   return handlers;

package/dist/server.js

@@ -148,6 +148,102 @@ var init_errors = __esm(() => {
   };
 });
 
+// src/oauth/pkce.ts
+var exports_pkce = {};
+__export(exports_pkce, {
+  parseState: () => parseState,
+  generateStateWithReturnUrl: () => generateStateWithReturnUrl,
+  generateState: () => generateState,
+  generateCodeVerifier: () => generateCodeVerifier,
+  generateCodeChallenge: () => generateCodeChallenge
+});
+function generateCodeVerifier() {
+  const array = new Uint8Array(32);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(array);
+  } else {
+    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(array);
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(verifier);
+  let hashBuffer;
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
+    hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", data);
+  } else {
+    throw new Error("crypto.subtle.digest is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(new Uint8Array(hashBuffer));
+}
+function generateState() {
+  const array = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    globalThis.crypto.getRandomValues(array);
+  } else {
+    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
+  }
+  return base64UrlEncode(array);
+}
+function generateStateWithReturnUrl(returnUrl) {
+  const csrf = generateState();
+  const stateData = returnUrl ? { csrf, returnUrl } : { csrf };
+  const encoder = new TextEncoder;
+  const jsonBytes = encoder.encode(JSON.stringify(stateData));
+  return base64UrlEncode(jsonBytes);
+}
+function parseState(state) {
+  try {
+    const decoded = base64UrlDecode(state);
+    const parsed = JSON.parse(decoded);
+    if (typeof parsed === "string") {
+      return { csrf: parsed };
+    } else if (parsed && typeof parsed === "object") {
+      return {
+        csrf: parsed.csrf || state,
+        returnUrl: parsed.returnUrl
+      };
+    }
+    return { csrf: state };
+  } catch {
+    return { csrf: state };
+  }
+}
+function base64UrlEncode(array) {
+  let base64 = "";
+  if (typeof Buffer !== "undefined") {
+    base64 = Buffer.from(array).toString("base64");
+  } else {
+    const binary = String.fromCharCode(...array);
+    base64 = btoa(binary);
+  }
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlDecode(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4 !== 0) {
+    base64 += "=";
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(base64, "base64").toString("utf-8");
+  } else {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0;i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    const decoder = new TextDecoder;
+    return decoder.decode(bytes);
+  }
+}
+
 // src/protocol/jsonrpc.ts
 function parseMessage(message) {
   try {
@@ -369,95 +465,6 @@ function methodToToolName(methodName, pluginId) {
   const snakeCaseMethod = camelToSnake(methodName);
   return `${pluginId}_${snakeCaseMethod}`;
 }
-
-// src/oauth/pkce.ts
-function generateCodeVerifier() {
-  const array = new Uint8Array(32);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(array);
-  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
-    globalThis.crypto.getRandomValues(array);
-  } else {
-    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
-  }
-  return base64UrlEncode(array);
-}
-async function generateCodeChallenge(verifier) {
-  const encoder = new TextEncoder;
-  const data = encoder.encode(verifier);
-  let hashBuffer;
-  if (typeof crypto !== "undefined" && crypto.subtle) {
-    hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  } else if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
-    hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", data);
-  } else {
-    throw new Error("crypto.subtle.digest is not available. Please use Node.js 19+ or a modern browser.");
-  }
-  return base64UrlEncode(new Uint8Array(hashBuffer));
-}
-function generateState() {
-  const array = new Uint8Array(16);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(array);
-  } else if (typeof globalThis !== "undefined" && globalThis.crypto) {
-    globalThis.crypto.getRandomValues(array);
-  } else {
-    throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
-  }
-  return base64UrlEncode(array);
-}
-function generateStateWithReturnUrl(returnUrl) {
-  const csrf = generateState();
-  const stateData = returnUrl ? { csrf, returnUrl } : { csrf };
-  const encoder = new TextEncoder;
-  const jsonBytes = encoder.encode(JSON.stringify(stateData));
-  return base64UrlEncode(jsonBytes);
-}
-function parseState(state) {
-  try {
-    const decoded = base64UrlDecode(state);
-    const parsed = JSON.parse(decoded);
-    if (typeof parsed === "string") {
-      return { csrf: parsed };
-    } else if (parsed && typeof parsed === "object") {
-      return {
-        csrf: parsed.csrf || state,
-        returnUrl: parsed.returnUrl
-      };
-    }
-    return { csrf: state };
-  } catch {
-    return { csrf: state };
-  }
-}
-function base64UrlEncode(array) {
-  let base64 = "";
-  if (typeof Buffer !== "undefined") {
-    base64 = Buffer.from(array).toString("base64");
-  } else {
-    const binary = String.fromCharCode(...array);
-    base64 = btoa(binary);
-  }
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-}
-function base64UrlDecode(str) {
-  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
-  while (base64.length % 4 !== 0) {
-    base64 += "=";
-  }
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(base64, "base64").toString("utf-8");
-  } else {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0;i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    const decoder = new TextDecoder;
-    return decoder.decode(bytes);
-  }
-}
-
 // src/oauth/window-manager.ts
 function isBrowser() {
   return typeof window !== "undefined" && typeof window.document !== "undefined";
@@ -1749,6 +1756,80 @@ function createNextOAuthHandler(config) {
           return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
         }
       };
+    },
+    toNextJsHandler(redirectConfig) {
+      const defaultRedirectUrl = redirectConfig?.redirectUrl || "/";
+      const errorRedirectUrl = redirectConfig?.errorRedirectUrl || "/auth-error";
+      return {
+        async POST(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const segments = params.all || [];
+          if (segments.length === 2 && segments[0] === "oauth") {
+            const action = segments[1];
+            if (action === "authorize") {
+              return handlers.authorize(req);
+            }
+            if (action === "callback") {
+              return handlers.callback(req);
+            }
+            if (action === "disconnect") {
+              return handlers.disconnect(req);
+            }
+            return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+          }
+          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+        },
+        async GET(req, context) {
+          const params = context.params instanceof Promise ? await context.params : context.params;
+          const segments = params.all || [];
+          if (segments.length === 2 && segments[0] === "oauth") {
+            const action = segments[1];
+            if (action === "status") {
+              return handlers.status(req);
+            }
+            if (action === "callback") {
+              const { searchParams } = new URL(req.url);
+              const code = searchParams.get("code");
+              const state = searchParams.get("state");
+              const error = searchParams.get("error");
+              const errorDescription = searchParams.get("error_description");
+              if (error) {
+                const errorMsg = errorDescription || error;
+                console.error("[OAuth Redirect] Error:", errorMsg);
+                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, req.url));
+              }
+              if (!code || !state) {
+                console.error("[OAuth Redirect] Missing code or state parameter");
+                return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, req.url));
+              }
+              let returnUrl = defaultRedirectUrl;
+              try {
+                const { parseState: parseState2 } = await Promise.resolve().then(() => exports_pkce);
+                const stateData = parseState2(state);
+                if (stateData.returnUrl) {
+                  returnUrl = stateData.returnUrl;
+                }
+              } catch (e) {
+                try {
+                  const referrer = req.headers?.get?.("referer") || req.headers?.get?.("referrer");
+                  if (referrer) {
+                    const referrerUrl = new URL(referrer);
+                    const currentUrl = new URL(req.url);
+                    if (referrerUrl.origin === currentUrl.origin) {
+                      returnUrl = referrerUrl.pathname + referrerUrl.search;
+                    }
+                  }
+                } catch {}
+              }
+              const targetUrl = new URL(returnUrl, req.url);
+              targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+              return Response.redirect(targetUrl);
+            }
+            return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
+          }
+          return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+        }
+      };
     }
   };
   return handlers;
@@ -1911,6 +1992,7 @@ function createMCPServer(config) {
     singleton: config.singleton ?? true
   };
   const client = new MCPClient(clientConfig);
+  client.__oauthConfig = { providers };
   const { POST, GET } = createOAuthRouteHandlers({ providers });
   return {
     client,
@@ -1938,7 +2020,35 @@ var GET = async (req, context) => {
   const routes = handler.createRoutes();
   return routes.GET(req, context);
 };
+function toNextJsHandler(options) {
+  const POST2 = async (req, context) => {
+    const config = options.config || options.client?.__oauthConfig;
+    if (!config) {
+      return Response.json({ error: 'OAuth not configured. You must pass either "client" (from createMCPServer) or "config" to toNextJsHandler().' }, { status: 500 });
+    }
+    const handler = createNextOAuthHandler(config);
+    const routes = handler.toNextJsHandler({
+      redirectUrl: options.redirectUrl,
+      errorRedirectUrl: options.errorRedirectUrl
+    });
+    return routes.POST(req, context);
+  };
+  const GET2 = async (req, context) => {
+    const config = options.config || options.client?.__oauthConfig;
+    if (!config) {
+      return Response.json({ error: 'OAuth not configured. You must pass either "client" (from createMCPServer) or "config" to toNextJsHandler().' }, { status: 500 });
+    }
+    const handler = createNextOAuthHandler(config);
+    const routes = handler.toNextJsHandler({
+      redirectUrl: options.redirectUrl,
+      errorRedirectUrl: options.errorRedirectUrl
+    });
+    return routes.GET(req, context);
+  };
+  return { POST: POST2, GET: GET2 };
+}
 export {
+  toNextJsHandler,
   gmailPlugin,
   githubPlugin,
   genericOAuthPlugin,

package/dist/src/adapters/nextjs.d.ts

@@ -265,6 +265,68 @@ export declare function createNextOAuthHandler(config: OAuthHandlerConfig): {
             }>;
         }): Promise<NextResponse>;
     };
+    /**
+     * Create unified catch-all route handler
+     *
+     * This is the simplest way to set up OAuth routes - create a single catch-all
+     * route file that handles ALL OAuth actions including provider redirects.
+     *
+     * @param redirectConfig - Configuration for OAuth redirect behavior
+     * @returns Object with POST and GET handlers for Next.js catch-all routes
+     *
+     * @example
+     * ```typescript
+     * // app/api/integrate/[...all]/route.ts
+     * import { createNextOAuthHandler } from 'integrate-sdk';
+     *
+     * const handler = createNextOAuthHandler({
+     *   providers: {
+     *     github: {
+     *       clientId: process.env.GITHUB_CLIENT_ID!,
+     *       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+     *     },
+     *   },
+     * });
+     *
+     * export const { POST, GET } = handler.toNextJsHandler({
+     *   redirectUrl: '/',
+     * });
+     * ```
+     *
+     * This single route file handles:
+     * - POST /api/integrate/oauth/authorize - Get authorization URL
+     * - POST /api/integrate/oauth/callback - Exchange code for token
+     * - GET /api/integrate/oauth/callback - Provider OAuth redirect
+     * - GET /api/integrate/oauth/status - Check authorization status
+     * - POST /api/integrate/oauth/disconnect - Disconnect provider
+     */
+    toNextJsHandler(redirectConfig?: {
+        /** URL to redirect to after OAuth callback (default: '/') */
+        redirectUrl?: string;
+        /** URL to redirect to on OAuth error (default: '/auth-error') */
+        errorRedirectUrl?: string;
+    }): {
+        /**
+         * POST handler for authorize, callback, and disconnect actions
+         */
+        POST(req: NextRequest, context: {
+            params: {
+                all: string[];
+            } | Promise<{
+                all: string[];
+            }>;
+        }): Promise<NextResponse>;
+        /**
+         * GET handler for status action and OAuth provider redirects
+         */
+        GET(req: NextRequest, context: {
+            params: {
+                all: string[];
+            } | Promise<{
+                all: string[];
+            }>;
+        }): Promise<NextResponse>;
+    };
 };
 export {};
 //# sourceMappingURL=nextjs.d.ts.map

package/dist/src/adapters/nextjs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../../src/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG1E,KAAK,WAAW,GAAG,GAAG,CAAC;AACvB,KAAK,YAAY,GAAG,GAAG,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB;IAI7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;mBACkB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAcxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;kBACiB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAcvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;gBACe,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IA+BrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;oBACmB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAiCzD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;QAGC;;WAEG;kBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,GACpE,OAAO,CAAC,YAAY,CAAC;QAuBxB;;WAEG;iBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,GACpE,OAAO,CAAC,YAAY,CAAC;;EAmB/B"}
+{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../../src/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG1E,KAAK,WAAW,GAAG,GAAG,CAAC;AACvB,KAAK,YAAY,GAAG,GAAG,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB;IAI7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;mBACkB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAcxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;kBACiB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAcvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;gBACe,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IA+BrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;oBACmB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAiCzD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;QAGC;;WAEG;kBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,GACpE,OAAO,CAAC,YAAY,CAAC;QAuBxB;;WAEG;iBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,GACpE,OAAO,CAAC,YAAY,CAAC;;IAiB5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;qCAC8B;QAC/B,6DAA6D;QAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,iEAAiE;QACjE,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B;QAKG;;WAEG;kBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,CAAC,CAAA;SAAE,GAClE,OAAO,CAAC,YAAY,CAAC;QAiCxB;;WAEG;iBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,CAAC,CAAA;SAAE,GAClE,OAAO,CAAC,YAAY,CAAC;;EA+F/B"}

package/dist/src/server.d.ts

@@ -121,4 +121,84 @@ export declare const GET: (req: any, context: {
         action: string;
     }>;
 }) => Promise<any>;
+/**
+ * Create catch-all route handlers from the global server configuration
+ *
+ * This is a helper function to create POST and GET handlers for catch-all routes
+ * that use the configuration from createMCPServer().
+ *
+ * @param redirectConfig - Optional configuration for OAuth redirect behavior
+ * @returns Object with POST and GET handlers for Next.js catch-all routes
+ *
+ * @example
+ * ```typescript
+ * // lib/integrate-server.ts
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ *
+ * export const { client: serverClient } = createMCPServer({
+ *   plugins: [
+ *     githubPlugin({
+ *       clientId: process.env.GITHUB_CLIENT_ID!,
+ *       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+ *       scopes: ['repo', 'user'],
+ *     }),
+ *   ],
+ * });
+ *
+ * // app/api/integrate/[...all]/route.ts
+ *
+ * // RECOMMENDED: Import serverClient from your server setup file
+ * import { serverClient } from '@/lib/integrate-server';
+ * import { toNextJsHandler } from 'integrate-sdk/server';
+ *
+ * export const { POST, GET } = toNextJsHandler({
+ *   client: serverClient,  // Pass the client from createMCPServer
+ *   redirectUrl: '/dashboard',
+ * });
+ *
+ * // Alternative: Provide config inline
+ * export const { POST, GET } = toNextJsHandler({
+ *   config: {
+ *     providers: {
+ *       github: {
+ *         clientId: process.env.GITHUB_CLIENT_ID!,
+ *         clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+ *       },
+ *     },
+ *   },
+ *   redirectUrl: '/dashboard',
+ * });
+ * ```
+ */
+export declare function toNextJsHandler(options: {
+    /** Server client instance from createMCPServer (extracts config automatically) */
+    client?: any;
+    /** Custom OAuth handler config (provide inline) */
+    config?: {
+        providers: Record<string, {
+            clientId: string;
+            clientSecret: string;
+            redirectUri?: string;
+        }>;
+    };
+    /** URL to redirect to after successful OAuth */
+    redirectUrl?: string;
+    /** URL to redirect to on OAuth error */
+    errorRedirectUrl?: string;
+}): {
+    POST: (req: any, context: {
+        params: {
+            all: string[];
+        } | Promise<{
+            all: string[];
+        }>;
+    }) => Promise<any>;
+    GET: (req: any, context: {
+        params: {
+            all: string[];
+        } | Promise<{
+            all: string[];
+        }>;
+    }) => Promise<any>;
+};
 //# sourceMappingURL=server.d.ts.map

package/dist/src/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAyCpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,EACnE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;IAmE/B,2DAA2D;;IAG3D,4DAA4D;;;;;;;;IAG5D,2DAA2D;;;;;;;;EAG9D;AAYD,YAAY,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE9E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,GAAG,EACR,SAAS;IAAE,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,iBAYtE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GACd,KAAK,GAAG,EACR,SAAS;IAAE,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,iBAYtE,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAyCpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,SAAS,SAAS,EAAE,EACnE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;IAsE/B,2DAA2D;;IAG3D,4DAA4D;;;;;;;;IAG5D,2DAA2D;;;;;;;;EAG9D;AAYD,YAAY,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE9E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,GAAG,EACR,SAAS;IAAE,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,iBAYtE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GACd,KAAK,GAAG,EACR,SAAS;IAAE,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,iBAYtE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,kFAAkF;IAClF,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,mDAAmD;IACnD,MAAM,CAAC,EAAE;QACP,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE;YACxB,QAAQ,EAAE,MAAM,CAAC;YACjB,YAAY,EAAE,MAAM,CAAC;YACrB,WAAW,CAAC,EAAE,MAAM,CAAC;SACtB,CAAC,CAAC;KACJ,CAAC;IACF,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;gBAMQ,GAAG,WACC;QAAE,MAAM,EAAE;YAAE,GAAG,EAAE,MAAM,EAAE,CAAA;SAAE,GAAG,OAAO,CAAC;YAAE,GAAG,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAA;KAAE;eAwB9D,GAAG,WACC;QAAE,MAAM,EAAE;YAAE,GAAG,EAAE,MAAM,EAAE,CAAA;SAAE,GAAG,OAAO,CAAC;YAAE,GAAG,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAA;KAAE;EAoBtE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "integrate-sdk",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Type-safe TypeScript SDK for MCP Client with plugin-based OAuth provider configuration",
   "type": "module",
   "main": "./dist/index.js",