@mastra/server 1.32.1-alpha.0 → 1.33.0-alpha.0

package/dist/{chunk-ALUAG74N.js → chunk-3KIFZFY7.js}

@@ -7,6 +7,10 @@ import { __export } from './chunk-PR4QN5HX.js';
 import { isDeepStrictEqual } from 'util';
 import { MastraA2AError } from '@mastra/core/a2a';
 import { z } from 'zod/v4';
+import { lookup } from 'dns/promises';
+import { request as request$1 } from 'http';
+import { request } from 'https';
+import { isIP } from 'net';
 
 // src/server/handlers/a2a.ts
 var a2a_exports = {};
@@ -15,8 +19,12 @@ __export(a2a_exports, {
   GET_AGENT_CARD_ROUTE: () => GET_AGENT_CARD_ROUTE,
   getAgentCardByIdHandler: () => getAgentCardByIdHandler,
   getAgentExecutionHandler: () => getAgentExecutionHandler,
+  handleDeleteTaskPushNotificationConfig: () => handleDeleteTaskPushNotificationConfig,
+  handleGetTaskPushNotificationConfig: () => handleGetTaskPushNotificationConfig,
+  handleListTaskPushNotificationConfig: () => handleListTaskPushNotificationConfig,
   handleMessageSend: () => handleMessageSend,
   handleMessageStream: () => handleMessageStream,
+  handleSetTaskPushNotificationConfig: () => handleSetTaskPushNotificationConfig,
   handleTaskCancel: () => handleTaskCancel,
   handleTaskGet: () => handleTaskGet,
   handleTaskResubscribe: () => handleTaskResubscribe
@@ -77,6 +85,231 @@ function convertToCoreMessagePart(part) {
       throw new Error("Data parts are not supported in core messages");
   }
 }
+var DEFAULT_PUSH_NOTIFICATION_TOKEN_HEADER = "X-A2A-Notification-Token";
+function isDisallowedHostname(hostname) {
+  const normalized = hostname.toLowerCase();
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".internal") || !normalized.includes(".");
+}
+function isDisallowedIpv4(address) {
+  const [first = -1, second = -1] = address.split(".").map(Number);
+  return first === 10 || first === 127 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168;
+}
+function isDisallowedIpv6(address) {
+  const normalized = address.toLowerCase();
+  return normalized === "::1" || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb") || normalized.startsWith("fc") || normalized.startsWith("fd");
+}
+function isDisallowedIpAddress(address) {
+  const version = isIP(address);
+  if (version === 4) {
+    return isDisallowedIpv4(address);
+  }
+  if (version === 6) {
+    return isDisallowedIpv6(address);
+  }
+  return false;
+}
+var DefaultPushNotificationSender = class {
+  constructor(pushNotificationStore, options = {}) {
+    this.pushNotificationStore = pushNotificationStore;
+    this.options = options;
+  }
+  pushNotificationStore;
+  options;
+  getStore() {
+    return this.pushNotificationStore;
+  }
+  async resolveValidatedDestination(rawUrl) {
+    const url = new URL(rawUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+      throw new Error(`Push notification URL must use http or https: ${url.protocol}`);
+    }
+    const hostname = url.hostname.toLowerCase();
+    if (this.options.allowedHosts && !this.options.allowedHosts.includes(hostname)) {
+      throw new Error(`Push notification host is not allowed: ${hostname}`);
+    }
+    if (isDisallowedHostname(hostname)) {
+      throw new Error(`Push notification URL must not target local or internal hosts: ${hostname}`);
+    }
+    if (isDisallowedIpAddress(hostname)) {
+      throw new Error(`Push notification URL must not target local or private IPs: ${hostname}`);
+    }
+    const resolvedAddresses = isIP(hostname) === 0 ? await (this.options.lookup ?? lookup)(hostname, { all: true, verbatim: true }) : [{ address: hostname, family: isIP(hostname) }];
+    if (resolvedAddresses.some((result) => isDisallowedIpAddress(result.address))) {
+      throw new Error(`Push notification URL resolved to a local or private IP: ${hostname}`);
+    }
+    const requestUrl = new URL(url.toString());
+    requestUrl.hostname = resolvedAddresses[0].address;
+    return {
+      originalUrl: url,
+      requestUrl,
+      hostHeader: url.host,
+      servername: isIP(hostname) === 0 ? hostname : void 0
+    };
+  }
+  async postTaskSnapshot({
+    requestUrl,
+    hostHeader,
+    servername,
+    headers,
+    body,
+    timeout
+  }) {
+    headers.set("host", hostHeader);
+    const signal = typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(timeout) : void 0;
+    if (this.options.fetch) {
+      return this.options.fetch(requestUrl.toString(), {
+        method: "POST",
+        headers,
+        body,
+        signal
+      });
+    }
+    const transport = requestUrl.protocol === "https:" ? request : request$1;
+    return await new Promise((resolve, reject) => {
+      const request = transport(
+        {
+          protocol: requestUrl.protocol,
+          hostname: requestUrl.hostname,
+          port: requestUrl.port || void 0,
+          path: `${requestUrl.pathname}${requestUrl.search}`,
+          method: "POST",
+          headers: Object.fromEntries(headers.entries()),
+          servername
+        },
+        (response) => {
+          response.resume();
+          response.on("end", () => {
+            resolve({
+              ok: !!response.statusCode && response.statusCode >= 200 && response.statusCode < 300,
+              status: response.statusCode ?? 0,
+              statusText: response.statusMessage ?? ""
+            });
+          });
+        }
+      );
+      request.on("error", reject);
+      if (signal) {
+        signal.addEventListener(
+          "abort",
+          () => {
+            request.destroy(signal.reason instanceof Error ? signal.reason : new Error("Push notification timed out"));
+          },
+          { once: true }
+        );
+      }
+      request.end(body);
+    });
+  }
+  async sendNotifications({
+    agentId,
+    task,
+    logger
+  }) {
+    const configs = this.pushNotificationStore.list({
+      agentId,
+      params: { id: task.id }
+    });
+    if (configs.length === 0) {
+      return;
+    }
+    await Promise.allSettled(
+      configs.map(async (config) => {
+        const headers = new Headers({
+          "content-type": "application/json"
+        });
+        if (config.pushNotificationConfig.token) {
+          headers.set(
+            this.options.tokenHeaderName ?? DEFAULT_PUSH_NOTIFICATION_TOKEN_HEADER,
+            config.pushNotificationConfig.token
+          );
+        }
+        const auth = config.pushNotificationConfig.authentication;
+        if (auth?.credentials) {
+          if (auth.schemes.includes("Bearer")) {
+            headers.set("authorization", `Bearer ${auth.credentials}`);
+          } else if (auth.schemes.includes("Basic")) {
+            headers.set("authorization", `Basic ${auth.credentials}`);
+          }
+        }
+        const { requestUrl, hostHeader, servername } = await this.resolveValidatedDestination(
+          config.pushNotificationConfig.url
+        );
+        const response = await this.postTaskSnapshot({
+          requestUrl,
+          hostHeader,
+          servername,
+          headers,
+          body: JSON.stringify(task),
+          timeout: this.options.timeout ?? 5e3
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Push notification failed with status ${response.status} ${response.statusText ?? ""}`.trim()
+          );
+        }
+      })
+    ).then((results) => {
+      for (const result of results) {
+        if (result.status === "rejected") {
+          logger?.error("Failed to deliver A2A push notification", result.reason);
+        }
+      }
+    });
+  }
+};
+
+// src/server/a2a/push-notification-store.ts
+function normalizeConfigId(taskId, configId) {
+  return configId || taskId;
+}
+var InMemoryPushNotificationStore = class {
+  store = /* @__PURE__ */ new Map();
+  getKey(agentId, taskId) {
+    return JSON.stringify([agentId, taskId]);
+  }
+  set({ agentId, config }) {
+    const key = this.getKey(agentId, config.taskId);
+    const configs = this.store.get(key) ?? /* @__PURE__ */ new Map();
+    const normalizedConfig = {
+      taskId: config.taskId,
+      pushNotificationConfig: {
+        ...config.pushNotificationConfig,
+        id: normalizeConfigId(config.taskId, config.pushNotificationConfig.id)
+      }
+    };
+    configs.set(normalizedConfig.pushNotificationConfig.id, structuredClone(normalizedConfig));
+    this.store.set(key, configs);
+    return structuredClone(normalizedConfig);
+  }
+  get({
+    agentId,
+    params
+  }) {
+    const key = this.getKey(agentId, params.id);
+    const configId = normalizeConfigId(params.id, params.pushNotificationConfigId);
+    const config = this.store.get(key)?.get(configId);
+    return config ? structuredClone(config) : null;
+  }
+  list({
+    agentId,
+    params
+  }) {
+    const key = this.getKey(agentId, params.id);
+    return Array.from(this.store.get(key)?.values() ?? []).map((config) => structuredClone(config));
+  }
+  delete({ agentId, params }) {
+    const key = this.getKey(agentId, params.id);
+    const configs = this.store.get(key);
+    if (!configs) {
+      return false;
+    }
+    const deleted = configs.delete(params.pushNotificationConfigId);
+    if (configs.size === 0) {
+      this.store.delete(key);
+    }
+    return deleted;
+  }
+};
 
 // src/server/a2a/tasks.ts
 function isTaskStatusUpdate(update) {
@@ -204,9 +437,27 @@ var messageSendParamsSchema = z.object({
     referenceTaskIds: z.array(z.string()).optional(),
     extensions: z.array(z.string()).optional(),
     metadata: z.record(z.string(), z.any()).optional()
-  })
+  }),
+  configuration: z.object({
+    acceptedOutputModes: z.array(z.string()).optional(),
+    blocking: z.boolean().optional(),
+    historyLength: z.number().optional(),
+    pushNotificationConfig: z.object({
+      url: z.string(),
+      id: z.string().optional(),
+      token: z.string().optional(),
+      authentication: z.object({
+        schemes: z.array(z.string()),
+        credentials: z.string().optional()
+      }).optional()
+    }).optional()
+  }).optional()
 });
-function createAgentCardDefaults() {
+var defaultPushNotificationStore = new InMemoryPushNotificationStore();
+var defaultPushNotificationSender = new DefaultPushNotificationSender(defaultPushNotificationStore);
+function createAgentCardDefaults({
+  pushNotifications = false
+} = {}) {
   return {
     protocolVersion: "0.3.0",
     additionalInterfaces: [],
@@ -215,7 +466,7 @@ function createAgentCardDefaults() {
     securitySchemes: {},
     capabilities: {
       streaming: true,
-      pushNotifications: false,
+      pushNotifications,
       stateTransitionHistory: false,
       extensions: []
     },
@@ -232,6 +483,7 @@ async function getAgentCardByIdHandler({
     url: "https://mastra.ai"
   },
   version = "1.0",
+  pushNotifications = false,
   requestContext
 }) {
   const agent = await getAgentFromSystem({ mastra, agentId });
@@ -242,7 +494,7 @@ async function getAgentCardByIdHandler({
     url: executionUrl,
     provider,
     version,
-    ...createAgentCardDefaults(),
+    ...createAgentCardDefaults({ pushNotifications }),
     // Convert agent tools to skills format for A2A protocol
     skills: Object.entries(tools).map(([toolId, tool]) => ({
       id: toolId,
@@ -338,6 +590,63 @@ function createDataArtifactUpdate({
     }
   };
 }
+function resolvePushNotificationPair({
+  pushNotificationStore,
+  pushNotificationSender
+}) {
+  if (pushNotificationSender) {
+    return {
+      pushNotificationStore: pushNotificationSender.getStore(),
+      pushNotificationSender
+    };
+  }
+  if (pushNotificationStore) {
+    return {
+      pushNotificationStore,
+      pushNotificationSender: new DefaultPushNotificationSender(pushNotificationStore)
+    };
+  }
+  return {
+    pushNotificationStore: defaultPushNotificationStore,
+    pushNotificationSender: defaultPushNotificationSender
+  };
+}
+function createTaskPushNotificationConfig(taskId, pushNotificationConfig) {
+  return {
+    taskId,
+    pushNotificationConfig: {
+      ...pushNotificationConfig,
+      id: pushNotificationConfig.id ?? taskId
+    }
+  };
+}
+function shouldSendPushNotification(previousTask, nextTask) {
+  const pushTriggerStates = ["completed", "failed", "canceled", "input-required"];
+  if (!pushTriggerStates.includes(nextTask.status.state)) {
+    return false;
+  }
+  return previousTask?.status.state !== nextTask.status.state;
+}
+async function saveTaskAndMaybeSendPushNotification({
+  taskStore,
+  pushNotificationSender,
+  previousTask,
+  nextTask,
+  agentId,
+  logger
+}) {
+  await taskStore.save({ agentId, data: nextTask });
+  if (!shouldSendPushNotification(previousTask, nextTask)) {
+    return;
+  }
+  void pushNotificationSender.sendNotifications({
+    agentId,
+    task: nextTask,
+    logger
+  }).catch((error) => {
+    logger?.error("Failed to schedule A2A push notification", error);
+  });
+}
 function extractFullStreamTextDelta(value) {
   if (typeof value !== "object" || value === null || !("type" in value)) {
     return null;
@@ -442,6 +751,8 @@ async function handleMessageSend({
   requestId,
   params,
   taskStore,
+  pushNotificationStore,
+  pushNotificationSender,
   agent,
   agentId,
   logger,
@@ -451,6 +762,13 @@ async function handleMessageSend({
   const { message, metadata } = params;
   const { contextId } = message;
   const taskId = message.taskId || crypto.randomUUID();
+  const {
+    pushNotificationStore: resolvedPushNotificationStore,
+    pushNotificationSender: resolvedPushNotificationSender
+  } = resolvePushNotificationPair({
+    pushNotificationStore,
+    pushNotificationSender
+  });
   let currentData = await loadOrCreateTask({
     taskId,
     taskStore,
@@ -459,7 +777,13 @@ async function handleMessageSend({
     contextId,
     metadata
   });
-  createTaskContext({
+  if (params.configuration?.pushNotificationConfig) {
+    resolvedPushNotificationStore.set({
+      agentId,
+      config: createTaskPushNotificationConfig(taskId, params.configuration.pushNotificationConfig)
+    });
+  }
+  const context = createTaskContext({
     task: currentData,
     userMessage: message,
     history: currentData.history || [],
@@ -494,7 +818,15 @@ async function handleMessageSend({
         finishReason: result.finishReason
       }
     };
-    await taskStore.save({ agentId, data: currentData });
+    await saveTaskAndMaybeSendPushNotification({
+      taskStore,
+      pushNotificationSender: resolvedPushNotificationSender,
+      previousTask: context.task,
+      nextTask: currentData,
+      agentId,
+      logger
+    });
+    context.task = currentData;
   } catch (handlerError) {
     const failureStatusUpdate = {
       state: "failed",
@@ -512,7 +844,14 @@ async function handleMessageSend({
     };
     currentData = applyUpdateToTask(currentData, failureStatusUpdate);
     try {
-      await taskStore.save({ agentId, data: currentData });
+      await saveTaskAndMaybeSendPushNotification({
+        taskStore,
+        pushNotificationSender: resolvedPushNotificationSender,
+        previousTask: context.task,
+        nextTask: currentData,
+        agentId,
+        logger
+      });
     } catch (saveError) {
       logger?.error(`Failed to save task ${currentData.id} after handler error:`, saveError?.message);
     }
@@ -532,10 +871,115 @@ async function handleTaskGet({
   }
   return createSuccessResponse(requestId, task);
 }
+async function loadTaskOrThrow({
+  taskStore,
+  agentId,
+  taskId
+}) {
+  const task = await taskStore.load({ agentId, taskId });
+  if (!task) {
+    throw MastraA2AError.taskNotFound(taskId);
+  }
+  return task;
+}
+async function handleSetTaskPushNotificationConfig({
+  requestId,
+  taskStore,
+  pushNotificationStore,
+  agentId,
+  params
+}) {
+  await loadTaskOrThrow({
+    taskStore,
+    agentId,
+    taskId: params.taskId
+  });
+  const { pushNotificationStore: resolvedPushNotificationStore } = resolvePushNotificationPair({
+    pushNotificationStore
+  });
+  const config = resolvedPushNotificationStore.set({
+    agentId,
+    config: createTaskPushNotificationConfig(params.taskId, params.pushNotificationConfig)
+  });
+  return createSuccessResponse(requestId, config);
+}
+async function handleGetTaskPushNotificationConfig({
+  requestId,
+  taskStore,
+  pushNotificationStore,
+  agentId,
+  params
+}) {
+  await loadTaskOrThrow({
+    taskStore,
+    agentId,
+    taskId: params.id
+  });
+  const { pushNotificationStore: resolvedPushNotificationStore } = resolvePushNotificationPair({
+    pushNotificationStore
+  });
+  const config = resolvedPushNotificationStore.get({
+    agentId,
+    params
+  });
+  if (!config) {
+    throw MastraA2AError.invalidParams(
+      `Push notification config not found: ${params.pushNotificationConfigId ?? params.id}`
+    );
+  }
+  return createSuccessResponse(requestId, config);
+}
+async function handleListTaskPushNotificationConfig({
+  requestId,
+  taskStore,
+  pushNotificationStore,
+  agentId,
+  params
+}) {
+  await loadTaskOrThrow({
+    taskStore,
+    agentId,
+    taskId: params.id
+  });
+  const { pushNotificationStore: resolvedPushNotificationStore } = resolvePushNotificationPair({
+    pushNotificationStore
+  });
+  const configs = resolvedPushNotificationStore.list({
+    agentId,
+    params
+  });
+  return createSuccessResponse(requestId, configs);
+}
+async function handleDeleteTaskPushNotificationConfig({
+  requestId,
+  taskStore,
+  pushNotificationStore,
+  agentId,
+  params
+}) {
+  await loadTaskOrThrow({
+    taskStore,
+    agentId,
+    taskId: params.id
+  });
+  const { pushNotificationStore: resolvedPushNotificationStore } = resolvePushNotificationPair({
+    pushNotificationStore
+  });
+  const deleted = resolvedPushNotificationStore.delete({
+    agentId,
+    params
+  });
+  if (!deleted) {
+    throw MastraA2AError.invalidParams(`Push notification config not found: ${params.pushNotificationConfigId}`);
+  }
+  return createSuccessResponse(requestId, null);
+}
 async function* handleMessageStream({
   requestId,
   params,
   taskStore,
+  pushNotificationStore,
+  pushNotificationSender,
   agent,
   agentId,
   logger,
@@ -545,6 +989,13 @@ async function* handleMessageStream({
   const { message, metadata } = params;
   const { contextId } = message;
   const taskId = message.taskId || crypto.randomUUID();
+  const {
+    pushNotificationStore: resolvedPushNotificationStore,
+    pushNotificationSender: resolvedPushNotificationSender
+  } = resolvePushNotificationPair({
+    pushNotificationStore,
+    pushNotificationSender
+  });
   let currentData = await loadOrCreateTask({
     taskId,
     taskStore,
@@ -553,6 +1004,12 @@ async function* handleMessageStream({
     contextId,
     metadata
   });
+  if (params.configuration?.pushNotificationConfig) {
+    resolvedPushNotificationStore.set({
+      agentId,
+      config: createTaskPushNotificationConfig(taskId, params.configuration.pushNotificationConfig)
+    });
+  }
   currentData = applyUpdateToTask(currentData, {
     state: "working",
     message: {
@@ -562,7 +1019,13 @@ async function* handleMessageStream({
       parts: [{ kind: "text", text: "Generating response..." }]
     }
   });
-  await taskStore.save({ agentId, data: currentData });
+  await saveTaskAndMaybeSendPushNotification({
+    taskStore,
+    pushNotificationSender: resolvedPushNotificationSender,
+    nextTask: currentData,
+    agentId,
+    logger
+  });
   yield createSuccessResponse(requestId, currentData);
   try {
     const resourceId = metadata?.resourceId ?? message.metadata?.resourceId ?? agentId;
@@ -589,7 +1052,13 @@ async function* handleMessageStream({
           lastChunk: false
         });
         currentData = applyUpdateToTask(currentData, textUpdate);
-        await taskStore.save({ agentId, data: currentData });
+        await saveTaskAndMaybeSendPushNotification({
+          taskStore,
+          pushNotificationSender: resolvedPushNotificationSender,
+          nextTask: currentData,
+          agentId,
+          logger
+        });
         yield createSuccessResponse(requestId, textUpdate);
         sawTextArtifact = true;
         pendingTextChunk = textDelta;
@@ -616,7 +1085,13 @@ async function* handleMessageStream({
         lastChunk: !structuredData
       });
       currentData = applyUpdateToTask(currentData, textUpdate);
-      await taskStore.save({ agentId, data: currentData });
+      await saveTaskAndMaybeSendPushNotification({
+        taskStore,
+        pushNotificationSender: resolvedPushNotificationSender,
+        nextTask: currentData,
+        agentId,
+        logger
+      });
       yield createSuccessResponse(requestId, textUpdate);
       sawTextArtifact = true;
       pendingTextChunk = void 0;
@@ -629,15 +1104,22 @@ async function* handleMessageStream({
         lastChunk: true
       });
       currentData = applyUpdateToTask(currentData, dataUpdate);
-      await taskStore.save({ agentId, data: currentData });
+      await saveTaskAndMaybeSendPushNotification({
+        taskStore,
+        pushNotificationSender: resolvedPushNotificationSender,
+        nextTask: currentData,
+        agentId,
+        logger
+      });
       yield createSuccessResponse(requestId, dataUpdate);
     }
-    currentData = applyUpdateToTask(currentData, {
+    const previousTask = currentData;
+    const completedTask = applyUpdateToTask(currentData, {
       state: "completed",
       message: void 0
     });
-    currentData.metadata = {
-      ...currentData.metadata,
+    completedTask.metadata = {
+      ...completedTask.metadata,
       execution: {
         toolCalls: await result.toolCalls,
         toolResults: await result.toolResults,
@@ -645,8 +1127,17 @@ async function* handleMessageStream({
         finishReason: await result.finishReason
       }
     };
-    await taskStore.save({ agentId, data: currentData });
+    currentData = completedTask;
+    await saveTaskAndMaybeSendPushNotification({
+      taskStore,
+      pushNotificationSender: resolvedPushNotificationSender,
+      previousTask,
+      nextTask: currentData,
+      agentId,
+      logger
+    });
   } catch (handlerError) {
+    const previousTask = currentData;
     currentData = applyUpdateToTask(currentData, {
       state: "failed",
       message: {
@@ -662,7 +1153,14 @@ async function* handleMessageStream({
       }
     });
     try {
-      await taskStore.save({ agentId, data: currentData });
+      await saveTaskAndMaybeSendPushNotification({
+        taskStore,
+        pushNotificationSender: resolvedPushNotificationSender,
+        previousTask,
+        nextTask: currentData,
+        agentId,
+        logger
+      });
     } catch (saveError) {
       logger?.error(`Failed to save task ${currentData.id} after handler error:`, saveError?.message);
     }
@@ -769,6 +1267,7 @@ function createA2ASSEResponse(payload) {
 async function handleTaskCancel({
   requestId,
   taskStore,
+  pushNotificationSender,
   agentId,
   taskId,
   logger
@@ -795,8 +1294,16 @@ async function handleTaskCancel({
       messageId: crypto.randomUUID()
     }
   };
+  const previousTask = data;
   data = applyUpdateToTask(data, cancelUpdate);
-  await taskStore.save({ agentId, data });
+  await saveTaskAndMaybeSendPushNotification({
+    taskStore,
+    pushNotificationSender: resolvePushNotificationPair({ pushNotificationSender }).pushNotificationSender,
+    previousTask,
+    nextTask: data,
+    agentId,
+    logger
+  });
   taskStore.activeCancellations.delete(taskId);
   return createSuccessResponse(requestId, data);
 }
@@ -808,10 +1315,19 @@ async function getAgentExecutionHandler({
   method,
   params,
   taskStore,
+  pushNotificationStore,
+  pushNotificationSender,
   logger,
   abortSignal
 }) {
   const agent = await getAgentFromSystem({ mastra, agentId });
+  const {
+    pushNotificationStore: resolvedPushNotificationStore,
+    pushNotificationSender: resolvedPushNotificationSender
+  } = resolvePushNotificationPair({
+    pushNotificationStore,
+    pushNotificationSender
+  });
   let taskId;
   try {
     taskId = getTaskIdFromParams(params);
@@ -821,8 +1337,11 @@ async function getAgentExecutionHandler({
           requestId,
           params,
           taskStore,
+          pushNotificationStore: resolvedPushNotificationStore,
+          pushNotificationSender: resolvedPushNotificationSender,
           agent,
           agentId,
+          logger,
           requestContext
         });
         return result;
@@ -832,8 +1351,11 @@ async function getAgentExecutionHandler({
           requestId,
           taskStore,
           params,
+          pushNotificationStore: resolvedPushNotificationStore,
+          pushNotificationSender: resolvedPushNotificationSender,
           agent,
           agentId,
+          logger,
           requestContext
         });
         return result;
@@ -851,8 +1373,10 @@ async function getAgentExecutionHandler({
         const result = await handleTaskCancel({
           requestId,
           taskStore,
+          pushNotificationSender: resolvedPushNotificationSender,
           agentId,
-          taskId: taskId || "No task ID provided"
+          taskId: taskId || "No task ID provided",
+          logger
         });
         return result;
       }
@@ -865,10 +1389,37 @@ async function getAgentExecutionHandler({
           abortSignal
         });
       case "tasks/pushNotificationConfig/set":
+        return await handleSetTaskPushNotificationConfig({
+          requestId,
+          taskStore,
+          pushNotificationStore: resolvedPushNotificationStore,
+          agentId,
+          params
+        });
       case "tasks/pushNotificationConfig/get":
+        return await handleGetTaskPushNotificationConfig({
+          requestId,
+          taskStore,
+          pushNotificationStore: resolvedPushNotificationStore,
+          agentId,
+          params
+        });
       case "tasks/pushNotificationConfig/list":
+        return await handleListTaskPushNotificationConfig({
+          requestId,
+          taskStore,
+          pushNotificationStore: resolvedPushNotificationStore,
+          agentId,
+          params
+        });
       case "tasks/pushNotificationConfig/delete":
-        throw MastraA2AError.pushNotificationNotSupported();
+        return await handleDeleteTaskPushNotificationConfig({
+          requestId,
+          taskStore,
+          pushNotificationStore: resolvedPushNotificationStore,
+          agentId,
+          params
+        });
       case "agent/getAuthenticatedExtendedCard":
         throw MastraA2AError.extendedAgentCardNotConfigured();
       default:
@@ -901,7 +1452,8 @@ var GET_AGENT_CARD_ROUTE = createRoute({
       mastra: ctx.mastra,
       requestContext: ctx.requestContext,
       agentId: ctx.agentId,
-      executionUrl
+      executionUrl,
+      pushNotifications: true
     });
   }
 });
@@ -936,6 +1488,6 @@ var AGENT_EXECUTION_ROUTE = createRoute({
   }
 });
 
-export { AGENT_EXECUTION_ROUTE, GET_AGENT_CARD_ROUTE, a2a_exports, getAgentCardByIdHandler, getAgentExecutionHandler, handleMessageSend, handleMessageStream, handleTaskCancel, handleTaskGet, handleTaskResubscribe };
-//# sourceMappingURL=chunk-ALUAG74N.js.map
-//# sourceMappingURL=chunk-ALUAG74N.js.map
+export { AGENT_EXECUTION_ROUTE, GET_AGENT_CARD_ROUTE, a2a_exports, getAgentCardByIdHandler, getAgentExecutionHandler, handleDeleteTaskPushNotificationConfig, handleGetTaskPushNotificationConfig, handleListTaskPushNotificationConfig, handleMessageSend, handleMessageStream, handleSetTaskPushNotificationConfig, handleTaskCancel, handleTaskGet, handleTaskResubscribe };
+//# sourceMappingURL=chunk-3KIFZFY7.js.map
+//# sourceMappingURL=chunk-3KIFZFY7.js.map