@metorial/mcp-server 1.0.0-rc.3 → 1.0.0-rc.5

package/src/auth.ts

@@ -1,28 +1,28 @@
 import z from 'zod';
 
-export type McpServerAuthUrlHandlerParams<AuthConfig extends {}> = {
-  authConfig: AuthConfig;
+export type McpServerOAuthUrlHandlerParams<OAuthConfig extends {}> = {
+  authConfig: OAuthConfig;
   clientId: string;
   clientSecret: string;
   state: string;
   redirectUri: string;
 };
 
-export type McpServerAuthUrlHandlerResult = {
+export type McpServerOAuthUrlHandlerResult = {
   authorizationUrl: string;
   authState?: Record<string, string> | null;
 };
 
-export type McpServerAuthUrlHandlerInternal = <AuthConfig extends {}>(
-  d: McpServerAuthUrlHandlerParams<AuthConfig>
-) => Promise<McpServerAuthUrlHandlerResult>;
+export type McpServerOAuthUrlHandlerInternal = <OAuthConfig extends {}>(
+  d: McpServerOAuthUrlHandlerParams<OAuthConfig>
+) => Promise<McpServerOAuthUrlHandlerResult>;
 
-export type McpServerAuthUrlHandler = <AuthConfig extends {}>(
-  d: McpServerAuthUrlHandlerParams<AuthConfig>
-) => Promise<string | McpServerAuthUrlHandlerResult>;
+export type McpServerOAuthUrlHandler = <OAuthConfig extends {}>(
+  d: McpServerOAuthUrlHandlerParams<OAuthConfig>
+) => Promise<string | McpServerOAuthUrlHandlerResult>;
 
-export type McpServerAuthCallbackHandlerParams<AuthConfig extends {}> = {
-  authConfig: AuthConfig;
+export type McpServerOAuthCallbackHandlerParams<OAuthConfig extends {}> = {
+  authConfig: OAuthConfig;
   authState: Record<string, string>;
   clientId: string;
   clientSecret: string;
@@ -33,7 +33,7 @@ export type McpServerAuthCallbackHandlerParams<AuthConfig extends {}> = {
   authorizationUrl: string;
 };
 
-export type McpServerAuthCallbackHandlerResult = {
+export type McpServerOAuthCallbackHandlerResult = {
   accessToken: string;
   refreshToken?: string;
   expiresIn?: number;
@@ -42,19 +42,19 @@ export type McpServerAuthCallbackHandlerResult = {
   [key: string]: any;
 };
 
-export type McpServerAuthCallbackHandler = <AuthConfig extends {}>(
-  d: McpServerAuthCallbackHandlerParams<AuthConfig>
-) => Promise<McpServerAuthCallbackHandlerResult>;
+export type McpServerOAuthCallbackHandler = <OAuthConfig extends {}>(
+  d: McpServerOAuthCallbackHandlerParams<OAuthConfig>
+) => Promise<McpServerOAuthCallbackHandlerResult>;
 
-export type McpServerAuthTokenRefreshHandlerParams<AuthConfig extends {}> = {
-  authConfig: AuthConfig;
+export type McpServerOAuthTokenRefreshHandlerParams<OAuthConfig extends {}> = {
+  authConfig: OAuthConfig;
   authState: Record<string, string>;
   refreshToken: string;
   clientId: string;
   clientSecret: string;
 };
 
-export type McpServerAuthTokenRefreshHandlerResult = {
+export type McpServerOAuthTokenRefreshHandlerResult = {
   accessToken: string;
   refreshToken?: string;
   expiresIn?: number;
@@ -63,11 +63,17 @@ export type McpServerAuthTokenRefreshHandlerResult = {
   [key: string]: any;
 };
 
-export type McpServerAuthTokenRefreshHandler = <AuthConfig extends {}>(
-  d: McpServerAuthTokenRefreshHandlerParams<AuthConfig>
-) => Promise<McpServerAuthTokenRefreshHandlerResult>;
+export type McpServerOAuthTokenHandlers = {
+  getAuthorizationUrl: McpServerOAuthUrlHandler;
+  handleCallback: McpServerOAuthCallbackHandler;
+  refreshToken?: McpServerOAuthTokenRefreshHandler;
+};
+
+export type McpServerOAuthTokenRefreshHandler = <OAuthConfig extends {}>(
+  d: McpServerOAuthTokenRefreshHandlerParams<OAuthConfig>
+) => Promise<McpServerOAuthTokenRefreshHandlerResult>;
 
-export type McpServerAuthValue = {
+export type McpServerOAuthValue = {
   accessToken: string;
   expiresIn?: number;
   scope?: string;
@@ -75,36 +81,63 @@ export type McpServerAuthValue = {
   [key: string]: any;
 };
 
-export class McpServerAuthConfig<AuthConfig extends {}> {
-  #value: McpServerAuthValue | null = null;
+export let authConfigs = new Set<McpServerOAuthConfig<any>>();
+
+export class McpServerOAuthConfig<OAuthConfig extends {}> {
+  #value: McpServerOAuthValue | null = null;
+  #isRegistered = false;
+
+  #getAuthUrlHandler?: McpServerOAuthUrlHandlerInternal;
+  #callbackHandler?: McpServerOAuthCallbackHandler;
+  #tokenRefreshHandler?: McpServerOAuthTokenRefreshHandler;
+
+  private constructor(public readonly schema: z.ZodType<OAuthConfig>) {
+    authConfigs.add(this);
+  }
+
+  static create<OAuthConfig extends {}>(
+    ...args:
+      | [z.ZodType<OAuthConfig>, McpServerOAuthTokenHandlers]
+      | [McpServerOAuthTokenHandlers]
+  ) {
+    let schema = args.length == 2 ? args[0] : undefined;
+    let handlers = args.length == 2 ? args[1] : args[0];
 
-  #getAuthUrlHandler?: McpServerAuthUrlHandlerInternal;
-  #callbackHandler?: McpServerAuthCallbackHandler;
-  #tokenRefreshHandler?: McpServerAuthTokenRefreshHandler;
+    let config = new McpServerOAuthConfig(schema ?? (z.object({}) as z.ZodType<OAuthConfig>));
 
-  private constructor(public readonly schema: z.ZodType<AuthConfig>) {}
+    config.getAuthorizationUrl(handlers.getAuthorizationUrl);
+    config.handleCallback(handlers.handleCallback);
+    if (handlers.refreshToken) {
+      config.refreshToken(handlers.refreshToken);
+    }
 
-  static create<AuthConfig extends {}>(schema?: z.ZodType<AuthConfig>) {
-    return new McpServerAuthConfig(schema ?? (z.object({}) as z.ZodType<AuthConfig>));
+    return config.build();
   }
 
-  static getImplementation(config: McpServerAuthConfig<any>) {
+  static getImplementation(config: McpServerOAuthConfig<any>) {
     if (!config.#getAuthUrlHandler || !config.#callbackHandler) {
       throw new Error('MCP Server auth config is missing required handlers');
     }
 
     return {
+      setValue: config.setValue.bind(config),
+      registered: config.registered.bind(config),
+
       getAuthUrlHandler: config.#getAuthUrlHandler,
       callbackHandler: config.#callbackHandler,
       tokenRefreshHandler: config.#tokenRefreshHandler
     };
   }
 
-  setValue(value: McpServerAuthValue) {
-    this.#value = value;
+  static assertRegistered(config: McpServerOAuthConfig<any>) {
+    if (!config.#isRegistered) {
+      throw new Error(
+        'MCP Server auth config is not registered with `createMcpServer`. Please pass your OAuth config as `authConfig` when creating the server.'
+      );
+    }
   }
 
-  getAuthorizationUrl(cb: McpServerAuthUrlHandler) {
+  getAuthorizationUrl(cb: McpServerOAuthUrlHandler) {
     this.#getAuthUrlHandler = async d => {
       let res = await cb(d);
       if (typeof res == 'string') {
@@ -115,17 +148,17 @@ export class McpServerAuthConfig<AuthConfig extends {}> {
     return this;
   }
 
-  handleCallback(cb: McpServerAuthCallbackHandler) {
+  handleCallback(cb: McpServerOAuthCallbackHandler) {
     this.#callbackHandler = cb;
     return this;
   }
 
-  refreshToken(cb: McpServerAuthTokenRefreshHandler) {
+  refreshToken(cb: McpServerOAuthTokenRefreshHandler) {
     this.#tokenRefreshHandler = cb;
     return this;
   }
 
-  build(): AuthConfig {
+  build(): OAuthConfig {
     if (!this.#getAuthUrlHandler || !this.#callbackHandler) {
       throw new Error('MCP Server auth config is missing required handlers');
     }
@@ -142,38 +175,57 @@ export class McpServerAuthConfig<AuthConfig extends {}> {
             return self;
           }
 
-          if (self.#value === null) {
-            throw new Error('MCP Server auth config value not set');
+          if (self.#value === null || !self.#isRegistered) {
+            throw new Error(
+              'MCP Server auth config is not registered with `createMcpServer`. Please pass your OAuth config as `authConfig` when creating the server.'
+            );
           }
 
           return (self.#value as any)[prop];
         }
       }
-    ) as any as AuthConfig;
+    ) as any as OAuthConfig;
+  }
+
+  private setValue(value: McpServerOAuthValue) {
+    this.#value = value;
+  }
+
+  private registered() {
+    this.#isRegistered = true;
   }
 }
 
-export let createAuth = <Config extends {}>(schema?: z.ZodType<Config>) => {
-  return McpServerAuthConfig.create(schema);
-};
+export let createOAuth = <Config extends {}>(
+  ...args: [z.ZodType<Config>, McpServerOAuthTokenHandlers] | [McpServerOAuthTokenHandlers]
+) => McpServerOAuthConfig.create(...args);
 
-export let auth = <Config extends {}>(schema?: z.ZodType<Config>) => createAuth(schema);
+export let oAuth = createOAuth;
 
-export let getAuthConfigImplementation = <Config extends {}>(configValue: any) => {
-  let self = configValue['__config__'] as McpServerAuthConfig<Config>;
-  return McpServerAuthConfig.getImplementation(self);
+export let getOAuthConfigImplementation = <Config extends {}>(configValue: any) => {
+  let self = configValue['__config__'] as McpServerOAuthConfig<Config>;
+  return McpServerOAuthConfig.getImplementation(self);
 };
 
-export let setAuthConfigValue = <Config extends {}>(
+export let setOAuthConfigValue = <Config extends {}>(
   configValue: any,
-  value: McpServerAuthValue
+  value: McpServerOAuthValue
 ) => {
-  let self = configValue['__config__'] as McpServerAuthConfig<Config>;
-  self.setValue(value);
+  let self = configValue['__config__'] as McpServerOAuthConfig<Config>;
+  let impl = McpServerOAuthConfig.getImplementation(self);
+
+  impl.setValue(value);
+  impl.registered();
+};
+
+export let registerOAuthConfig = <Config extends {}>(configValue: any) => {
+  let self = configValue['__config__'] as McpServerOAuthConfig<Config>;
+  let impl = McpServerOAuthConfig.getImplementation(self);
+  impl.registered();
 };
 
-export let getAuthConfigSchema = <Config extends {}>(configValue: any) => {
-  let self = configValue['__config__'] as McpServerAuthConfig<Config>;
+export let getOAuthConfigSchema = <Config extends {}>(configValue: any) => {
+  let self = configValue['__config__'] as McpServerOAuthConfig<Config>;
   return self.schema.toJSONSchema({
     unrepresentable: 'any',
     override: ctx => {

package/src/config.ts

@@ -1,19 +1,36 @@
 import z from 'zod';
 
+export let configs = new Set<McpServerConfig<any>>();
+
 export class McpServerConfig<Config extends {}> {
   #value: Config | null = null;
+  #isRegistered = false;
 
-  private constructor(public readonly schema: z.ZodType<Config>) {}
+  private constructor(public readonly schema: z.ZodType<Config>) {
+    configs.add(this);
+  }
 
   static create<Config extends {}>(schema: z.ZodType<Config>) {
     return new McpServerConfig(schema);
   }
 
+  static assertRegistered(config: McpServerConfig<any>) {
+    if (!config.#isRegistered) {
+      throw new Error(
+        'MCP Server config is not registered with `createMcpServer`. Please pass your config as `config` when creating the server.'
+      );
+    }
+  }
+
   setValue(value: unknown) {
     let parsed = this.schema.parse(value);
     this.#value = parsed;
   }
 
+  registered() {
+    this.#isRegistered = true;
+  }
+
   value(): Config {
     let self = this;
 
@@ -27,8 +44,10 @@ export class McpServerConfig<Config extends {}> {
             return self;
           }
 
-          if (self.#value === null) {
-            throw new Error('MCP Server config value not set');
+          if (self.#value === null || !self.#isRegistered) {
+            throw new Error(
+              'MCP Server config is not registered with `createMcpServer`. Please pass your config as `config` when creating the server.'
+            );
           }
 
           return (self.#value as any)[prop];
@@ -47,6 +66,12 @@ export let config = <Config extends {}>(schema: z.ZodType<Config>) => createConf
 export let setConfigValue = <Config extends {}>(configValue: any, value: Config) => {
   let self = configValue['__config__'] as McpServerConfig<Config>;
   self.setValue(value);
+  self.registered();
+};
+
+export let registerConfig = <Config extends {}>(configValue: any) => {
+  let self = configValue['__config__'] as McpServerConfig<Config>;
+  self.registered();
 };
 
 export let getConfigSchema = <Config extends {}>(configValue: any) => {

package/src/index.ts

@@ -13,20 +13,20 @@ export {
 } from './adapter';
 
 export {
-  auth,
-  createAuth,
-  type McpServerAuthCallbackHandler,
-  type McpServerAuthCallbackHandlerParams,
-  type McpServerAuthCallbackHandlerResult,
-  type McpServerAuthConfig,
-  type McpServerAuthTokenRefreshHandler,
-  type McpServerAuthTokenRefreshHandlerParams,
-  type McpServerAuthTokenRefreshHandlerResult,
-  type McpServerAuthUrlHandler,
-  type McpServerAuthUrlHandlerInternal,
-  type McpServerAuthUrlHandlerParams,
-  type McpServerAuthUrlHandlerResult,
-  type McpServerAuthValue
+  createOAuth,
+  oAuth,
+  type McpServerOAuthCallbackHandler,
+  type McpServerOAuthCallbackHandlerParams,
+  type McpServerOAuthCallbackHandlerResult,
+  type McpServerOAuthConfig,
+  type McpServerOAuthTokenRefreshHandler,
+  type McpServerOAuthTokenRefreshHandlerParams,
+  type McpServerOAuthTokenRefreshHandlerResult,
+  type McpServerOAuthUrlHandler,
+  type McpServerOAuthUrlHandlerInternal,
+  type McpServerOAuthUrlHandlerParams,
+  type McpServerOAuthUrlHandlerResult,
+  type McpServerOAuthValue
 } from './auth';
 
 export { config, createConfig, type McpServerConfig } from './config';

package/src/instance.ts

@@ -5,15 +5,24 @@ import {
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
 import {
-  getAuthConfigImplementation,
-  getAuthConfigSchema,
-  McpServerAuthCallbackHandlerParams,
-  McpServerAuthTokenRefreshHandlerParams,
-  McpServerAuthUrlHandlerParams,
-  setAuthConfigValue
+  authConfigs,
+  getOAuthConfigImplementation,
+  getOAuthConfigSchema,
+  McpServerOAuthCallbackHandlerParams,
+  McpServerOAuthConfig,
+  McpServerOAuthTokenRefreshHandlerParams,
+  McpServerOAuthUrlHandlerParams,
+  registerOAuthConfig,
+  setOAuthConfigValue
 } from './auth';
 import { ClientOpts, handleMcpMessages } from './client';
-import { getConfigSchema, setConfigValue } from './config';
+import {
+  configs,
+  getConfigSchema,
+  McpServerConfig,
+  registerConfig,
+  setConfigValue
+} from './config';
 
 export type McpServerInstanceServer = CreateMcpServerOpts | { server: McpServer };
 let getServer = (instance: McpServerInstanceServer) => {
@@ -33,6 +42,12 @@ export class McpServerInstance {
   #server: McpServer;
 
   private constructor(private instance: McpServerInstanceOpts) {
+    if (instance.config) registerConfig(instance.config);
+    if (instance.authConfig) registerOAuthConfig(instance.authConfig);
+
+    for (let ac of authConfigs) McpServerOAuthConfig.assertRegistered(ac);
+    for (let co of configs) McpServerConfig.assertRegistered(co);
+
     this.#server = getServer(instance);
   }
 
@@ -46,8 +61,8 @@ export class McpServerInstance {
       oauth: this.instance.authConfig
         ? {
             status: 'enabled' as const,
-            authConfig: getAuthConfigSchema(this.instance.authConfig),
-            hasTokenRefresh: !!getAuthConfigImplementation(this.instance.authConfig)
+            authConfig: getOAuthConfigSchema(this.instance.authConfig),
+            hasTokenRefresh: !!getOAuthConfigImplementation(this.instance.authConfig)
               .tokenRefreshHandler
           }
         : {
@@ -66,29 +81,29 @@ export class McpServerInstance {
       setConfigValue(this.instance.config, opts.config);
     }
     if (opts.authConfig && this.instance.authConfig) {
-      setAuthConfigValue(this.instance.authConfig, opts.authConfig);
+      setOAuthConfigValue(this.instance.authConfig, opts.authConfig);
     }
 
     return handleMcpMessages(this.#server, opts.client, opts.message);
   }
 
-  getOauthAuthorizationUrl(d: McpServerAuthUrlHandlerParams<any>) {
+  getOauthAuthorizationUrl(d: McpServerOAuthUrlHandlerParams<any>) {
     if (!this.instance.authConfig) return null;
-    let impl = getAuthConfigImplementation(this.instance.authConfig);
+    let impl = getOAuthConfigImplementation(this.instance.authConfig);
 
     return impl.getAuthUrlHandler(d);
   }
 
-  handleOauthCallback(d: McpServerAuthCallbackHandlerParams<any>) {
+  handleOauthCallback(d: McpServerOAuthCallbackHandlerParams<any>) {
     if (!this.instance.authConfig) return null;
-    let impl = getAuthConfigImplementation(this.instance.authConfig);
+    let impl = getOAuthConfigImplementation(this.instance.authConfig);
 
     return impl.callbackHandler(d);
   }
 
-  handleOauthTokenRefresh(d: McpServerAuthTokenRefreshHandlerParams<any>) {
+  handleOauthTokenRefresh(d: McpServerOAuthTokenRefreshHandlerParams<any>) {
     if (!this.instance.authConfig) return null;
-    let impl = getAuthConfigImplementation(this.instance.authConfig);
+    let impl = getOAuthConfigImplementation(this.instance.authConfig);
 
     if (!impl.tokenRefreshHandler) {
       return null;