@mastra/server 1.32.1 → 1.33.0-alpha.0

package/dist/{chunk-3TFM333T.cjs → chunk-CJ2LC5EE.cjs}

@@ -9,6 +9,10 @@ var chunkO7I5CWRX_cjs = require('./chunk-O7I5CWRX.cjs');
 var util = require('util');
 var a2a = require('@mastra/core/a2a');
 var v4 = require('zod/v4');
+var promises = require('dns/promises');
+var http = require('http');
+var https = require('https');
+var net = require('net');
 
 // src/server/handlers/a2a.ts
 var a2a_exports = {};
@@ -17,8 +21,12 @@ chunkO7I5CWRX_cjs.__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
@@ -79,6 +87,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 = net.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 = net.isIP(hostname) === 0 ? await (this.options.lookup ?? promises.lookup)(hostname, { all: true, verbatim: true }) : [{ address: hostname, family: net.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: net.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:" ? https.request : http.request;
+    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) {
@@ -206,9 +439,27 @@ var messageSendParamsSchema = v4.z.object({
     referenceTaskIds: v4.z.array(v4.z.string()).optional(),
     extensions: v4.z.array(v4.z.string()).optional(),
     metadata: v4.z.record(v4.z.string(), v4.z.any()).optional()
-  })
+  }),
+  configuration: v4.z.object({
+    acceptedOutputModes: v4.z.array(v4.z.string()).optional(),
+    blocking: v4.z.boolean().optional(),
+    historyLength: v4.z.number().optional(),
+    pushNotificationConfig: v4.z.object({
+      url: v4.z.string(),
+      id: v4.z.string().optional(),
+      token: v4.z.string().optional(),
+      authentication: v4.z.object({
+        schemes: v4.z.array(v4.z.string()),
+        credentials: v4.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: [],
@@ -217,7 +468,7 @@ function createAgentCardDefaults() {
     securitySchemes: {},
     capabilities: {
       streaming: true,
-      pushNotifications: false,
+      pushNotifications,
       stateTransitionHistory: false,
       extensions: []
     },
@@ -234,6 +485,7 @@ async function getAgentCardByIdHandler({
     url: "https://mastra.ai"
   },
   version = "1.0",
+  pushNotifications = false,
   requestContext
 }) {
   const agent = await chunkWZKXMP2U_cjs.getAgentFromSystem({ mastra, agentId });
@@ -244,7 +496,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,
@@ -340,6 +592,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;
@@ -444,6 +753,8 @@ async function handleMessageSend({
   requestId,
   params,
   taskStore,
+  pushNotificationStore,
+  pushNotificationSender,
   agent,
   agentId,
   logger,
@@ -453,6 +764,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,
@@ -461,7 +779,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 || [],
@@ -496,7 +820,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",
@@ -514,7 +846,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);
     }
@@ -534,10 +873,115 @@ async function handleTaskGet({
   }
   return createSuccessResponse(requestId, task);
 }
+async function loadTaskOrThrow({
+  taskStore,
+  agentId,
+  taskId
+}) {
+  const task = await taskStore.load({ agentId, taskId });
+  if (!task) {
+    throw a2a.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 a2a.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 a2a.MastraA2AError.invalidParams(`Push notification config not found: ${params.pushNotificationConfigId}`);
+  }
+  return createSuccessResponse(requestId, null);
+}
 async function* handleMessageStream({
   requestId,
   params,
   taskStore,
+  pushNotificationStore,
+  pushNotificationSender,
   agent,
   agentId,
   logger,
@@ -547,6 +991,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,
@@ -555,6 +1006,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: {
@@ -564,7 +1021,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;
@@ -591,7 +1054,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;
@@ -618,7 +1087,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;
@@ -631,15 +1106,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,
@@ -647,8 +1129,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: {
@@ -664,7 +1155,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);
     }
@@ -771,6 +1269,7 @@ function createA2ASSEResponse(payload) {
 async function handleTaskCancel({
   requestId,
   taskStore,
+  pushNotificationSender,
   agentId,
   taskId,
   logger
@@ -797,8 +1296,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);
 }
@@ -810,10 +1317,19 @@ async function getAgentExecutionHandler({
   method,
   params,
   taskStore,
+  pushNotificationStore,
+  pushNotificationSender,
   logger,
   abortSignal
 }) {
   const agent = await chunkWZKXMP2U_cjs.getAgentFromSystem({ mastra, agentId });
+  const {
+    pushNotificationStore: resolvedPushNotificationStore,
+    pushNotificationSender: resolvedPushNotificationSender
+  } = resolvePushNotificationPair({
+    pushNotificationStore,
+    pushNotificationSender
+  });
   let taskId;
   try {
     taskId = getTaskIdFromParams(params);
@@ -823,8 +1339,11 @@ async function getAgentExecutionHandler({
           requestId,
           params,
           taskStore,
+          pushNotificationStore: resolvedPushNotificationStore,
+          pushNotificationSender: resolvedPushNotificationSender,
           agent,
           agentId,
+          logger,
           requestContext
         });
         return result;
@@ -834,8 +1353,11 @@ async function getAgentExecutionHandler({
           requestId,
           taskStore,
           params,
+          pushNotificationStore: resolvedPushNotificationStore,
+          pushNotificationSender: resolvedPushNotificationSender,
           agent,
           agentId,
+          logger,
           requestContext
         });
         return result;
@@ -853,8 +1375,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;
       }
@@ -867,10 +1391,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 a2a.MastraA2AError.pushNotificationNotSupported();
+        return await handleDeleteTaskPushNotificationConfig({
+          requestId,
+          taskStore,
+          pushNotificationStore: resolvedPushNotificationStore,
+          agentId,
+          params
+        });
       case "agent/getAuthenticatedExtendedCard":
         throw a2a.MastraA2AError.extendedAgentCardNotConfigured();
       default:
@@ -903,7 +1454,8 @@ var GET_AGENT_CARD_ROUTE = chunk7LAFXMXB_cjs.createRoute({
       mastra: ctx.mastra,
       requestContext: ctx.requestContext,
       agentId: ctx.agentId,
-      executionUrl
+      executionUrl,
+      pushNotifications: true
     });
   }
 });
@@ -943,10 +1495,14 @@ exports.GET_AGENT_CARD_ROUTE = GET_AGENT_CARD_ROUTE;
 exports.a2a_exports = a2a_exports;
 exports.getAgentCardByIdHandler = getAgentCardByIdHandler;
 exports.getAgentExecutionHandler = getAgentExecutionHandler;
+exports.handleDeleteTaskPushNotificationConfig = handleDeleteTaskPushNotificationConfig;
+exports.handleGetTaskPushNotificationConfig = handleGetTaskPushNotificationConfig;
+exports.handleListTaskPushNotificationConfig = handleListTaskPushNotificationConfig;
 exports.handleMessageSend = handleMessageSend;
 exports.handleMessageStream = handleMessageStream;
+exports.handleSetTaskPushNotificationConfig = handleSetTaskPushNotificationConfig;
 exports.handleTaskCancel = handleTaskCancel;
 exports.handleTaskGet = handleTaskGet;
 exports.handleTaskResubscribe = handleTaskResubscribe;
-//# sourceMappingURL=chunk-3TFM333T.cjs.map
-//# sourceMappingURL=chunk-3TFM333T.cjs.map
+//# sourceMappingURL=chunk-CJ2LC5EE.cjs.map
+//# sourceMappingURL=chunk-CJ2LC5EE.cjs.map