@mastra/client-js 1.39.0-alpha.1 → 1.39.0-alpha.13

package/dist/docs/references/reference-client-js-workflows.md

@@ -12,6 +12,19 @@ Retrieve a list of all available workflows:
 const workflows = await mastraClient.listWorkflows()
 ```
 
+## Getting workflow run counts
+
+Retrieve per-workflow counts of `running` and [`suspended`](https://mastra.ai/docs/workflows/suspend-and-resume) runs in a single request. The counts are computed on the server and keyed by the workflow's registry key, the key used when registering the workflow in the Mastra config, which can differ from the workflow's own `id`:
+
+```typescript
+const runCounts = await mastraClient.listWorkflowRunCounts()
+// { "cityWorkflow": { running: 2, suspended: 1 }, ... }
+```
+
+Returns: `Record<string, { running: number; suspended: number }>`
+
+The server may cache the counts for a few seconds between requests. Servers that predate this endpoint respond with `404 Not Found`. Handle the error when the client can talk to older deployments.
+
 ## Working with a specific workflow
 
 Get an instance of a specific workflow by its ID:
@@ -212,28 +225,28 @@ A workflow run result yields the following:
 
 **payload** (`object`): Contains currentStep (id, status, output, payload) and workflowState (status, steps record)
 
-## Stored workflows
+## Dynamic workflows
 
-> **Beta:** Stored workflows are in beta. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** Breaking changes may occur without a major version bump until the API is stable.
 
-Stored workflows are workflow definitions expressed as JSON. The server persists each definition and registers it as a runnable workflow. See [Stored workflows](https://mastra.ai/docs/workflows/stored-workflows) for the definition format.
+Dynamic workflows are workflow definitions expressed as JSON. The server persists each definition and registers it as a runnable workflow. See [Dynamic workflows](https://mastra.ai/docs/workflows/dynamic-workflows) for the definition format.
 
-### `listStoredWorkflows()`
+### `listDynamicWorkflows()`
 
-List stored workflow definitions, optionally filtered by `status` (`'active' | 'archived'`) and `authorId`:
+List dynamic workflow definitions, optionally filtered by `status` (`'active' | 'archived'`) and `authorId`:
 
 ```typescript
