integrate-sdk 0.6.8 → 0.6.9

package/dist/adapters/tanstack-start.js

@@ -8,6 +8,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/adapters/tanstack-start.ts
 function toTanStackStartHandler(handler) {

package/dist/index.js

@@ -2025,64 +2025,10 @@ function toNodeHandler(config) {
     }
   };
 }
-// src/adapters/solid-start.ts
-function toSolidStartHandler(baseHandler) {
-  const handler = async (event) => {
-    return baseHandler(event.request);
-  };
-  return {
-    GET: handler,
-    POST: handler,
-    PATCH: handler,
-    PUT: handler,
-    DELETE: handler
-  };
-}
-// src/adapters/svelte-kit.ts
-async function svelteKitHandler({
-  authConfig,
-  event,
-  resolve,
-  basePath = "/api/integrate"
-}) {
-  const { url } = event;
-  const baseUrl = new URL(basePath, url.origin);
-  if (!url.pathname.startsWith(baseUrl.pathname)) {
-    return resolve(event);
-  }
-  return authConfig(event.request);
-}
-function toSvelteKitHandler(baseHandler) {
-  return async (event) => {
-    return baseHandler(event.request);
-  };
-}
-// src/adapters/tanstack-start.ts
-function toTanStackStartHandler(handler) {
-  const baseHandler = async ({ request }) => {
-    return handler(request);
-  };
-  return {
-    GET: baseHandler,
-    POST: baseHandler
-  };
-}
-var createTanStackOAuthHandler = toTanStackStartHandler;
-
-// src/index.ts
-init_errors();
-
 // src/utils/env.ts
 function getEnv(key) {
   try {
-    const getMetaEnv = () => {
-      try {
-        return typeof import.meta !== "undefined" ? import.meta.env : undefined;
-      } catch {
-        return;
-      }
-    };
-    const metaEnv = getMetaEnv();
+    const metaEnv = import.meta.env;
     if (metaEnv && typeof metaEnv === "object" && metaEnv !== null) {
       const value = metaEnv[key];
       if (value !== undefined && value !== null && value !== "") {
@@ -2206,6 +2152,319 @@ function createSimplePlugin(config) {
     onDisconnect: config.onDisconnect
   };
 }
+
+// src/server.ts
+var globalServerConfig = null;
+function getDefaultRedirectUri() {
+  if (typeof window !== "undefined") {
+    return `${window.location.origin}/api/integrate/oauth/callback`;
+  }
+  const integrateUrl = getEnv("INTEGRATE_URL");
+  if (integrateUrl) {
+    return `${integrateUrl}/api/integrate/oauth/callback`;
+  }
+  const vercelUrl = getEnv("VERCEL_URL");
+  if (vercelUrl) {
+    return `https://${vercelUrl}/api/integrate/oauth/callback`;
+  }
+  return "http://localhost:3000/api/integrate/oauth/callback";
+}
+function createMCPServer(config) {
+  if (typeof window !== "undefined") {
+    throw new Error("createMCPServer() should only be called on the server-side. " + "Use createMCPClient() for client-side code.");
+  }
+  const providers = {};
+  const updatedPlugins = config.plugins.map((plugin) => {
+    if (plugin.oauth) {
+      const { clientId, clientSecret, redirectUri: pluginRedirectUri } = plugin.oauth;
+      if (!clientId || !clientSecret) {
+        console.warn(`Warning: Plugin "${plugin.id}" is missing OAuth credentials. ` + `Provide clientId and clientSecret in the plugin configuration.`);
+        return plugin;
+      }
+      const redirectUri = pluginRedirectUri || config.redirectUri || getDefaultRedirectUri();
+      providers[plugin.id] = {
+        clientId,
+        clientSecret,
+        redirectUri
+      };
+      return {
+        ...plugin,
+        oauth: {
+          ...plugin.oauth,
+          redirectUri
+        }
+      };
+    }
+    return plugin;
+  });
+  globalServerConfig = {
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey
+  };
+  const clientConfig = {
+    ...config,
+    plugins: updatedPlugins,
+    connectionMode: config.connectionMode || "lazy",
+    singleton: config.singleton ?? true
+  };
+  const client = new MCPClient(clientConfig);
+  if (config.apiKey) {
+    client.setRequestHeader("X-API-KEY", config.apiKey);
+  }
+  client.__oauthConfig = {
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey
+  };
+  const { POST, GET } = createOAuthRouteHandlers({
+    providers,
+    serverUrl: config.serverUrl,
+    apiKey: config.apiKey
+  });
+  const handler = async (request, context) => {
+    const method = request.method.toUpperCase();
+    let action;
+    let segments = [];
+    if (context?.params?.action) {
+      action = context.params.action;
+    } else if (context?.params?.all) {
+      const all = context.params.all;
+      if (Array.isArray(all)) {
+        segments = all;
+      } else if (typeof all === "string") {
+        segments = all.split("/").filter(Boolean);
+      }
+      if (segments.length === 2 && segments[0] === "oauth") {
+        action = segments[1];
+      } else if (segments.length === 1) {
+        action = segments[0];
+      } else if (segments.length > 0) {
+        action = segments[segments.length - 1];
+      }
+    } else {
+      const url = new URL(request.url);
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      segments = pathParts;
+      const oauthIndex = pathParts.indexOf("oauth");
+      if (oauthIndex >= 0 && oauthIndex < pathParts.length - 1) {
+        action = pathParts[oauthIndex + 1];
+      } else if (pathParts.length > 0) {
+        action = pathParts[pathParts.length - 1];
+      } else {
+        action = "callback";
+      }
+    }
+    if (segments.length > 0) {
+      if (segments.length === 2 && segments[0] !== "oauth") {
+        return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+      }
+    }
+    if (method === "GET" && action === "callback") {
+      const url = new URL(request.url);
+      const searchParams = url.searchParams;
+      const code = searchParams.get("code");
+      const state = searchParams.get("state");
+      const error = searchParams.get("error");
+      const errorDescription = searchParams.get("error_description");
+      const defaultRedirectUrl = "/";
+      const errorRedirectUrl = "/auth-error";
+      if (error) {
+        const errorMsg = errorDescription || error;
+        console.error("[OAuth Redirect] Error:", errorMsg);
+        return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, request.url));
+      }
+      if (!code || !state) {
+        console.error("[OAuth Redirect] Missing code or state parameter");
+        return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, request.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 = request.headers.get("referer") || request.headers.get("referrer");
+          if (referrer) {
+            const referrerUrl = new URL(referrer);
+            const currentUrl = new URL(request.url);
+            if (referrerUrl.origin === currentUrl.origin) {
+              returnUrl = referrerUrl.pathname + referrerUrl.search;
+            }
+          }
+        } catch {}
+      }
+      const targetUrl = new URL(returnUrl, request.url);
+      targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+      return Response.redirect(targetUrl);
+    }
+    const handlerContext = { params: { action: action || "callback" } };
+    if (method === "POST") {
+      return POST(request, handlerContext);
+    } else if (method === "GET") {
+      return GET(request, handlerContext);
+    } else {
+      return Response.json({ error: `Method ${method} not allowed` }, { status: 405 });
+    }
+  };
+  return {
+    client,
+    POST,
+    GET,
+    handler
+  };
+}
+function createOAuthRouteHandlers(config) {
+  const handler = createNextOAuthHandler(config);
+  return handler.createRoutes();
+}
+var POST = async (req, context) => {
+  if (!globalServerConfig) {
+    return Response.json({ error: "OAuth not configured. Call createMCPServer() in your server initialization file first." }, { status: 500 });
+  }
+  const handler = createNextOAuthHandler(globalServerConfig);
+  const routes = handler.createRoutes();
+  return routes.POST(req, context);
+};
+var GET = async (req, context) => {
+  if (!globalServerConfig) {
+    return Response.json({ error: "OAuth not configured. Call createMCPServer() in your server initialization file first." }, { status: 500 });
+  }
+  const handler = createNextOAuthHandler(globalServerConfig);
+  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 };
+}
+function toAstroHandler(baseHandler, options) {
+  const defaultRedirectUrl = options?.redirectUrl || "/";
+  const errorRedirectUrl = options?.errorRedirectUrl || "/auth-error";
+  return async (ctx) => {
+    const wrappedHandler = async (request, context) => {
+      const url = new URL(request.url);
+      const method = request.method.toUpperCase();
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      const oauthIndex = pathParts.indexOf("oauth");
+      if (method === "GET" && oauthIndex >= 0 && pathParts[oauthIndex + 1] === "callback") {
+        const searchParams = url.searchParams;
+        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)}`, request.url));
+        }
+        if (!code || !state) {
+          console.error("[OAuth Redirect] Missing code or state parameter");
+          return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, request.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 = request.headers.get("referer") || request.headers.get("referrer");
+            if (referrer) {
+              const referrerUrl = new URL(referrer);
+              const currentUrl = new URL(request.url);
+              if (referrerUrl.origin === currentUrl.origin) {
+                returnUrl = referrerUrl.pathname + referrerUrl.search;
+              }
+            }
+          } catch {}
+        }
+        const targetUrl = new URL(returnUrl, request.url);
+        targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+        return Response.redirect(targetUrl);
+      }
+      return baseHandler(request, context);
+    };
+    return wrappedHandler(ctx.request, { params: { all: ctx.params.all } });
+  };
+}
+function toSolidStartHandler(baseHandler, options) {
+  const wrappedHandler = toAstroHandler(baseHandler, options);
+  const handler = async (event) => {
+    return wrappedHandler({ request: event.request, params: {} });
+  };
+  return {
+    GET: handler,
+    POST: handler,
+    PATCH: handler,
+    PUT: handler,
+    DELETE: handler
+  };
+}
+function toSvelteKitHandler(baseHandler, options) {
+  const wrappedHandler = toAstroHandler(baseHandler, options);
+  return async (event) => {
+    const all = event.params?.all;
+    return wrappedHandler({ request: event.request, params: { all } });
+  };
+}
+// src/adapters/svelte-kit.ts
+async function svelteKitHandler({
+  authConfig,
+  event,
+  resolve,
+  basePath = "/api/integrate"
+}) {
+  const { url } = event;
+  const baseUrl = new URL(basePath, url.origin);
+  if (!url.pathname.startsWith(baseUrl.pathname)) {
+    return resolve(event);
+  }
+  return authConfig(event.request);
+}
+// src/adapters/tanstack-start.ts
+function toTanStackStartHandler(handler) {
+  const baseHandler = async ({ request }) => {
+    return handler(request);
+  };
+  return {
+    GET: baseHandler,
+    POST: baseHandler
+  };
+}
+var createTanStackOAuthHandler = toTanStackStartHandler;
+
+// src/index.ts
+init_errors();
+
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {

package/dist/server.js

@@ -1855,14 +1855,7 @@ function createNextOAuthHandler(config) {
 // src/utils/env.ts
 function getEnv(key) {
   try {
-    const getMetaEnv = () => {
-      try {
-        return typeof import.meta !== "undefined" ? import.meta.env : undefined;
-      } catch {
-        return;
-      }
-    };
-    const metaEnv = getMetaEnv();
+    const metaEnv = import.meta.env;
     if (metaEnv && typeof metaEnv === "object" && metaEnv !== null) {
       const value = metaEnv[key];
       if (value !== undefined && value !== null && value !== "") {
@@ -2059,19 +2052,81 @@ function createMCPServer(config) {
   const handler = async (request, context) => {
     const method = request.method.toUpperCase();
     let action;
+    let segments = [];
     if (context?.params?.action) {
       action = context.params.action;
     } else if (context?.params?.all) {
       const all = context.params.all;
       if (Array.isArray(all)) {
-        action = all[all.length - 1];
+        segments = all;
       } else if (typeof all === "string") {
-        action = all.split("/").pop();
+        segments = all.split("/").filter(Boolean);
+      }
+      if (segments.length === 2 && segments[0] === "oauth") {
+        action = segments[1];
+      } else if (segments.length === 1) {
+        action = segments[0];
+      } else if (segments.length > 0) {
+        action = segments[segments.length - 1];
       }
     } else {
       const url = new URL(request.url);
       const pathParts = url.pathname.split("/").filter(Boolean);
-      action = pathParts[pathParts.length - 1] || "callback";
+      segments = pathParts;
+      const oauthIndex = pathParts.indexOf("oauth");
+      if (oauthIndex >= 0 && oauthIndex < pathParts.length - 1) {
+        action = pathParts[oauthIndex + 1];
+      } else if (pathParts.length > 0) {
+        action = pathParts[pathParts.length - 1];
+      } else {
+        action = "callback";
+      }
+    }
+    if (segments.length > 0) {
+      if (segments.length === 2 && segments[0] !== "oauth") {
+        return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
+      }
+    }
+    if (method === "GET" && action === "callback") {
+      const url = new URL(request.url);
+      const searchParams = url.searchParams;
+      const code = searchParams.get("code");
+      const state = searchParams.get("state");
+      const error = searchParams.get("error");
+      const errorDescription = searchParams.get("error_description");
+      const defaultRedirectUrl = "/";
+      const errorRedirectUrl = "/auth-error";
+      if (error) {
+        const errorMsg = errorDescription || error;
+        console.error("[OAuth Redirect] Error:", errorMsg);
+        return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent(errorMsg)}`, request.url));
+      }
+      if (!code || !state) {
+        console.error("[OAuth Redirect] Missing code or state parameter");
+        return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, request.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 = request.headers.get("referer") || request.headers.get("referrer");
+          if (referrer) {
+            const referrerUrl = new URL(referrer);
+            const currentUrl = new URL(request.url);
+            if (referrerUrl.origin === currentUrl.origin) {
+              returnUrl = referrerUrl.pathname + referrerUrl.search;
+            }
+          }
+        } catch {}
+      }
+      const targetUrl = new URL(returnUrl, request.url);
+      targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+      return Response.redirect(targetUrl);
     }
     const handlerContext = { params: { action: action || "callback" } };
     if (method === "POST") {
@@ -2136,8 +2191,83 @@ function toNextJsHandler(options) {
   };
   return { POST: POST2, GET: GET2 };
 }
