integrate-sdk 0.6.9 → 0.7.0

package/dist/adapters/auto-routes.js

@@ -139,6 +139,41 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
+  async handleToolCall(request, authHeader) {
+    const url = new URL("/tools/call", this.serverUrl);
+    const headers = this.getHeaders({
+      "Content-Type": "application/json"
+    });
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      headers["Authorization"] = authHeader;
+    }
+    const jsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method: "tools/call",
+      params: {
+        name: request.name,
+        arguments: request.arguments || {}
+      }
+    };
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(jsonRpcRequest)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to execute tool call: ${error}`);
+    }
+    const jsonRpcResponse = await response.json();
+    if (jsonRpcResponse.error) {
+      const error = new Error(jsonRpcResponse.error.message || "Tool call failed");
+      error.code = jsonRpcResponse.error.code;
+      error.data = jsonRpcResponse.error.data;
+      throw error;
+    }
+    return jsonRpcResponse.result;
+  }
 }
 
 // src/adapters/auto-routes.ts

package/dist/adapters/base-handler.js

@@ -139,6 +139,41 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
+  async handleToolCall(request, authHeader) {
+    const url = new URL("/tools/call", this.serverUrl);
+    const headers = this.getHeaders({
+      "Content-Type": "application/json"
+    });
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      headers["Authorization"] = authHeader;
+    }
+    const jsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method: "tools/call",
+      params: {
+        name: request.name,
+        arguments: request.arguments || {}
+      }
+    };
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(jsonRpcRequest)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to execute tool call: ${error}`);
+    }
+    const jsonRpcResponse = await response.json();
+    if (jsonRpcResponse.error) {
+      const error = new Error(jsonRpcResponse.error.message || "Tool call failed");
+      error.code = jsonRpcResponse.error.code;
+      error.data = jsonRpcResponse.error.data;
+      throw error;
+    }
+    return jsonRpcResponse.result;
+  }
 }
 export {
   OAuthHandler

package/dist/adapters/nextjs.js

@@ -235,6 +235,41 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
+  async handleToolCall(request, authHeader) {
+    const url = new URL("/tools/call", this.serverUrl);
+    const headers = this.getHeaders({
+      "Content-Type": "application/json"
+    });
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      headers["Authorization"] = authHeader;
+    }
+    const jsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method: "tools/call",
+      params: {
+        name: request.name,
+        arguments: request.arguments || {}
+      }
+    };
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(jsonRpcRequest)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to execute tool call: ${error}`);
+    }
+    const jsonRpcResponse = await response.json();
+    if (jsonRpcResponse.error) {
+      const error = new Error(jsonRpcResponse.error.message || "Tool call failed");
+      error.code = jsonRpcResponse.error.code;
+      error.data = jsonRpcResponse.error.data;
+      throw error;
+    }
+    return jsonRpcResponse.result;
+  }
 }
 
 // src/adapters/nextjs.ts
@@ -312,6 +347,9 @@ function createNextOAuthHandler(config) {
           if (action === "disconnect") {
             return handlers.disconnect(req);
           }
+          if (action === "mcp") {
+            return handlers.mcp(req);
+          }
           return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
         },
         async GET(req, context) {
@@ -324,6 +362,17 @@ function createNextOAuthHandler(config) {
         }
       };
     },
+    async mcp(req) {
+      try {
+        const body = await req.json();
+        const authHeader = req.headers.get("authorization");
+        const result = await handler.handleToolCall(body, authHeader);
+        return Response.json(result);
+      } catch (error) {
+        console.error("[MCP Tool Call] Error:", error);
+        return Response.json({ error: error.message || "Failed to execute tool call" }, { status: error.statusCode || 500 });
+      }
+    },
     toNextJsHandler(redirectConfig) {
       const defaultRedirectUrl = redirectConfig?.redirectUrl || "/";
       const errorRedirectUrl = redirectConfig?.errorRedirectUrl || "/auth-error";
@@ -344,6 +393,9 @@ function createNextOAuthHandler(config) {
             }
             return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
           }
+          if (segments.length === 1 && segments[0] === "mcp") {
+            return handlers.mcp(req);
+          }
           return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
         },
         async GET(req, context) {

package/dist/adapters/node.js

@@ -139,6 +139,41 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
+  async handleToolCall(request, authHeader) {
+    const url = new URL("/tools/call", this.serverUrl);
+    const headers = this.getHeaders({
+      "Content-Type": "application/json"
+    });
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      headers["Authorization"] = authHeader;
+    }
+    const jsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method: "tools/call",
+      params: {
+        name: request.name,
+        arguments: request.arguments || {}
+      }
+    };
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(jsonRpcRequest)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to execute tool call: ${error}`);
+    }
+    const jsonRpcResponse = await response.json();
+    if (jsonRpcResponse.error) {
+      const error = new Error(jsonRpcResponse.error.message || "Tool call failed");
+      error.code = jsonRpcResponse.error.code;
+      error.data = jsonRpcResponse.error.data;
+      throw error;
+    }
+    return jsonRpcResponse.result;
+  }
 }
 
 // src/adapters/node.ts