-const { definitions, total } = await mastraClient.listStoredWorkflows({
+const { definitions, total } = await mastraClient.listDynamicWorkflows({
   status: 'active',
 })
 ```
 
-### `upsertStoredWorkflow()`
+### `upsertDynamicWorkflow()`
 
-Create or replace a stored workflow definition. The server validates the definition, persists it, and live-registers it for execution:
+Create or replace a dynamic workflow definition. The server validates the definition, persists it, and live-registers it for execution:
 
 ```typescript
-const stored = await mastraClient.upsertStoredWorkflow({
+const stored = await mastraClient.upsertDynamicWorkflow({
   id: 'greeting-workflow',
   description: 'Returns a greeting for the supplied name',
   inputSchema: {
@@ -261,7 +274,7 @@ const stored = await mastraClient.upsertStoredWorkflow({
 When the root definition nests helper workflows that don't exist yet, pass them in the same request through `dependencies`. The server validates and registers the bundle as a unit and echoes the helper ids back as `dependencyIds`:
 
 ```typescript
-const stored = await mastraClient.upsertStoredWorkflow({
+const stored = await mastraClient.upsertDynamicWorkflow({
   id: 'root-workflow',
   // ...schemas and graph referencing 'helper-workflow'...
   dependencies: [helperDefinition],
@@ -270,33 +283,33 @@ const stored = await mastraClient.upsertStoredWorkflow({
 console.log(stored.dependencyIds) // ['helper-workflow']
 ```
 
-### `getStoredWorkflow()`
+### `getDynamicWorkflow()`
 
-Get a stored workflow instance for definition management. To execute a stored workflow, use `getWorkflow(id).createRun()` like any other workflow:
+Get a dynamic workflow instance for definition management. To execute a dynamic workflow, use `getWorkflow(id).createRun()` like any other workflow:
 
 ```typescript
-const storedWorkflow = mastraClient.getStoredWorkflow('greeting-workflow')
+const dynamicWorkflow = mastraClient.getDynamicWorkflow('greeting-workflow')
 ```
 
-### `storedWorkflow.details()`
+### `dynamicWorkflow.details()`
 
 Retrieve the persisted definition, including schemas, graph, status, and timestamps:
 
 ```typescript
-const definition = await storedWorkflow.details()
+const definition = await dynamicWorkflow.details()
 ```
 
-### `storedWorkflow.delete()`
+### `dynamicWorkflow.delete()`
 
 Delete the stored definition and unregister the live workflow:
 
 ```typescript
-await storedWorkflow.delete()
+await dynamicWorkflow.delete()
 ```
 
-### Executing a stored workflow
+### Executing a dynamic workflow
 
-Once registered, a stored workflow runs through the ordinary workflow API:
+Once registered, a dynamic workflow runs through the ordinary workflow API:
 
 ```typescript
 const workflow = mastraClient.getWorkflow('greeting-workflow')

package/dist/index.cjs

@@ -28,6 +28,7 @@ let _mastra_schema_compat_schema = require("@mastra/schema-compat/schema");
 let _mastra_core_request_context = require("@mastra/core/request-context");
 let _mastra_schema_compat_zod_to_json = require("@mastra/schema-compat/zod-to-json");
 let _mastra_core_a2a_client = require("@mastra/core/a2a/client");
+let _mastra_core_a2a_v1 = require("@mastra/core/a2a/v1");
 let canonicalize = require("canonicalize");
 canonicalize = __toESM(canonicalize, 1);
 let jose = require("jose");
@@ -3849,6 +3850,74 @@ var A2A = class extends BaseResource {
 		}));
 	}
 };
+/** Client for the A2A Protocol v1.0 wire format. */
+var A2AV1 = class extends BaseResource {
+	agentId;
+	constructor(options, agentId) {
+		super(options);
+		this.agentId = agentId;
+	}
+	async rpc(method, params) {
+		return unwrapA2AResult(await this.request(`/a2a/${this.agentId}`, {
+			method: "POST",
+			headers: { "A2A-Version": "1.0" },
+			body: {
+				jsonrpc: "2.0",
+				id: crypto.randomUUID(),
+				method,
+				params
+			}
+		}));
+	}
+	async getAgentCard() {
+		const card = await this.request(`/.well-known/${this.agentId}/agent-card.json`, { headers: { "A2A-Version": "1.0" } });
+		return _mastra_core_a2a_v1.AgentCard.fromJSON(card);
+	}
+	async sendMessage(params) {
+		const result = await this.rpc("message/send", _mastra_core_a2a_v1.SendMessageRequest.toJSON(params));
+		return _mastra_core_a2a_v1.SendMessageResponse.fromJSON(result);
+	}
+	async *sendMessageStream(params) {
+		const response = await this.request(`/a2a/${this.agentId}`, {
+			method: "POST",
+			headers: { "A2A-Version": "1.0" },
+			body: {
+				jsonrpc: "2.0",
+				id: crypto.randomUUID(),
+				method: "message/stream",
+				params: _mastra_core_a2a_v1.SendMessageRequest.toJSON(params)
+			},
+			stream: true
+		});
+		for await (const event of processA2AStream(await requireResponseBody(response, "message/stream"))) yield _mastra_core_a2a_v1.StreamResponse.fromJSON(event);
+	}
+	async getTask(params) {
+		const result = await this.rpc("tasks/get", _mastra_core_a2a_v1.GetTaskRequest.toJSON(params));
+		return _mastra_core_a2a_v1.Task.fromJSON(result);
+	}
+	async listTasks(params) {
+		const result = await this.rpc("tasks/list", _mastra_core_a2a_v1.ListTasksRequest.toJSON(params));
+		return _mastra_core_a2a_v1.ListTasksResponse.fromJSON(result);
+	}
+	async cancelTask(params) {
+		const result = await this.rpc("tasks/cancel", _mastra_core_a2a_v1.CancelTaskRequest.toJSON(params));
+		return _mastra_core_a2a_v1.Task.fromJSON(result);
+	}
+	async *resubscribeTask(params) {
+		const response = await this.request(`/a2a/${this.agentId}`, {
+			method: "POST",
+			headers: { "A2A-Version": "1.0" },
+			body: {
+				jsonrpc: "2.0",
+				id: crypto.randomUUID(),
+				method: "tasks/resubscribe",
+				params: _mastra_core_a2a_v1.SubscribeToTaskRequest.toJSON(params)
+			},
+			stream: true
+		});
+		for await (const event of processA2AStream(await requireResponseBody(response, "tasks/resubscribe"))) yield _mastra_core_a2a_v1.StreamResponse.fromJSON(event);
+	}
+};
 //#endregion
 //#region src/resources/mcp-tool.ts
 /**
@@ -4688,27 +4757,27 @@ var StoredAgent = class extends BaseResource {
 	}
 };
 //#endregion
-//#region src/resources/stored-workflow.ts
-/** Resource for interacting with a specific stored workflow definition. */
-var StoredWorkflow = class extends BaseResource {
-	storedWorkflowId;
-	constructor(options, storedWorkflowId) {
+//#region src/resources/dynamic-workflow.ts
+/** Resource for interacting with a specific dynamic workflow definition. */
+var DynamicWorkflow = class extends BaseResource {
+	dynamicWorkflowId;
+	constructor(options, dynamicWorkflowId) {
 		super(options);
-		this.storedWorkflowId = storedWorkflowId;
+		this.dynamicWorkflowId = dynamicWorkflowId;
 	}
 	/**
-	* Retrieves the full stored workflow definition (schemas, graph, status, metadata)
-	* @returns Promise containing the stored workflow definition
+	* Retrieves the full dynamic workflow definition (schemas, graph, status, metadata)
+	* @returns Promise containing the dynamic workflow definition
 	*/
 	details() {
-		return this.request(`/stored/workflows/${encodeURIComponent(this.storedWorkflowId)}`);
+		return this.request(`/stored/workflows/${encodeURIComponent(this.dynamicWorkflowId)}`);
 	}
 	/**
-	* Deletes the stored workflow definition and unregisters it from the server
+	* Deletes the dynamic workflow definition and unregisters it from the server
 	* @returns Promise containing the deletion result
 	*/
 	delete() {
-		return this.request(`/stored/workflows/${encodeURIComponent(this.storedWorkflowId)}`, { method: "DELETE" });
+		return this.request(`/stored/workflows/${encodeURIComponent(this.dynamicWorkflowId)}`, { method: "DELETE" });
 	}
 };
 //#endregion
@@ -6365,6 +6434,18 @@ var MastraClient = class extends BaseResource {
 		return this.request(`/workflows${queryString ? `?${queryString}` : ""}`);
 	}
 	/**
+	* Retrieves per-workflow counts of running and suspended (awaiting resume) runs
+	* @param requestContext - Optional request context to pass as query parameter
+	* @returns Promise containing map of workflow IDs to run counts
+	*/
+	listWorkflowRunCounts(requestContext) {
+		const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
+		const searchParams = new URLSearchParams();
+		if (requestContextParam) searchParams.set("requestContext", requestContextParam);
+		const queryString = searchParams.toString();
+		return this.request(`/workflows/run-counts${queryString ? `?${queryString}` : ""}`);
+	}
+	/**
 	* Gets a workflow instance by ID
 	* @param workflowId - ID of the workflow to retrieve
 	* @returns Workflow instance
@@ -6516,6 +6597,13 @@ var MastraClient = class extends BaseResource {
 		return new A2A(this.options, agentId);
 	}
 	/**
+	* Gets an A2A Protocol v1.0 client for an agent.
+	* @param agentId - ID of the agent to interact with
+	*/
+	getA2AV1(agentId) {
+		return new A2AV1(this.options, agentId);
+	}
+	/**
 	* Retrieves the working memory for a specific thread (optionally resource-scoped).
 	* @param agentId - ID of the agent.
 	* @param threadId - ID of the thread.
@@ -6827,11 +6915,11 @@ var MastraClient = class extends BaseResource {
 		return new StoredAgent(this.options, storedAgentId);
 	}
 	/**
-	* Lists stored workflow definitions, optionally filtered by status or author
+	* Lists dynamic workflow definitions, optionally filtered by status or author
 	* @param params - Optional filters: `status` ('active' | 'archived') and `authorId`
 	* @returns Promise containing the matching definitions and a total count
 	*/
-	listStoredWorkflows(params) {
+	listDynamicWorkflows(params) {
 		const searchParams = new URLSearchParams();
 		if (params?.status) searchParams.set("status", params.status);
 		if (params?.authorId) searchParams.set("authorId", params.authorId);
@@ -6839,26 +6927,26 @@ var MastraClient = class extends BaseResource {
 		return this.request(`/stored/workflows${queryString ? `?${queryString}` : ""}`);
 	}
 	/**
-	* Creates or replaces a stored workflow definition and live-registers it on the server.
+	* Creates or replaces a dynamic workflow definition and live-registers it on the server.
 	* Optional `dependencies` lets helper workflows referenced by the root definition be
 	* saved in the same request; their ids are echoed back as `dependencyIds`.
 	* @param params - The workflow definition (id, schemas, graph) plus optional helper dependencies
 	* @returns Promise containing the persisted definition and any dependency ids
 	*/
-	upsertStoredWorkflow(params) {
+	upsertDynamicWorkflow(params) {
 		return this.request("/stored/workflows", {
 			method: "POST",
 			body: params
 		});
 	}
 	/**
-	* Gets a stored workflow instance by ID for further operations (details, delete).
-	* To execute a stored workflow, use `getWorkflow(id).createRun()` like any other workflow.
-	* @param storedWorkflowId - ID of the stored workflow definition
-	* @returns StoredWorkflow instance
+	* Gets a dynamic workflow instance by ID for further operations (details, delete).
+	* To execute a dynamic workflow, use `getWorkflow(id).createRun()` like any other workflow.
+	* @param dynamicWorkflowId - ID of the dynamic workflow definition
+	* @returns DynamicWorkflow instance
 	*/
-	getStoredWorkflow(storedWorkflowId) {
-		return new StoredWorkflow(this.options, storedWorkflowId);
+	getDynamicWorkflow(dynamicWorkflowId) {
+		return new DynamicWorkflow(this.options, dynamicWorkflowId);
 	}
 	/**
 	* Lists all stored prompt blocks with optional pagination