refactor: simplify context type hierarchy from 14 types to 4 plain types

Remove all context classes (BaseContext, ServerContext, ClientContext,
NotificationLogHelper) and intermediate types (McpReqContext, McpReqContextInput,
HttpReqContext, NotificationContext, BaseRequestContext, ServerNotificationContext).

Replace with 4 plain types:
- TaskContext: conditional task grouping
- ContextInterface: base context with nested mcpReq, http?, task?, notification
- ServerContextInterface: extends via & with server additions
- ClientContextInterface: type alias for ContextInterface

POJO construction inlined in Server.createRequestContext() and
Client.createRequestContext(). No abstract classes or factories needed.

Bug fixes:
- requestSampling now passes relatedRequestId (was missing)
- Logging methods now route through sendLoggingMessage with NotificationOptions
  for proper relatedRequestId/relatedTask association

Net: -348 lines

Author: felixweinberger

examples/server/src/simpleStreamableHttp.ts

@@ -63,13 +63,10 @@ const getServer = () => {
             }
         },
         async ({ name }, ctx): Promise<CallToolResult> => {
-            await ctx.notification.log(
-                {
-                    level: 'debug',
-                    data: `Starting greet for ${name}`
-                },
-                ctx.sessionId
-            );
+            await ctx.notification.log({
+                level: 'debug',
+                data: `Starting greet for ${name}`
+            });
 
             return {
                 content: [
@@ -96,36 +93,27 @@ const getServer = () => {
                 openWorldHint: false
             }
         },
-        async ({ name }, ctx): Promise<CallToolResult> => {
+        async ({ name }, _ctx): Promise<CallToolResult> => {
             const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
-            await server.sendLoggingMessage(
-                {
-                    level: 'debug',
-                    data: `Starting multi-greet for ${name}`
-                },
-                ctx.sessionId
-            );
+            await server.sendLoggingMessage({
+                level: 'debug',
+                data: `Starting multi-greet for ${name}`
+            });
 
             await sleep(1000); // Wait 1 second before first greeting
 
-            await server.sendLoggingMessage(
-                {
-                    level: 'info',
-                    data: `Sending first greeting to ${name}`
-                },
-                ctx.sessionId
-            );
+            await server.sendLoggingMessage({
+                level: 'info',
+                data: `Sending first greeting to ${name}`
+            });
 
             await sleep(1000); // Wait another second before second greeting
 
-            await server.sendLoggingMessage(
-                {
-                    level: 'info',
-                    data: `Sending second greeting to ${name}`
-                },
-                ctx.sessionId
-            );
+            await server.sendLoggingMessage({
+                level: 'info',
+                data: `Sending second greeting to ${name}`
+            });
 
             return {
                 content: [
@@ -311,13 +299,10 @@ const getServer = () => {
             }
         },
         async ({ name }, ctx): Promise<GetPromptResult> => {
-            await ctx.notification.log(
-                {
-                    level: 'debug',
-                    data: `Starting greeting template for ${name}`
-                },
-                ctx.sessionId
-            );
+            await ctx.notification.log({
+                level: 'debug',
+                data: `Starting greeting template for ${name}`
+            });
 
             return {
                 messages: [
@@ -406,13 +391,10 @@ const getServer = () => {
             mimeType: 'text/plain'
         },
         async (_, ctx): Promise<ReadResourceResult> => {
-            await ctx.notification.log(
-                {
-                    level: 'debug',
-                    data: `Starting example file 1`
-                },
-                ctx.sessionId
-            );
+            await ctx.notification.log({
+                level: 'debug',
+                data: `Starting example file 1`
+            });
 
             return {
                 contents: [

packages/client/src/client/client.ts

@@ -1,11 +1,13 @@
 import type {
+    AnySchema,
     CallToolRequest,
     ClientCapabilities,
     ClientNotification,
     ClientRequest,
     ClientResult,
     CompatibilityCallToolResultSchema,
     CompleteRequest,
+    ContextInterface,
     GetPromptRequest,
     Implementation,
     JSONRPCRequest,
@@ -22,13 +24,15 @@ import type {
     MessageExtraInfo,
     Notification,
     NotificationMethod,
+    NotificationOptions,
     ProtocolOptions,
     ReadResourceRequest,
     Request,
     RequestMethod,
     RequestOptions,
     RequestTypeMap,
     Result,
+    SchemaOutput,
     ServerCapabilities,
     SubscribeRequest,
     TaskContext,
@@ -42,6 +46,7 @@ import {
     AjvJsonSchemaValidator,
     assertClientRequestTaskCapability,
     assertToolsCallTaskCapability,
+    buildTaskContext,
     CallToolResultSchema,
     CompleteResultSchema,
     CreateMessageRequestSchema,
@@ -70,7 +75,6 @@ import {
 
 import { ExperimentalClientTasks } from '../experimental/tasks/client.js';
 import type { ClientContextInterface } from './context.js';
-import { ClientContext } from './context.js';
 
 /**
  * Elicitation default application helper. Applies defaults to the data based on the schema.
@@ -472,37 +476,57 @@ export class Client<
         abortController: AbortController;
         capturedTransport: Transport | undefined;
         extra?: MessageExtraInfo;
-    }): ClientContextInterface<ClientRequest | RequestT, ClientNotification | NotificationT> {
+    }): ContextInterface<ClientRequest | RequestT, ClientNotification | NotificationT> {
         const { request, taskStore, relatedTaskId, taskCreationParams, abortController, capturedTransport, extra } = args;
         const sessionId = capturedTransport?.sessionId;
+        const requestId = request.id;
 
-        // Build the task context using the helper from Protocol
-        const task: TaskContext | undefined = this.buildTaskContext({
+        const task: TaskContext | undefined = buildTaskContext({
             taskStore,
             request,
             sessionId,
             relatedTaskId,
             taskCreationParams
         });
 
-        // Return a ClientContext instance
-        return new ClientContext<RequestT, NotificationT, ResultT>({
-            client: this,
-            request,
+        // Build send closures that inject relatedRequestId and relatedTask
+        const sendRequest = async <U extends AnySchema>(
+            req: ClientRequest | RequestT,
+            resultSchema: U,
+            options?: RequestOptions
+        ): Promise<SchemaOutput<U>> => {
+            const requestOptions: RequestOptions = { ...options, relatedRequestId: requestId };
+            const taskId = task?.id;
+            if (taskId) {
+                requestOptions.relatedTask = { taskId };
+                if (task?.store) {
+                    await task.store.updateTaskStatus(taskId, 'input_required');
+                }
+            }
+            return this.request(req, resultSchema, requestOptions);
+        };
+
+        const sendNotification = async (notification: ClientNotification | NotificationT): Promise<void> => {
+            const notificationOptions: NotificationOptions = { relatedRequestId: requestId };
+            if (task && task.id) {
+                notificationOptions.relatedTask = { taskId: task.id };
+            }
+            return this.notification(notification, notificationOptions);
+        };
+
+        return {
             sessionId,
             mcpReq: {
-                id: request.id,
+                id: requestId,
                 method: request.method,
                 _meta: request.params?._meta,
-                signal: abortController.signal
+                signal: abortController.signal,
+                send: sendRequest
             },
-            http: extra?.authInfo
-                ? {
-                      authInfo: extra?.authInfo
-                  }
-                : undefined,
-            task: task
-        });
+            http: extra?.authInfo ? { authInfo: extra.authInfo } : undefined,
+            task,
+            notification: { send: sendNotification }
+        };
     }
 
     protected assertCapability(capability: keyof ServerCapabilities, method: string): void {

packages/client/src/client/context.ts

@@ -1,66 +1,13 @@
-import type {
-    ClientNotification,
-    ClientRequest,
-    ClientResult,
-    ContextInterface,
-    HttpReqContext,
-    JSONRPCRequest,
-    McpReqContextInput,
-    Notification,
-    Request,
-    Result,
-    TaskContext
-} from '@modelcontextprotocol/core';
-import { BaseContext } from '@modelcontextprotocol/core';
-
-import type { Client } from './client.js';
+import type { ClientNotification, ClientRequest, ContextInterface, Notification, Request } from '@modelcontextprotocol/core';
 
 /**
- * Type alias for client-side request handler context.
- * Extends the base ContextInterface with no additional fields.
- * The generic parameters match the Client's combined types.
+ * Client-specific context type for request handlers.
+ * Used when the client handles requests from the server (e.g., sampling, elicitation).
+ *
+ * @typeParam RequestT - The type of requests that can be sent from this context
+ * @typeParam NotificationT - The type of notifications that can be sent from this context
  */
 export type ClientContextInterface<
     RequestT extends Request = Request,
     NotificationT extends Notification = Notification
 > = ContextInterface<ClientRequest | RequestT, ClientNotification | NotificationT>;
-
-/**
- * A context object that is passed to client-side request handlers.
- * Used when the client handles requests from the server (e.g., sampling, elicitation).
- */
-export class ClientContext<
-        RequestT extends Request = Request,
-        NotificationT extends Notification = Notification,
-        ResultT extends Result = Result
-    >
-    extends BaseContext<ClientRequest | RequestT, ClientNotification | NotificationT, ClientResult | ResultT>
-    implements ClientContextInterface<RequestT, NotificationT>
-{
-    private readonly client: Client<RequestT, NotificationT, ResultT>;
-
-    constructor(args: {
-        sessionId?: string;
-        request: JSONRPCRequest;
-        mcpReq: McpReqContextInput;
-        http?: HttpReqContext;
-        task: TaskContext | undefined;
-        client: Client<RequestT, NotificationT, ResultT>;
-    }) {
-        super({
-            request: args.request,
-            sessionId: args.sessionId,
-            mcpReq: args.mcpReq,
-            http: args.http,
-            task: args.task
-        });
-        this.client = args.client;
-    }
-
-    /**
-     * Returns the client instance for sending notifications and requests.
-     */
-    protected getProtocol(): Client<RequestT, NotificationT, ResultT> {
-        return this.client;
-    }
-}