+function toAstroHandler(baseHandler, options) {
+  const defaultRedirectUrl = options?.redirectUrl || "/";
+  const errorRedirectUrl = options?.errorRedirectUrl || "/auth-error";
+  return async (ctx) => {
+    const wrappedHandler = async (request, context) => {
+      const url = new URL(request.url);
+      const method = request.method.toUpperCase();
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      const oauthIndex = pathParts.indexOf("oauth");
+      if (method === "GET" && oauthIndex >= 0 && pathParts[oauthIndex + 1] === "callback") {
+        const searchParams = url.searchParams;
+        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)}`, request.url));
+        }
+        if (!code || !state) {
+          console.error("[OAuth Redirect] Missing code or state parameter");
+          return Response.redirect(new URL(`${errorRedirectUrl}?error=${encodeURIComponent("Invalid OAuth callback")}`, request.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 = request.headers.get("referer") || request.headers.get("referrer");
+            if (referrer) {
+              const referrerUrl = new URL(referrer);
+              const currentUrl = new URL(request.url);
+              if (referrerUrl.origin === currentUrl.origin) {
+                returnUrl = referrerUrl.pathname + referrerUrl.search;
+              }
+            }
+          } catch {}
+        }
+        const targetUrl = new URL(returnUrl, request.url);
+        targetUrl.hash = `oauth_callback=${encodeURIComponent(JSON.stringify({ code, state }))}`;
+        return Response.redirect(targetUrl);
+      }
+      return baseHandler(request, context);
+    };
+    return wrappedHandler(ctx.request, { params: { all: ctx.params.all } });
+  };
+}
+function toSolidStartHandler(baseHandler, options) {
+  const wrappedHandler = toAstroHandler(baseHandler, options);
+  const handler = async (event) => {
+    return wrappedHandler({ request: event.request, params: {} });
+  };
+  return {
+    GET: handler,
+    POST: handler,
+    PATCH: handler,
+    PUT: handler,
+    DELETE: handler
+  };
+}
+function toSvelteKitHandler(baseHandler, options) {
+  const wrappedHandler = toAstroHandler(baseHandler, options);
+  return async (event) => {
+    const all = event.params?.all;
+    return wrappedHandler({ request: event.request, params: { all } });
+  };
+}
 export {
+  toSvelteKitHandler,
+  toSolidStartHandler,
   toNextJsHandler,
+  toAstroHandler,
   gmailPlugin,
   githubPlugin,
   genericOAuthPlugin,

package/dist/src/adapters/solid-start.d.ts

@@ -1,54 +1,8 @@
 /**
  * SolidStart OAuth Route Adapter
  * Provides OAuth route handlers for SolidStart
- */
-/**
- * Create SolidStart OAuth route handlers
- *
- * Use this to create secure OAuth API routes in your SolidStart application
- * that handle authorization with server-side secrets.
- *
- * @param baseHandler - Handler function from createMCPServer
- * @returns Object with GET, POST, PATCH, PUT, DELETE handlers
- *
- * @example
- * ```typescript
- * // lib/integrate-server.ts
- * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
- *
- * export const { client: serverClient, handler } = createMCPServer({
- *   plugins: [
- *     githubPlugin({
- *       clientId: process.env.GITHUB_CLIENT_ID!,
- *       clientSecret: process.env.GITHUB_CLIENT_SECRET!,
- *     }),
- *   ],
- * });
- *
- * // src/routes/api/integrate/[...all].ts
- * import { toSolidStartHandler } from 'integrate-sdk/adapters/solid-start';
- * import { handler } from '@/lib/integrate-server';
- *
- * const handlers = toSolidStartHandler(handler);
  *
- * export const { GET, POST, PATCH, PUT, DELETE } = handlers;
- * ```
+ * Re-exports from server.ts for convenience
  */
-export declare function toSolidStartHandler(baseHandler: (request: Request) => Promise<Response>): {
-    GET: (event: {
-        request: Request;
-    }) => Promise<Response>;
-    POST: (event: {
-        request: Request;
-    }) => Promise<Response>;
-    PATCH: (event: {
-        request: Request;
-    }) => Promise<Response>;
-    PUT: (event: {
-        request: Request;
-    }) => Promise<Response>;
-    DELETE: (event: {
-        request: Request;
-    }) => Promise<Response>;
-};
+export { toSolidStartHandler } from '../server.js';
 //# sourceMappingURL=solid-start.d.ts.map

package/dist/src/adapters/solid-start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solid-start.d.ts","sourceRoot":"","sources":["../../../src/adapters/solid-start.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC;iBACxD;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;kBAAxC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;mBAAxC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;iBAAxC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;oBAAxC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAG,OAAO,CAAC,QAAQ,CAAC;EAWvE"}
+{"version":3,"file":"solid-start.d.ts","sourceRoot":"","sources":["../../../src/adapters/solid-start.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC"}

package/dist/src/adapters/svelte-kit.d.ts

@@ -50,8 +50,7 @@ export declare function svelteKitHandler({ authConfig, event, resolve, basePath,
  * Use this to create secure OAuth API routes in your SvelteKit application
  * that handle authorization with server-side secrets.
  *
- * @param baseHandler - Handler function from createMCPServer
- * @returns Handler function for SvelteKit routes
+ * Re-exports from server.ts for convenience
  *
  * @example
  * ```typescript
@@ -68,15 +67,17 @@ export declare function svelteKitHandler({ authConfig, event, resolve, basePath,
  * });
  *
  * // routes/api/integrate/[...all]/+server.ts
- * import { toSvelteKitHandler } from 'integrate-sdk/adapters/svelte-kit';
+ * import { toSvelteKitHandler } from 'integrate-sdk/server';
  * import { handler } from '$lib/integrate-server';
  *
- * const svelteKitRoute = toSvelteKitHandler(handler);
+ * const svelteKitRoute = toSvelteKitHandler(handler, {
+ *   redirectUrl: '/dashboard',
+ *   errorRedirectUrl: '/auth-error',
+ * });
  *
  * export const POST = svelteKitRoute;
  * export const GET = svelteKitRoute;
  * ```
  */
-export declare function toSvelteKitHandler(baseHandler: (request: Request) => Promise<Response>): (event: RequestEvent) => Promise<Response>;
-export {};
+export { toSvelteKitHandler } from '../server.js';
 //# sourceMappingURL=svelte-kit.d.ts.map

package/dist/src/adapters/svelte-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,KAAK,YAAY,GAAG,GAAG,CAAC;AACxB,KAAK,eAAe,GAAG,GAAG,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,gBAAgB,CAAC,EACnC,UAAU,EACV,KAAK,EACL,OAAO,EACP,QAA2B,GAC9B,EAAE;IACC,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpD,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAWpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,IACrE,OAAO,YAAY,KAAG,OAAO,CAAC,QAAQ,CAAC,CAGxD"}
+{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,KAAK,YAAY,GAAG,GAAG,CAAC;AACxB,KAAK,eAAe,GAAG,GAAG,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,gBAAgB,CAAC,EACnC,UAAU,EACV,KAAK,EACL,OAAO,EACP,QAA2B,GAC9B,EAAE;IACC,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpD,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAWpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC"}