@mastra/client-js 1.15.0-alpha.5 → 1.15.0

package/dist/index.js

@@ -5,6 +5,7 @@ import { standardSchemaToJSONSchema, toStandardSchema } from '@mastra/schema-com
 import { RequestContext } from '@mastra/core/request-context';
 export { RequestContext } from '@mastra/core/request-context';
 import { zodToJsonSchema as zodToJsonSchema$1 } from '@mastra/schema-compat/zod-to-json';
+import { MastraA2AError } from '@mastra/core/a2a';
 
 // src/resources/agent.ts
 function normalizeRoutePath(path) {
@@ -2627,7 +2628,120 @@ var Workflow = class extends BaseResource {
   }
 };
 
+// src/utils/process-a2a-stream.ts
+function splitNextEvent(buffer) {
+  const normalizedBuffer = buffer.replace(/\x1E/g, "\n\n");
+  const match = normalizedBuffer.match(/\r?\n\r?\n/);
+  if (!match || match.index === void 0) {
+    return { rest: normalizedBuffer };
+  }
+  const separatorLength = match[0].length;
+  return {
+    eventBlock: normalizedBuffer.slice(0, match.index),
+    rest: normalizedBuffer.slice(match.index + separatorLength)
+  };
+}
+function parseEventBlock(eventBlock) {
+  const trimmedBlock = eventBlock.trim();
+  if (!trimmedBlock) {
+    return {};
+  }
+  const lines = trimmedBlock.split(/\r?\n/);
+  const dataLines = lines.filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart());
+  const payload = dataLines.length > 0 ? dataLines.join("\n") : trimmedBlock;
+  if (!payload || payload === "[DONE]") {
+    return { done: true };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse A2A stream event: ${error instanceof Error ? error.message : "unknown parse error"}`
+    );
+  }
+  if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error) {
+    throw new MastraClientError(200, "OK", `A2A stream error - ${JSON.stringify(parsed.error)}`, parsed.error);
+  }
+  if (parsed && typeof parsed === "object" && "result" in parsed) {
+    return { event: parsed.result };
+  }
+  return { event: parsed };
+}
+async function* processA2AStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        buffer += decoder.decode();
+      } else {
+        buffer += decoder.decode(value, { stream: true });
+      }
+      while (true) {
+        const { eventBlock, rest } = splitNextEvent(buffer);
+        buffer = rest;
+        if (!eventBlock) {
+          break;
+        }
+        const parsedEvent = parseEventBlock(eventBlock);
+        if (parsedEvent.done) {
+          return;
+        }
+        if (parsedEvent.event) {
+          yield parsedEvent.event;
+        }
+      }
+      if (done) {
+        break;
+      }
+    }
+    if (buffer.trim()) {
+      const parsedEvent = parseEventBlock(buffer);
+      if (!parsedEvent.done && parsedEvent.event) {
+        yield parsedEvent.event;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
 // src/resources/a2a.ts
+function createA2AJsonRpcError(response) {
+  const error = response.error;
+  const message = error?.message ?? "Unknown A2A JSON-RPC error";
+  return typeof error?.code === "number" ? new MastraA2AError(error.code, message, error.data) : new MastraClientError(200, "OK", `A2A JSON-RPC error - ${message}`, error);
+}
+function unwrapA2AResult(response) {
+  if ("error" in response && response.error) {
+    throw createA2AJsonRpcError(response);
+  }
+  if ("result" in response) {
+    return response.result;
+  }
+  throw new MastraClientError(200, "OK", "A2A JSON-RPC response did not include a result", response);
+}
+async function requireResponseBody(response, method) {
+  if (response.body) {
+    return response.body;
+  }
+  const headerSummary = Array.from(response.headers.entries()).map(([key, value]) => `${key}: ${value}`).join(", ");
+  let responseText = "";
+  try {
+    responseText = await response.text();
+  } catch {
+  }
+  const details = [
+    `A2A ${method} stream response did not include a body`,
+    `(status: ${response.status} ${response.statusText})`,
+    headerSummary ? `headers: ${headerSummary}` : "",
+    responseText ? `body: ${responseText}` : ""
+  ].filter(Boolean).join(" ");
+  throw new MastraClientError(response.status, response.statusText, details);
+}
 var A2A = class extends BaseResource {
   constructor(options, agentId) {
     super(options);
@@ -2635,19 +2749,41 @@ var A2A = class extends BaseResource {
   }
   agentId;
   /**
-   * Get the agent card with metadata about the agent
+   * Get the agent card with metadata about the agent.
    * @returns Promise containing the agent card information
    */
-  async getCard() {
+  async getAgentCard() {
     return this.request(`/.well-known/${this.agentId}/agent-card.json`);
   }
   /**
-   * Send a message to the agent and gets a message or task response
+   * @deprecated Use getAgentCard() instead.
+   */
+  async getCard() {
+    return this.getAgentCard();
+  }
+  /**
+   * Get the authenticated extended agent card.
+   * @returns Promise containing the authenticated extended agent card
+   */
+  async getExtendedAgentCard() {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "agent/getAuthenticatedExtendedCard"
+      }
+    });
+    return unwrapA2AResult(response);
+  }
+  /**
+   * @deprecated Use sendMessageStream() for the streaming experience.
+   * Send a message to the agent and gets a message or task response.
    * @param params - Parameters for the task
-   * @returns Promise containing the response
+   * @returns Promise containing the JSON-RPC response envelope
    */
   async sendMessage(params) {
-    const response = await this.request(`/a2a/${this.agentId}`, {
+    return this.request(`/a2a/${this.agentId}`, {
       method: "POST",
       body: {
         jsonrpc: "2.0",
@@ -2656,15 +2792,14 @@ var A2A = class extends BaseResource {
         params
       }
     });
-    return response;
   }
   /**
-   * Sends a message to an agent to initiate/continue a task and subscribes
+   * Sends a message to an agent to initiate or continue a task and subscribes
    * the client to real-time updates for that task via Server-Sent Events (SSE).
    * @param params - Parameters for the task
-   * @returns A stream of Server-Sent Events. Each SSE `data` field contains a `SendStreamingMessageResponse`
+   * @returns An async generator of typed A2A stream events
    */
-  async sendStreamingMessage(params) {
+  async *sendMessageStream(params) {
     const response = await this.request(`/a2a/${this.agentId}`, {
       method: "POST",
       body: {
@@ -2675,15 +2810,31 @@ var A2A = class extends BaseResource {
       },
       stream: true
     });
-    return response;
+    yield* processA2AStream(await requireResponseBody(response, "message/stream"));
   }
   /**
-   * Get the status and result of a task
+   * @deprecated Use sendMessageStream() instead.
+   */
+  async sendStreamingMessage(params) {
+    return this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "message/stream",
+        params
+      },
+      stream: true
+    });
+  }
+  /**
+   * @deprecated
+   * Get the status and result of a task.
    * @param params - Parameters for querying the task
-   * @returns Promise containing the task response
+   * @returns Promise containing the JSON-RPC response envelope
    */
   async getTask(params) {
-    const response = await this.request(`/a2a/${this.agentId}`, {
+    return this.request(`/a2a/${this.agentId}`, {
       method: "POST",
       body: {
         jsonrpc: "2.0",
@@ -2692,10 +2843,10 @@ var A2A = class extends BaseResource {
         params
       }
     });
-    return response;
   }
   /**
-   * Cancel a running task
+   * @deprecated
+   * Cancel a running task.
    * @param params - Parameters identifying the task to cancel
    * @returns Promise containing the task response
    */
@@ -2710,6 +2861,92 @@ var A2A = class extends BaseResource {
       }
     });
   }
+  /**
+   * Resume a task stream for an existing task.
+   * @param params - Parameters identifying the task to resubscribe to
+   * @returns An async generator of typed A2A stream events
+   */
+  async *resubscribeTask(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "tasks/resubscribe",
+        params
+      },
+      stream: true
+    });
+    yield* processA2AStream(await requireResponseBody(response, "tasks/resubscribe"));
+  }
+  /**
+   * Set push notification config for a task.
+   * @param params - Push notification configuration for the task
+   * @returns Promise containing the push notification configuration
+   */
+  async setTaskPushNotificationConfig(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "tasks/pushNotificationConfig/set",
+        params
+      }
+    });
+    return unwrapA2AResult(response);
+  }
+  /**
+   * Get push notification config for a task.
+   * @param params - Parameters identifying the task
+   * @returns Promise containing the push notification configuration
+   */
+  async getTaskPushNotificationConfig(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "tasks/pushNotificationConfig/get",
+        params
+      }
+    });
+    return unwrapA2AResult(response);
+  }
+  /**
+   * List push notification configs for a task.
+   * @param params - Parameters identifying the task
+   * @returns Promise containing the push notification configurations
+   */
+  async listTaskPushNotificationConfig(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "tasks/pushNotificationConfig/list",
+        params
+      }
+    });
+    return unwrapA2AResult(response);
+  }
+  /**
+   * Delete a push notification config for a task.
+   * @param params - Parameters identifying the config to delete
+   * @returns Promise that resolves when the config is deleted
+   */
+  async deleteTaskPushNotificationConfig(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        jsonrpc: "2.0",
+        id: crypto.randomUUID(),
+        method: "tasks/pushNotificationConfig/delete",
+        params
+      }
+    });
+    unwrapA2AResult(response);
+  }
 };
 
 // src/resources/mcp-tool.ts