package/dist/adapters/solid-start.js

@@ -373,6 +373,41 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
+  async handleToolCall(request, authHeader) {
+    const url = new URL("/tools/call", this.serverUrl);
+    const headers = this.getHeaders({
+      "Content-Type": "application/json"
+    });
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      headers["Authorization"] = authHeader;
+    }
+    const jsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method: "tools/call",
+      params: {
+        name: request.name,
+        arguments: request.arguments || {}
+      }
+    };
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(jsonRpcRequest)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to execute tool call: ${error}`);
+    }
+    const jsonRpcResponse = await response.json();
+    if (jsonRpcResponse.error) {
+      const error = new Error(jsonRpcResponse.error.message || "Tool call failed");
+      error.code = jsonRpcResponse.error.code;
+      error.data = jsonRpcResponse.error.data;
+      throw error;
+    }
+    return jsonRpcResponse.result;
+  }
 }
 
 // src/adapters/nextjs.ts
@@ -450,6 +485,9 @@ function createNextOAuthHandler(config) {
           if (action === "disconnect") {
             return handlers.disconnect(req);
           }
+          if (action === "mcp") {
+            return handlers.mcp(req);
+          }
           return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
         },
         async GET(req, context) {
@@ -462,6 +500,17 @@ function createNextOAuthHandler(config) {
         }
       };
     },
+    async mcp(req) {
+      try {
+        const body = await req.json();
+        const authHeader = req.headers.get("authorization");
+        const result = await handler.handleToolCall(body, authHeader);
+        return Response.json(result);
+      } catch (error) {
+        console.error("[MCP Tool Call] Error:", error);
+        return Response.json({ error: error.message || "Failed to execute tool call" }, { status: error.statusCode || 500 });
+      }
+    },
     toNextJsHandler(redirectConfig) {
       const defaultRedirectUrl = redirectConfig?.redirectUrl || "/";
       const errorRedirectUrl = redirectConfig?.errorRedirectUrl || "/auth-error";
@@ -482,6 +531,9 @@ function createNextOAuthHandler(config) {
             }
             return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
           }
+          if (segments.length === 1 && segments[0] === "mcp") {
+            return handlers.mcp(req);
+          }
           return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
         },
         async GET(req, context) {
@@ -1279,6 +1331,7 @@ class MCPClient {
   connecting = null;
   oauthManager;
   eventEmitter = new SimpleEventEmitter;
+  apiRouteBase;
   github;
   gmail;
   server;
@@ -1290,6 +1343,7 @@ class MCPClient {
     });
     const oauthApiBase = config.oauthApiBase || "/api/integrate/oauth";
     const defaultRedirectUri = this.getDefaultRedirectUri(oauthApiBase);
+    this.apiRouteBase = config.apiRouteBase || "/api/integrate";
     this.plugins = config.plugins.map((plugin) => {
       if (plugin.oauth && !plugin.oauth.redirectUri) {
         return {
@@ -1381,12 +1435,8 @@ class MCPClient {
     if (!this.availableTools.has(name)) {
       throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
     }
-    const params = {
-      name,
-      arguments: args
-    };
     try {
-      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const response = await this.callToolThroughHandler(name, args);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
@@ -1445,18 +1495,58 @@ class MCPClient {
     if (!this.availableTools.has(name)) {
       throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
     }
-    const params = {
-      name,
-      arguments: args
-    };
     try {
-      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const response = await this.callToolThroughHandler(name, args);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
       throw parsedError;
     }
   }
+  async callToolThroughHandler(name, args, provider) {
+    const url = `${this.apiRouteBase}/mcp`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (provider) {
+      const tokenData = this.oauthManager.getProviderToken(provider);
+      if (tokenData) {
+        headers["Authorization"] = `Bearer ${tokenData.accessToken}`;
+      }
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        name,
+        arguments: args
+      })
+    });
+    if (!response.ok) {
+      let errorMessage = `Request failed: ${response.statusText}`;
+      const error = new Error(errorMessage);
+      error.statusCode = response.status;
+      try {
+        const errorData = await response.json();
+        if (errorData.error) {
+          errorMessage = typeof errorData.error === "string" ? errorData.error : errorData.error.message || errorMessage;
+          error.message = errorMessage;
+        }
+        if (errorData.code) {
+          error.code = errorData.code;
+        }
+        if (errorData.data) {
+          error.data = errorData.data;
+        }
+        if (errorData.error && typeof errorData.error === "object") {
+          error.jsonrpcError = errorData.error;
+        }
+      } catch {}
+      throw error;
+    }
+    const result = await response.json();
+    return result;
+  }
   async callToolWithRetry(name, args, retryCount = 0) {
     if (!this.initialized) {
       throw new Error("Client not initialized. Call connect() first.");
@@ -1468,35 +1558,24 @@ class MCPClient {
       throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
     }
     const provider = this.getProviderForTool(name);
-    if (provider) {
-      const tokenData = this.oauthManager.getProviderToken(provider);
-      if (tokenData) {
-        this.transport.setHeader("Authorization", `Bearer ${tokenData.accessToken}`);
-      }
-    }
-    const params = {
-      name,
-      arguments: args
-    };
     try {
-      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const response = await this.callToolThroughHandler(name, args, provider);
       if (provider) {
         this.authState.set(provider, { authenticated: true });
       }
       return response;
     } catch (error) {
-      const provider2 = this.getProviderForTool(name);
-      const parsedError = parseServerError(error, { toolName: name, provider: provider2 });
+      const parsedError = parseServerError(error, { toolName: name, provider });
       if (isAuthError(parsedError) && retryCount < this.maxReauthRetries) {
-        if (provider2) {
-          this.authState.set(provider2, {
+        if (provider) {
+          this.authState.set(provider, {
             authenticated: false,
             lastError: parsedError
           });
         }
-        if (this.onReauthRequired && provider2) {
+        if (this.onReauthRequired && provider) {
           const reauthSuccess = await this.onReauthRequired({
-            provider: provider2,
+            provider,
             error: parsedError,
             toolName: name
           });

package/dist/adapters/svelte-kit.js

@@ -373,6 +373,41 @@ class OAuthHandler {
     const data = await response.json();
     return data;
   }
+  async handleToolCall(request, authHeader) {
+    const url = new URL("/tools/call", this.serverUrl);
+    const headers = this.getHeaders({
+      "Content-Type": "application/json"
+    });
+    if (authHeader && authHeader.startsWith("Bearer ")) {
+      headers["Authorization"] = authHeader;
+    }
+    const jsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: Date.now() + Math.random(),
+      method: "tools/call",
+      params: {
+        name: request.name,
+        arguments: request.arguments || {}
+      }
+    };
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(jsonRpcRequest)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`MCP server failed to execute tool call: ${error}`);
+    }
+    const jsonRpcResponse = await response.json();
+    if (jsonRpcResponse.error) {
+      const error = new Error(jsonRpcResponse.error.message || "Tool call failed");
+      error.code = jsonRpcResponse.error.code;
+      error.data = jsonRpcResponse.error.data;
+      throw error;
+    }
+    return jsonRpcResponse.result;
+  }
 }
 
 // src/adapters/nextjs.ts
@@ -450,6 +485,9 @@ function createNextOAuthHandler(config) {
           if (action === "disconnect") {
             return handlers.disconnect(req);
           }
+          if (action === "mcp") {
+            return handlers.mcp(req);
+          }
           return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
         },
         async GET(req, context) {
@@ -462,6 +500,17 @@ function createNextOAuthHandler(config) {
         }
       };
     },
+    async mcp(req) {
+      try {
+        const body = await req.json();
+        const authHeader = req.headers.get("authorization");
+        const result = await handler.handleToolCall(body, authHeader);
+        return Response.json(result);
+      } catch (error) {
+        console.error("[MCP Tool Call] Error:", error);
+        return Response.json({ error: error.message || "Failed to execute tool call" }, { status: error.statusCode || 500 });
+      }
+    },
     toNextJsHandler(redirectConfig) {
       const defaultRedirectUrl = redirectConfig?.redirectUrl || "/";
       const errorRedirectUrl = redirectConfig?.errorRedirectUrl || "/auth-error";
@@ -482,6 +531,9 @@ function createNextOAuthHandler(config) {
             }
             return Response.json({ error: `Unknown action: ${action}` }, { status: 404 });
           }
+          if (segments.length === 1 && segments[0] === "mcp") {
+            return handlers.mcp(req);
+          }
           return Response.json({ error: `Invalid route: /${segments.join("/")}` }, { status: 404 });
         },
         async GET(req, context) {
@@ -1279,6 +1331,7 @@ class MCPClient {
   connecting = null;
   oauthManager;
   eventEmitter = new SimpleEventEmitter;
+  apiRouteBase;
   github;
   gmail;
   server;
@@ -1290,6 +1343,7 @@ class MCPClient {
     });
     const oauthApiBase = config.oauthApiBase || "/api/integrate/oauth";
     const defaultRedirectUri = this.getDefaultRedirectUri(oauthApiBase);
+    this.apiRouteBase = config.apiRouteBase || "/api/integrate";
     this.plugins = config.plugins.map((plugin) => {
       if (plugin.oauth && !plugin.oauth.redirectUri) {
         return {
@@ -1381,12 +1435,8 @@ class MCPClient {
     if (!this.availableTools.has(name)) {
       throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
     }
-    const params = {
-      name,
-      arguments: args
-    };
     try {
-      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const response = await this.callToolThroughHandler(name, args);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
@@ -1445,18 +1495,58 @@ class MCPClient {
     if (!this.availableTools.has(name)) {
       throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
     }
-    const params = {
-      name,
-      arguments: args
-    };
     try {
-      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const response = await this.callToolThroughHandler(name, args);
       return response;
     } catch (error) {
       const parsedError = parseServerError(error, { toolName: name });
       throw parsedError;
     }
   }
+  async callToolThroughHandler(name, args, provider) {
+    const url = `${this.apiRouteBase}/mcp`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (provider) {
+      const tokenData = this.oauthManager.getProviderToken(provider);
+      if (tokenData) {
+        headers["Authorization"] = `Bearer ${tokenData.accessToken}`;
+      }
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        name,
+        arguments: args
+      })
+    });
+    if (!response.ok) {
+      let errorMessage = `Request failed: ${response.statusText}`;
+      const error = new Error(errorMessage);
+      error.statusCode = response.status;
+      try {
+        const errorData = await response.json();
+        if (errorData.error) {
+          errorMessage = typeof errorData.error === "string" ? errorData.error : errorData.error.message || errorMessage;
+          error.message = errorMessage;
+        }
+        if (errorData.code) {
+          error.code = errorData.code;
+        }
+        if (errorData.data) {
+          error.data = errorData.data;
+        }
+        if (errorData.error && typeof errorData.error === "object") {
+          error.jsonrpcError = errorData.error;
+        }
+      } catch {}
+      throw error;
+    }
+    const result = await response.json();
+    return result;
+  }
   async callToolWithRetry(name, args, retryCount = 0) {
     if (!this.initialized) {
       throw new Error("Client not initialized. Call connect() first.");
@@ -1468,35 +1558,24 @@ class MCPClient {
       throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
     }
     const provider = this.getProviderForTool(name);
-    if (provider) {
-      const tokenData = this.oauthManager.getProviderToken(provider);
-      if (tokenData) {
-        this.transport.setHeader("Authorization", `Bearer ${tokenData.accessToken}`);
-      }
-    }
-    const params = {
-      name,
-      arguments: args
-    };
     try {
-      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const response = await this.callToolThroughHandler(name, args, provider);
       if (provider) {
         this.authState.set(provider, { authenticated: true });
       }
       return response;
     } catch (error) {
-      const provider2 = this.getProviderForTool(name);
-      const parsedError = parseServerError(error, { toolName: name, provider: provider2 });
+      const parsedError = parseServerError(error, { toolName: name, provider });
       if (isAuthError(parsedError) && retryCount < this.maxReauthRetries) {
-        if (provider2) {
-          this.authState.set(provider2, {
+        if (provider) {
+          this.authState.set(provider, {
             authenticated: false,
             lastError: parsedError
           });
         }
-        if (this.onReauthRequired && provider2) {
+        if (this.onReauthRequired && provider) {
           const reauthSuccess = await this.onReauthRequired({
-            provider: provider2,
+            provider,
             error: parsedError,
             toolName: name
           });