Merge pull request #29 from Beyond-Better/staging

Client session tracking; improved types

Author: cngarrison

deno.jsonc

@@ -1,6 +1,6 @@
 {
   "name": "@beyondbetter/bb-mcp-server",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Comprehensive library for building Deno-based MCP servers",
   "license": "MIT",
   "copyright": "2025 - Beyond Better <charlie@beyondbetter.app>",

src/lib/server/AppServer.ts

@@ -111,6 +111,7 @@ export class AppServer {
       //   credentialStore: appDependencies.credentialStore,
       // });
     }
+
     const resolvedDependencies: AppServerDependencies = await getAllDependencies(
       appDependencies,
     );
@@ -247,6 +248,7 @@ export class AppServer {
 
     // Create HTTP server if we have the dependencies
     if (this.dependencies.httpServerConfig) {
+      this._logger.info('AppServer: customEndpoints...', this.dependencies.customEndpoints);
       this.httpServer = new HttpServer({
         logger: this._logger,
         beyondMcpServer: this.dependencies.beyondMcpServer,
@@ -256,6 +258,7 @@ export class AppServer {
         workflowRegistry: this.dependencies.workflowRegistry,
         httpServerConfig: this.dependencies.httpServerConfig,
         docsEndpointHandler: this.dependencies.docsEndpointHandler,
+        customEndpoints: this.dependencies.customEndpoints,
       });
 
       // Start HTTP server (handles MCP via /mcp endpoint)

src/lib/server/BeyondMcpServer.ts

@@ -42,6 +42,7 @@ import {
   type CreateMessageResult,
   type ElicitInputRequest,
   type ElicitInputResult,
+  type SendNotificationRequest,
   type ToolDefinition,
   type ToolHandler,
   ToolHandlerMode,
@@ -233,6 +234,13 @@ export class BeyondMcpServer {
     return this.sdkMcpServer;
   }
 
+  /**
+   * Get the transport manager instance
+   */
+  getTransportManager(): TransportManager {
+    return this.transportManager;
+  }
+
   /**
    * Execute an operation within the context of an authenticated user
    */
@@ -361,18 +369,28 @@ export class BeyondMcpServer {
   /**
    * MCP SDK integration methods
    */
-  async createMessage(request: CreateMessageRequest): Promise<CreateMessageResult> {
+  async createMessage(
+    request: CreateMessageRequest,
+    sessionId?: string,
+  ): Promise<CreateMessageResult> {
+    if (!this.mcpSDKHelpers) {
+      throw new Error('BeyondMcpServer not initialized. Call initialize() first.');
+    }
+    return await this.mcpSDKHelpers.createMessage(request, sessionId);
+  }
+
+  async elicitInput(request: ElicitInputRequest, sessionId?: string): Promise<ElicitInputResult> {
     if (!this.mcpSDKHelpers) {
       throw new Error('BeyondMcpServer not initialized. Call initialize() first.');
     }
-    return await this.mcpSDKHelpers.createMessage(request);
+    return await this.mcpSDKHelpers.elicitInput(request, sessionId);
   }
 
-  async elicitInput(request: ElicitInputRequest): Promise<ElicitInputResult> {
+  async sendNotification(request: SendNotificationRequest, sessionId?: string): Promise<void> {
     if (!this.mcpSDKHelpers) {
       throw new Error('BeyondMcpServer not initialized. Call initialize() first.');
     }
-    return await this.mcpSDKHelpers.elicitInput(request);
+    return await this.mcpSDKHelpers.sendNotification(request, sessionId);
   }
 
   /**

src/lib/server/DependencyHelpers.ts

@@ -860,6 +860,7 @@ export async function getAllDependencies(
     consumerDeps.oauthConsumer, // Pass OAuth consumer for third-party auth
     consumerDeps.thirdpartyApiClient, // Pass API client for token refresh
   );
+
   const transportManager = overrides.transportManager || getTransportManager(
     configManager,
     logger,
@@ -881,6 +882,10 @@ export async function getAllDependencies(
   const docsEndpointHandler = overrides.docsEndpointHandler ||
     getDocsEndpointHandler(docsEndpointConfig, logger);
 
+  if (overrides.customEndpoints) {
+    consumerDeps.customEndpoints = overrides.customEndpoints;
+  }
+
   // Create MCP server (either from class or default)
   const serverConfig = overrides.serverConfig || {
     name: configManager.get('SERVER_NAME', 'generic-mcp-server'),

src/lib/server/HttpServer.ts

@@ -19,6 +19,7 @@ import type { OAuthProvider } from '../auth/OAuthProvider.ts';
 import type { OAuthConsumer } from '../auth/OAuthConsumer.ts';
 import type { WorkflowRegistry } from '../workflows/WorkflowRegistry.ts';
 import type { DocsEndpointHandler } from './DocsEndpointHandler.ts';
+import type { CustomEndpoints } from './ServerTypes.ts';
 import { OAuthEndpoints } from './OAuthEndpoints.ts';
 import { BeyondMcpServer } from './BeyondMcpServer.ts';
 import { APIRouter } from './APIRouter.ts';
@@ -73,10 +74,7 @@ export interface HttpServerDependencies {
   /** Documentation endpoint handler (optional) */
   docsEndpointHandler?: DocsEndpointHandler | undefined;
   /** Custom endpoint handlers */
-  customEndpoints?: Array<{
-    path: string;
-    handle(request: Request): Promise<Response>;
-  }>;
+  customEndpoints?: CustomEndpoints | undefined;
 }
 
 /**
@@ -100,10 +98,7 @@ export class HttpServer {
   private corsHandler: CORSHandler;
   private errorPages: ErrorPages;
   private docsHandler: DocsEndpointHandler | undefined;
-  private customEndpoints: Array<{
-    path: string;
-    handle(request: Request): Promise<Response>;
-  }>;
+  private customEndpoints: CustomEndpoints | undefined;
 
   // Integration components
   private beyondMcpServer: BeyondMcpServer;
@@ -150,11 +145,11 @@ export class HttpServer {
       hostname: this.httpServerConfig.hostname,
       signal: this.abortController.signal,
       onListen: ({ port, hostname }) => {
-        this.logger.info(`HTTP server running on http://${hostname}:${port}`);
+        this.logger.info(`HttpServer: HTTP server running on http://${hostname}:${port}`);
       },
     }, (request: Request) => this.handleRequest(request));
 
-    this.server.finished.then(() => this.logger.info('HTTP server closed'));
+    this.server.finished.then(() => this.logger.info('HttpServer: HTTP server closed'));
   }
 
   /**
@@ -164,7 +159,7 @@ export class HttpServer {
     if (this.server) {
       this.abortController.abort('stopping server');
       this.server = undefined;
-      this.logger.info('HTTP server stopped');
+      this.logger.info('HttpServer: HTTP server stopped');
     }
   }
 
@@ -176,7 +171,7 @@ export class HttpServer {
     const path = url.pathname;
     const method = request.method;
 
-    this.logger.debug(`HTTP request: ${method} ${path}`);
+    this.logger.debug(`HttpServer: HTTP request: ${method} ${path}`);
 
     try {
       // Handle CORS preflight
@@ -191,7 +186,7 @@ export class HttpServer {
       return this.corsHandler.addCORSHeaders(response);
     } catch (error) {
       this.logger.error(
-        'HTTP request error:',
+        'HttpServer: HTTP request error:',
         error instanceof Error ? error : new Error(String(error)),
       );
       return this.corsHandler.addCORSHeaders(
@@ -228,9 +223,11 @@ export class HttpServer {
     }
 
     // Custom endpoints
-    for (const handler of this.customEndpoints) {
-      if (path.startsWith(handler.path)) {
-        return await handler.handle(request);
+    if (this.customEndpoints) {
+      for (const handler of this.customEndpoints) {
+        if (path.startsWith(handler.path)) {
+          return await handler.handle(request, { beyondMcpServer: this.beyondMcpServer });
+        }
       }
     }
 

src/lib/server/MCPSDKHelpers.ts

@@ -8,11 +8,11 @@
  * - Tool schema generation helpers
  */
 
-import { McpServer as SdkMcpServer } from 'mcp/server/mcp.js';
+import type { McpServer as SdkMcpServer } from 'mcp/server/mcp.js';
 import type { CallToolResult } from 'mcp/types.js';
 
 // Import library components
-import { Logger } from '../utils/Logger.ts';
+import type { Logger } from '../utils/Logger.ts';
 import { toError } from '../utils/Error.ts';
 
 // Import types
@@ -21,7 +21,9 @@ import type {
   CreateMessageResult,
   ElicitInputRequest,
   ElicitInputResult,
+  //LoggingLevel,
   RegisteredTool,
+  SendNotificationRequest,
 } from '../types/BeyondMcpTypes.ts';
 
 /**
@@ -39,19 +41,24 @@ export class BeyondMcpSDKHelpers {
   /**
    * MCP Sampling API integration
    */
-  async createMessage(request: CreateMessageRequest): Promise<CreateMessageResult> {
+  async createMessage(
+    request: CreateMessageRequest,
+    sessionId?: string,
+  ): Promise<CreateMessageResult> {
     this.logger.debug('MCPSDKHelpers: Creating message via MCP sampling API', {
       model: request.model,
       messageCount: request.messages.length,
       maxTokens: request.maxTokens,
       temperature: request.temperature,
+      sessionId,
     });
 
     try {
       // Cast to MCP SDK expected type
       const mcpRequest = {
         ...request,
         maxTokens: request.maxTokens || 2000, // Ensure maxTokens is present
+        // deno-lint-ignore no-explicit-any
       } as any;
 
       const result = await this.sdkMcpServer.server.createMessage(mcpRequest);
@@ -60,6 +67,7 @@ export class BeyondMcpSDKHelpers {
         model: request.model,
         hasContent: !!result?.content,
         contentLength: result?.content ? JSON.stringify(result.content).length : 0,
+        sessionId,
       });
 
       // Cast result to expected type with unknown intermediate
@@ -72,27 +80,65 @@ export class BeyondMcpSDKHelpers {
     }
   }
 
+  /**
+   * MCP Notification API integration
+   * Sends a logging message notification to the client
+   */
+  async sendNotification(request: SendNotificationRequest, sessionId?: string): Promise<void> {
+    this.logger.debug('MCPSDKHelpers: Sending notification via MCP notification API', {
+      level: request.level,
+      logger: request.logger,
+      hasData: !!request.data,
+      sessionId,
+    });
+
+    try {
+      // Send notification using SDK's sendLoggingMessage
+      await this.sdkMcpServer.sendLoggingMessage(
+        {
+          level: request.level,
+          logger: request.logger,
+          data: request.data,
+        },
+        sessionId,
+      );
+
+      this.logger.debug('MCPSDKHelpers: Notification sent successfully', {
+        level: request.level,
+        logger: request.logger,
+      });
+    } catch (error) {
+      this.logger.error('MCPSDKHelpers: MCP notification failed:', toError(error));
+      throw new Error(
+        `MCP notification failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      );
+    }
+  }
+
   /**
    * MCP Elicitation API integration
    */
-  async elicitInput(request: ElicitInputRequest): Promise<ElicitInputResult> {
+  async elicitInput(request: ElicitInputRequest, sessionId?: string): Promise<ElicitInputResult> {
     this.logger.debug('MCPSDKHelpers: Eliciting input via MCP elicitation API', {
       messageLength: request.message.length,
       hasSchema: !!request.requestedSchema,
+      sessionId,
     });
 
     try {
       // Cast to MCP SDK expected type
       const mcpRequest = {
         ...request,
+        // deno-lint-ignore no-explicit-any
         requestedSchema: request.requestedSchema as any,
       };
-
+      // deno-lint-ignore no-explicit-any
       const result = await this.sdkMcpServer.server.elicitInput(mcpRequest as any);
 
       this.logger.debug('MCPSDKHelpers: Input elicited successfully', {
         action: result.action,
         hasContent: !!result.content,
+        sessionId,
       });
 
       // Cast result to expected type - handle action mapping

src/lib/server/ServerTypes.ts

@@ -11,6 +11,7 @@ import type { Logger } from '../../types/library.types.ts';
 import type { OAuthProvider } from '../auth/OAuthProvider.ts';
 import type { TransportManager } from '../transport/TransportManager.ts';
 import type { WorkflowRegistry } from '../workflows/WorkflowRegistry.ts';
+import type { BeyondMcpServer } from './BeyondMcpServer.ts';
 
 // Re-export core server types for convenience
 export type { HttpServerConfig, HttpServerDependencies } from './HttpServer.ts';
@@ -315,6 +316,16 @@ export interface EndpointRegistry {
   } | null;
 }
 
+/**
+ * Endpoint handler registry
+ */
+export interface CustomEndpoint {
+  path: string;
+  //handle(request: Request, dependencies: AppDependencies): Promise<Response>;
+  handle(request: Request, dependencies: { beyondMcpServer: BeyondMcpServer }): Promise<Response>;
+}
+export type CustomEndpoints = Array<CustomEndpoint>;
+
 /**
  * Request/response logging configuration
  */