@modelcontextprotocol/sdk 1.24.2 → 1.25.0

package/dist/cjs/shared/protocol.js

@@ -38,8 +38,8 @@ class Protocol {
         // Automatic pong by default.
         _request => ({}));
         // Install task handlers if TaskStore is provided
-        this._taskStore = _options === null || _options === void 0 ? void 0 : _options.taskStore;
-        this._taskMessageQueue = _options === null || _options === void 0 ? void 0 : _options.taskMessageQueue;
+        this._taskStore = _options?.taskStore;
+        this._taskMessageQueue = _options?.taskMessageQueue;
         if (this._taskStore) {
             this.setRequestHandler(types_js_1.GetTaskRequestSchema, async (request, extra) => {
                 const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
@@ -55,7 +55,6 @@ class Protocol {
             });
             this.setRequestHandler(types_js_1.GetTaskPayloadRequestSchema, async (request, extra) => {
                 const handleTaskResult = async () => {
-                    var _a;
                     const taskId = request.params.taskId;
                     // Deliver queued messages
                     if (this._taskMessageQueue) {
@@ -91,7 +90,7 @@ class Protocol {
                             }
                             // Send the message on the response stream by passing the relatedRequestId
                             // This tells the transport to write the message to the tasks/result response stream
-                            await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.send(queuedMessage.message, { relatedRequestId: extra.requestId }));
+                            await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
                         }
                     }
                     // Now check task status
@@ -125,9 +124,8 @@ class Protocol {
                 return await handleTaskResult();
             });
             this.setRequestHandler(types_js_1.ListTasksRequestSchema, async (request, extra) => {
-                var _a;
                 try {
-                    const { tasks, nextCursor } = await this._taskStore.listTasks((_a = request.params) === null || _a === void 0 ? void 0 : _a.cursor, extra.sessionId);
+                    const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
                     // @ts-expect-error SendResultT cannot contain ListTasksResult, but we include it in our derived types everywhere else
                     return {
                         tasks,
@@ -173,9 +171,12 @@ class Protocol {
         }
     }
     async _oncancel(notification) {
+        if (!notification.params.requestId) {
+            return;
+        }
         // Handle request cancellation
         const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
-        controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason);
+        controller?.abort(notification.params.reason);
     }
     _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
         this._timeoutInfo.set(messageId, {
@@ -216,22 +217,21 @@ class Protocol {
      * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
      */
     async connect(transport) {
-        var _a, _b, _c;
         this._transport = transport;
-        const _onclose = (_a = this.transport) === null || _a === void 0 ? void 0 : _a.onclose;
+        const _onclose = this.transport?.onclose;
         this._transport.onclose = () => {
-            _onclose === null || _onclose === void 0 ? void 0 : _onclose();
+            _onclose?.();
             this._onclose();
         };
-        const _onerror = (_b = this.transport) === null || _b === void 0 ? void 0 : _b.onerror;
+        const _onerror = this.transport?.onerror;
         this._transport.onerror = (error) => {
-            _onerror === null || _onerror === void 0 ? void 0 : _onerror(error);
+            _onerror?.(error);
             this._onerror(error);
         };
-        const _onmessage = (_c = this._transport) === null || _c === void 0 ? void 0 : _c.onmessage;
+        const _onmessage = this._transport?.onmessage;
         this._transport.onmessage = (message, extra) => {
-            _onmessage === null || _onmessage === void 0 ? void 0 : _onmessage(message, extra);
-            if ((0, types_js_1.isJSONRPCResponse)(message) || (0, types_js_1.isJSONRPCError)(message)) {
+            _onmessage?.(message, extra);
+            if ((0, types_js_1.isJSONRPCResultResponse)(message) || (0, types_js_1.isJSONRPCErrorResponse)(message)) {
                 this._onresponse(message);
             }
             else if ((0, types_js_1.isJSONRPCRequest)(message)) {
@@ -247,7 +247,6 @@ class Protocol {
         await this._transport.start();
     }
     _onclose() {
-        var _a;
         const responseHandlers = this._responseHandlers;
         this._responseHandlers = new Map();
         this._progressHandlers.clear();
@@ -255,18 +254,16 @@ class Protocol {
         this._pendingDebouncedNotifications.clear();
         const error = types_js_1.McpError.fromError(types_js_1.ErrorCode.ConnectionClosed, 'Connection closed');
         this._transport = undefined;
-        (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.onclose?.();
         for (const handler of responseHandlers.values()) {
             handler(error);
         }
     }
     _onerror(error) {
-        var _a;
-        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+        this.onerror?.(error);
     }
     _onnotification(notification) {
-        var _a;
-        const handler = (_a = this._notificationHandlers.get(notification.method)) !== null && _a !== void 0 ? _a : this.fallbackNotificationHandler;
+        const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
         // Ignore notifications not being subscribed to.
         if (handler === undefined) {
             return;
@@ -277,12 +274,11 @@ class Protocol {
             .catch(error => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
     }
     _onrequest(request, extra) {
-        var _a, _b, _c, _d, _e, _f;
-        const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== void 0 ? _a : this.fallbackRequestHandler;
+        const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
         // Capture the current transport at request time to ensure responses go to the correct client
         const capturedTransport = this._transport;
         // Extract taskId from request metadata if present (needed early for method not found case)
-        const relatedTaskId = (_d = (_c = (_b = request.params) === null || _b === void 0 ? void 0 : _b._meta) === null || _c === void 0 ? void 0 : _c[types_js_1.RELATED_TASK_META_KEY]) === null || _d === void 0 ? void 0 : _d.taskId;
+        const relatedTaskId = request.params?._meta?.[types_js_1.RELATED_TASK_META_KEY]?.taskId;
         if (handler === undefined) {
             const errorResponse = {
                 jsonrpc: '2.0',
@@ -298,21 +294,23 @@ class Protocol {
                     type: 'error',
                     message: errorResponse,
                     timestamp: Date.now()
-                }, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId).catch(error => this._onerror(new Error(`Failed to enqueue error response: ${error}`)));
+                }, capturedTransport?.sessionId).catch(error => this._onerror(new Error(`Failed to enqueue error response: ${error}`)));
             }
             else {
-                capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(errorResponse).catch(error => this._onerror(new Error(`Failed to send an error response: ${error}`)));
+                capturedTransport
+                    ?.send(errorResponse)
+                    .catch(error => this._onerror(new Error(`Failed to send an error response: ${error}`)));
             }
             return;
         }
         const abortController = new AbortController();
         this._requestHandlerAbortControllers.set(request.id, abortController);
-        const taskCreationParams = (_e = request.params) === null || _e === void 0 ? void 0 : _e.task;
-        const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId) : undefined;
+        const taskCreationParams = (0, types_js_1.isTaskAugmentedRequestParams)(request.params) ? request.params.task : undefined;
+        const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : undefined;
         const fullExtra = {
             signal: abortController.signal,
-            sessionId: capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId,
-            _meta: (_f = request.params) === null || _f === void 0 ? void 0 : _f._meta,
+            sessionId: capturedTransport?.sessionId,
+            _meta: request.params?._meta,
             sendNotification: async (notification) => {
                 // Include related-task metadata if this request is part of a task
                 const notificationOptions = { relatedRequestId: request.id };
@@ -322,7 +320,6 @@ class Protocol {
                 await this.notification(notification, notificationOptions);
             },
             sendRequest: async (r, resultSchema, options) => {
-                var _a, _b;
                 // Include related-task metadata if this request is part of a task
                 const requestOptions = { ...options, relatedRequestId: request.id };
                 if (relatedTaskId && !requestOptions.relatedTask) {
@@ -330,20 +327,20 @@ class Protocol {
                 }
                 // Set task status to input_required when sending a request within a task context
                 // Use the taskId from options (explicit) or fall back to relatedTaskId (inherited)
-                const effectiveTaskId = (_b = (_a = requestOptions.relatedTask) === null || _a === void 0 ? void 0 : _a.taskId) !== null && _b !== void 0 ? _b : relatedTaskId;
+                const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
                 if (effectiveTaskId && taskStore) {
                     await taskStore.updateTaskStatus(effectiveTaskId, 'input_required');
                 }
                 return await this.request(r, resultSchema, requestOptions);
             },
-            authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo,
+            authInfo: extra?.authInfo,
             requestId: request.id,
-            requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo,
+            requestInfo: extra?.requestInfo,
             taskId: relatedTaskId,
             taskStore: taskStore,
-            taskRequestedTtl: taskCreationParams === null || taskCreationParams === void 0 ? void 0 : taskCreationParams.ttl,
-            closeSSEStream: extra === null || extra === void 0 ? void 0 : extra.closeSSEStream,
-            closeStandaloneSSEStream: extra === null || extra === void 0 ? void 0 : extra.closeStandaloneSSEStream
+            taskRequestedTtl: taskCreationParams?.ttl,
+            closeSSEStream: extra?.closeSSEStream,
+            closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
         };
         // Starting with Promise.resolve() puts any synchronous errors into the monad as well.
         Promise.resolve()
@@ -371,13 +368,12 @@ class Protocol {
                     type: 'response',
                     message: response,
                     timestamp: Date.now()
-                }, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId);
+                }, capturedTransport?.sessionId);
             }
             else {
-                await (capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(response));
+                await capturedTransport?.send(response);
             }
         }, async (error) => {
-            var _a;
             if (abortController.signal.aborted) {
                 // Request was cancelled
                 return;
@@ -387,7 +383,7 @@ class Protocol {
                 id: request.id,
                 error: {
                     code: Number.isSafeInteger(error['code']) ? error['code'] : types_js_1.ErrorCode.InternalError,
-                    message: (_a = error.message) !== null && _a !== void 0 ? _a : 'Internal error',
+                    message: error.message ?? 'Internal error',
                     ...(error['data'] !== undefined && { data: error['data'] })
                 }
             };
@@ -397,10 +393,10 @@ class Protocol {
                     type: 'error',
                     message: errorResponse,
                     timestamp: Date.now()
-                }, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId);
+                }, capturedTransport?.sessionId);
             }
             else {
-                await (capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(errorResponse));
+                await capturedTransport?.send(errorResponse);
             }
         })
             .catch(error => this._onerror(new Error(`Failed to send response: ${error}`)))
@@ -439,7 +435,7 @@ class Protocol {
         const resolver = this._requestResolvers.get(messageId);
         if (resolver) {
             this._requestResolvers.delete(messageId);
-            if ((0, types_js_1.isJSONRPCResponse)(response)) {
+            if ((0, types_js_1.isJSONRPCResultResponse)(response)) {
                 resolver(response);
             }
             else {
@@ -457,7 +453,7 @@ class Protocol {
         this._cleanupTimeout(messageId);
         // Keep progress handler alive for CreateTaskResult responses
         let isTaskResponse = false;
-        if ((0, types_js_1.isJSONRPCResponse)(response) && response.result && typeof response.result === 'object') {
+        if ((0, types_js_1.isJSONRPCResultResponse)(response) && response.result && typeof response.result === 'object') {
             const result = response.result;
             if (result.task && typeof result.task === 'object') {
                 const task = result.task;
@@ -470,7 +466,7 @@ class Protocol {
         if (!isTaskResponse) {
             this._progressHandlers.delete(messageId);
         }
-        if ((0, types_js_1.isJSONRPCResponse)(response)) {
+        if ((0, types_js_1.isJSONRPCResultResponse)(response)) {
             handler(response);
         }
         else {
@@ -485,8 +481,7 @@ class Protocol {
      * Closes the connection.
      */
     async close() {
-        var _a;
-        await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.close());
+        await this._transport?.close();
     }
     /**
      * Sends a request and returns an AsyncGenerator that yields response messages.
@@ -516,8 +511,7 @@ class Protocol {
      * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
      */
     async *requestStream(request, resultSchema, options) {
-        var _a, _b, _c, _d;
-        const { task } = options !== null && options !== void 0 ? options : {};
+        const { task } = options ?? {};
         // For non-task requests, just yield the result
         if (!task) {
             try {
@@ -580,10 +574,10 @@ class Protocol {
                     return;
                 }
                 // Wait before polling again
-                const pollInterval = (_c = (_a = task.pollInterval) !== null && _a !== void 0 ? _a : (_b = this._options) === null || _b === void 0 ? void 0 : _b.defaultTaskPollInterval) !== null && _c !== void 0 ? _c : 1000;
+                const pollInterval = task.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
                 await new Promise(resolve => setTimeout(resolve, pollInterval));
                 // Check if cancelled
-                (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
+                options?.signal?.throwIfAborted();
             }
         }
         catch (error) {
@@ -599,10 +593,9 @@ class Protocol {
      * Do not use this method to emit notifications! Use notification() instead.
      */
     request(request, resultSchema, options) {
-        const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options !== null && options !== void 0 ? options : {};
+        const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
         // Send the request
         return new Promise((resolve, reject) => {
-            var _a, _b, _c, _d, _e, _f, _g;
             const earlyReject = (error) => {
                 reject(error);
             };
@@ -610,7 +603,7 @@ class Protocol {
                 earlyReject(new Error('Not connected'));
                 return;
             }
-            if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) {
+            if (this._options?.enforceStrictCapabilities === true) {
                 try {
                     this.assertCapabilityForMethod(request.method);
                     // If task creation is requested, also check task capabilities
@@ -623,19 +616,19 @@ class Protocol {
                     return;
                 }
             }
-            (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
+            options?.signal?.throwIfAborted();
             const messageId = this._requestMessageId++;
             const jsonrpcRequest = {
                 ...request,
                 jsonrpc: '2.0',
                 id: messageId
             };
-            if (options === null || options === void 0 ? void 0 : options.onprogress) {
+            if (options?.onprogress) {
                 this._progressHandlers.set(messageId, options.onprogress);
                 jsonrpcRequest.params = {
                     ...request.params,
                     _meta: {
-                        ...(((_c = request.params) === null || _c === void 0 ? void 0 : _c._meta) || {}),
+                        ...(request.params?._meta || {}),
                         progressToken: messageId
                     }
                 };
@@ -652,31 +645,31 @@ class Protocol {
                 jsonrpcRequest.params = {
                     ...jsonrpcRequest.params,
                     _meta: {
-                        ...(((_d = jsonrpcRequest.params) === null || _d === void 0 ? void 0 : _d._meta) || {}),
+                        ...(jsonrpcRequest.params?._meta || {}),
                         [types_js_1.RELATED_TASK_META_KEY]: relatedTask
                     }
                 };
             }
             const cancel = (reason) => {
-                var _a;
                 this._responseHandlers.delete(messageId);
                 this._progressHandlers.delete(messageId);
                 this._cleanupTimeout(messageId);
-                (_a = this._transport) === null || _a === void 0 ? void 0 : _a.send({
+                this._transport
+                    ?.send({
                     jsonrpc: '2.0',
                     method: 'notifications/cancelled',
                     params: {
                         requestId: messageId,
                         reason: String(reason)
                     }
-                }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch(error => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
+                }, { relatedRequestId, resumptionToken, onresumptiontoken })
+                    .catch(error => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
                 // Wrap the reason in an McpError if it isn't already
                 const error = reason instanceof types_js_1.McpError ? reason : new types_js_1.McpError(types_js_1.ErrorCode.RequestTimeout, String(reason));
                 reject(error);
             };
             this._responseHandlers.set(messageId, response => {
-                var _a;
-                if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                if (options?.signal?.aborted) {
                     return;
                 }
                 if (response instanceof Error) {
@@ -696,15 +689,14 @@ class Protocol {
                     reject(error);
                 }
             });
-            (_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 ? void 0 : _e.addEventListener('abort', () => {
-                var _a;
-                cancel((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.reason);
+            options?.signal?.addEventListener('abort', () => {
+                cancel(options?.signal?.reason);
             });
-            const timeout = (_f = options === null || options === void 0 ? void 0 : options.timeout) !== null && _f !== void 0 ? _f : exports.DEFAULT_REQUEST_TIMEOUT_MSEC;
+            const timeout = options?.timeout ?? exports.DEFAULT_REQUEST_TIMEOUT_MSEC;
             const timeoutHandler = () => cancel(types_js_1.McpError.fromError(types_js_1.ErrorCode.RequestTimeout, 'Request timed out', { timeout }));
-            this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_g = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _g !== void 0 ? _g : false);
+            this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
             // Queue request if related to a task
-            const relatedTaskId = relatedTask === null || relatedTask === void 0 ? void 0 : relatedTask.taskId;
+            const relatedTaskId = relatedTask?.taskId;
             if (relatedTaskId) {
                 // Store the response resolver for this request so responses can be routed back
                 const responseResolver = (response) => {
@@ -778,13 +770,12 @@ class Protocol {
      * Emits a notification, which is a one-way message that does not expect a response.
      */
     async notification(notification, options) {
-        var _a, _b, _c, _d, _e;
         if (!this._transport) {
             throw new Error('Not connected');
         }
         this.assertNotificationCapability(notification.method);
         // Queue notification if related to a task
-        const relatedTaskId = (_a = options === null || options === void 0 ? void 0 : options.relatedTask) === null || _a === void 0 ? void 0 : _a.taskId;
+        const relatedTaskId = options?.relatedTask?.taskId;
         if (relatedTaskId) {
             // Build the JSONRPC notification with metadata
             const jsonrpcNotification = {
@@ -793,7 +784,7 @@ class Protocol {
                 params: {
                     ...notification.params,
                     _meta: {
-                        ...(((_b = notification.params) === null || _b === void 0 ? void 0 : _b._meta) || {}),
+                        ...(notification.params?._meta || {}),
                         [types_js_1.RELATED_TASK_META_KEY]: options.relatedTask
                     }
                 }
@@ -807,10 +798,10 @@ class Protocol {
             // This prevents duplicate delivery for bidirectional transports
             return;
         }
-        const debouncedMethods = (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.debouncedNotificationMethods) !== null && _d !== void 0 ? _d : [];
+        const debouncedMethods = this._options?.debouncedNotificationMethods ?? [];
         // A notification can only be debounced if it's in the list AND it's "simple"
         // (i.e., has no parameters and no related request ID or related task that could be lost).
-        const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId) && !(options === null || options === void 0 ? void 0 : options.relatedTask);
+        const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask;
         if (canDebounce) {
             // If a notification of this type is already scheduled, do nothing.
             if (this._pendingDebouncedNotifications.has(notification.method)) {
@@ -821,7 +812,6 @@ class Protocol {
             // Schedule the actual send to happen in the next microtask.
             // This allows all synchronous calls in the current event loop tick to be coalesced.
             Promise.resolve().then(() => {
-                var _a, _b;
                 // Un-mark the notification so the next one can be scheduled.
                 this._pendingDebouncedNotifications.delete(notification.method);
                 // SAFETY CHECK: If the connection was closed while this was pending, abort.
@@ -833,13 +823,13 @@ class Protocol {
                     jsonrpc: '2.0'
                 };
                 // Augment with related task metadata if relatedTask is provided
-                if (options === null || options === void 0 ? void 0 : options.relatedTask) {
+                if (options?.relatedTask) {
                     jsonrpcNotification = {
                         ...jsonrpcNotification,
                         params: {
                             ...jsonrpcNotification.params,
                             _meta: {
-                                ...(((_a = jsonrpcNotification.params) === null || _a === void 0 ? void 0 : _a._meta) || {}),
+                                ...(jsonrpcNotification.params?._meta || {}),
                                 [types_js_1.RELATED_TASK_META_KEY]: options.relatedTask
                             }
                         }
@@ -847,7 +837,7 @@ class Protocol {
                 }
                 // Send the notification, but don't await it here to avoid blocking.
                 // Handle potential errors with a .catch().
-                (_b = this._transport) === null || _b === void 0 ? void 0 : _b.send(jsonrpcNotification, options).catch(error => this._onerror(error));
+                this._transport?.send(jsonrpcNotification, options).catch(error => this._onerror(error));
             });
             // Return immediately.
             return;
@@ -857,13 +847,13 @@ class Protocol {
             jsonrpc: '2.0'
         };
         // Augment with related task metadata if relatedTask is provided
-        if (options === null || options === void 0 ? void 0 : options.relatedTask) {
+        if (options?.relatedTask) {
             jsonrpcNotification = {
                 ...jsonrpcNotification,
                 params: {
                     ...jsonrpcNotification.params,
                     _meta: {
-                        ...(((_e = jsonrpcNotification.params) === null || _e === void 0 ? void 0 : _e._meta) || {}),
+                        ...(jsonrpcNotification.params?._meta || {}),
                         [types_js_1.RELATED_TASK_META_KEY]: options.relatedTask
                     }
                 }
@@ -939,12 +929,11 @@ class Protocol {
      * simply propagates the error.
      */
     async _enqueueTaskMessage(taskId, message, sessionId) {
-        var _a;
         // Task message queues are only used when taskStore is configured
         if (!this._taskStore || !this._taskMessageQueue) {
             throw new Error('Cannot enqueue task message: taskStore and taskMessageQueue are not configured');
         }
-        const maxQueueSize = (_a = this._options) === null || _a === void 0 ? void 0 : _a.maxTaskQueueSize;
+        const maxQueueSize = this._options?.maxTaskQueueSize;
         await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
     }
     /**
@@ -981,16 +970,15 @@ class Protocol {
      * @returns Promise that resolves when an update occurs or rejects if aborted
      */
     async _waitForTaskUpdate(taskId, signal) {
-        var _a, _b, _c;
         // Get the task's poll interval, falling back to default
-        let interval = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.defaultTaskPollInterval) !== null && _b !== void 0 ? _b : 1000;
+        let interval = this._options?.defaultTaskPollInterval ?? 1000;
         try {
-            const task = await ((_c = this._taskStore) === null || _c === void 0 ? void 0 : _c.getTask(taskId));
-            if (task === null || task === void 0 ? void 0 : task.pollInterval) {
+            const task = await this._taskStore?.getTask(taskId);
+            if (task?.pollInterval) {
                 interval = task.pollInterval;
             }
         }
-        catch (_d) {
+        catch {
             // Use default interval if task lookup fails
         }
         return new Promise((resolve, reject) => {