@mastra/client-js 1.56.0 → 1.57.0-alpha.1

package/dist/docs/references/reference-observability-tracing-advanced-queries.md

@@ -10,8 +10,9 @@ Advanced trace queries select completed traces with a structured time range and
 | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | ------------------------------------------ |
 | Query traces     | List matching traces, paginate through them, and poll for new ones.                                                                                       | `queryTraces()`     | `POST /api/observability/traces/query`     |
 | Aggregate traces | Count matching traces and compute measures, such as error rate, latency percentiles, tokens, and cost, optionally grouped by dimensions and time buckets. | `aggregateTraces()` | `POST /api/observability/traces/aggregate` |
+| Aggregate spans  | Compute the same measures over individual spans, such as every agent run including nested ones, grouped by span dimensions.                               | `aggregateSpans()`  | `POST /api/observability/spans/aggregate`  |
 
-Both APIs accept the same [trace selection](#select-traces). The filters, operators, and limits on this page apply to each. Use the aggregate API to find the group that needs attention, such as an agent with a high error rate, then send the same predicate plus the group's dimensions to the query API to list the traces behind it. Each query result represents a trace. Use its `traceId` to [retrieve the full trace](https://mastra.ai/reference/client-js/observability).
+The trace APIs accept the same [trace selection](#select-traces). The filters, operators, and limits on this page apply to each. Use the aggregate API to find the group that needs attention, such as an agent with a high error rate, then send the same predicate plus the group's dimensions to the query API to list the traces behind it. Each query result represents a trace. Use its `traceId` to [retrieve the full trace](https://mastra.ai/reference/client-js/observability).
 
 The endpoints use the same authentication as other observability routes and require the `observability:read` permission. Every request requires a time range.
 
@@ -25,6 +26,7 @@ The configured observability store must support each API. Call `getObservability
 | -------------------------------- | -------------------------------------- | -------------------------------------------------------------------------------------- |
 | `traceQuery`                     | `trace-query`                          | `queryTraces()`                                                                        |
 | `traceAggregate`                 | `trace-aggregate`                      | `aggregateTraces()`                                                                    |
+| `spanAggregate`                  | `span-aggregate`                       | `aggregateSpans()`                                                                     |
 | `traceQueryRootDuration`         | `trace-query-root-duration`            | Trace-scope `durationMs` predicates                                                    |
 | `traceQueryTimeToFirstChunk`     | `trace-query-time-to-first-chunk`      | `timeToFirstChunkMs` predicates and results                                            |
 | `traceQueryTimeToFirstChunkSort` | `trace-query-time-to-first-chunk-sort` | `orderBy` on `timeToFirstChunkMs`                                                      |
@@ -34,7 +36,7 @@ The configured observability store must support each API. Call `getObservability
 | `traceQueryDiscovery`            | `trace-query-discovery`                | [Field and value discovery](#discover-fields-and-values)                               |
 | `traceQueryTenantScope`          | `trace-query-tenant-scope`             | [Trusted tenant scope](#trusted-tenant-scope)                                          |
 
-A missing `traceAggregate` value means the server doesn't support aggregation. Servers without the aggregate route return `404`, and stores without the feature return `501 TRACE_AGGREGATE_UNSUPPORTED`. Against a store without a sub-feature, a request that uses a gated field returns `501` before storage runs. Root span `name`, `spanType`, and `entityId` are the exception and return `422` with a `field_not_allowed` issue.
+A missing `traceAggregate` value means the server doesn't support aggregation. Servers without the aggregate route return `404`, and stores without the feature return `501 TRACE_AGGREGATE_UNSUPPORTED`. A missing `spanAggregate` value means the same for span aggregation, and stores without the feature return `501 SPAN_AGGREGATE_UNSUPPORTED`. Against a store without a sub-feature, a request that uses a gated field returns `501` before storage runs. Root span `name`, `spanType`, and `entityId` are the exception and return `422` with a `field_not_allowed` issue.
 
 ## Select traces
 
@@ -212,7 +214,7 @@ const selectedModel = {
         {
           op: 'eq',
           left: { path: 'model' },
-          right: { literal: 'claude-sonnet-4-6' },
+          right: { literal: 'claude-sonnet-5-5' },
         },
         { op: 'eq', left: { path: 'provider' }, right: { literal: 'anthropic' } },
       ],
@@ -700,14 +702,14 @@ Token and cost measures read the model usage metrics recorded for each trace, so
 
 A trace that recorded at least one usage metric is usage-bearing. `tokens.<kind>.sum` adds the tokens of a group's usage-bearing traces, and `tokens.<kind>.avg` divides that sum by the number of usage-bearing traces, not by `count`. Both are `null` when the group has no usage-bearing traces.
 
-Cost comes from estimated cost recorded on total input and total output token metrics. `cost.sum` adds the cost of traces with at least one priced metric, and `cost.avg` divides by the number of those traces. A metric whose pricing failed, including a partial cost, isn't priced.
+Cost comes from estimated cost recorded on total input and total output token metrics. `cost.sum` adds the cost of traces with at least one priced metric, and `cost.avg` divides by the number of those traces. A partly priced call, where Mastra could price some token types but not others, adds the cost of the priced token types. A metric with any other pricing failure adds no cost.
 
 When you request any `cost.*` measure, every row also includes a `cost` object:
 
-| Field      | Description                                                                                                                    |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------------ |
-| `coverage` | Fraction of usage-bearing traces whose usage was fully priced, from 0 to 1. `null` when the group has no usage-bearing traces. |
-| `unit`     | Cost unit of the priced metrics, such as `USD`. `'mixed'` when they use more than one unit, and `null` when none are priced.   |
+| Field      | Description                                                                                                                                                                                                                                             |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `coverage` | Fraction of usage-bearing traces whose usage was fully priced, from 0 to 1. A trace with a partly priced call isn't fully priced, so it lowers coverage even though its known cost is in `cost.sum`. `null` when the group has no usage-bearing traces. |
+| `unit`     | Cost unit of the priced metrics, such as `USD`. `'mixed'` when they use more than one unit, and `null` when none are priced.                                                                                                                            |
 
 `cost.sum` and `cost.avg` are `null` when the group has no priced traces or `unit` is `'mixed'`. A coverage below 1 means the cost understates the group's spend. The `cost` object isn't a measure, so `having` and `orderBy` can't reference it.
 
@@ -803,11 +805,90 @@ PostgreSQL and ClickHouse stop aggregations after the same `traceQueryTimeoutMs`
 | `501`  | The installed Core or configured observability store doesn't support aggregation or a requested field. Returns `TRACE_AGGREGATE_UNSUPPORTED`.                                                                                   |
 | `504`  | A PostgreSQL or ClickHouse aggregation exceeded its execution timeout. Returns `TRACE_QUERY_EXECUTION_TIMEOUT` without partial results.                                                                                         |
 
+## Aggregate spans
+
+Use `aggregateSpans()` or `POST /api/observability/spans/aggregate` to compute measures over individual spans instead of traces. Trace aggregation only sees each trace's root span, so an agent run nested inside a workflow isn't counted. Span aggregation counts every span that matches, at any depth.
+
+The request has the same shape as [`aggregateTraces()`](#aggregate-request-fields), with the same measures, `having`, `orderBy`, `interval`, limits, and errors. The differences are in which records are selected and which dimensions are available.
+
+### Aggregate spans with the client SDK
+
+This request counts agent runs by status per day, including nested runs:
+
+```typescript
+const { capabilities } = await mastraClient.getObservabilityCapabilities()
+
+if (capabilities.spanAggregate) {
+  const { rows } = await mastraClient.aggregateSpans({
+    timeRange: {
+      from: '2026-08-01T00:00:00.000Z',
+      to: '2026-08-08T00:00:00.000Z',
+    },
+    where: { op: 'eq', left: { path: 'spanType' }, right: { literal: 'agent_run' } },
+    groupBy: ['status'],
+    interval: '1d',
+    measures: ['count', 'duration.p95'],
+  })
+}
+```
+
+Send the same body to `POST /api/observability/spans/aggregate` to use HTTP directly.
+
+### Span selection
+
+Aggregation selects the spans that [`querySpans()`](https://mastra.ai/reference/client-js/observability) would return for the same `timeRange` and `where`:
+
+- `timeRange` bounds each span's `startedAt`, and can span up to 365 days.
+- `where` accepts the `querySpans()` fields and operators, such as `spanType`, `name`, `status`, `durationMs`, entity and parent/root entity fields, and context identifiers.
+- Only completed spans count. When a span was exported more than once, only its latest copy counts.
+
+`count` equals the number of spans `querySpans()` pages through for the same request. Buckets use each span's `startedAt`. `duration.*` measures read the span's own duration, and `errorCount` and `errorRate` read whether the span itself recorded an error.
+
+On ClickHouse, a request whose `where` limits `spanType` to agent, workflow, processor, or scorer runs, RAG ingestion, or tool calls reads the smaller branch table instead of every span. That path can differ from `querySpans()`:
+
+- Spans written before an upgrade from `@mastra/clickhouse` 1.4, 1.5, or 1.6 aren't in the branch table, so older windows can count fewer spans.
+- After ClickHouse merges the copies of a span exported more than once, the branch table keeps the copy written last, not the one that ended last. Counts don't change, but the `status` and duration of a retried span can.
+
+### Span dimensions
+
+| Dimension                                                                         | Notes                                                                                                               |
+| --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| `name`, `spanType`, `status`                                                      | The span's own name, type, and status. `status` is `error` when the span recorded an error and `success` otherwise. |
+| `entityType`, `entityId`, `entityName`                                            | The entity that produced the span.                                                                                  |
+| `parentEntityType`, `parentEntityName`, `rootEntityType`, `rootEntityName`        | The calling entity and the trace's root entity, such as the agent that made a model call.                           |
+| `environment`, `serviceName`, `executionSource`                                   | Deployment attributes recorded on the span.                                                                         |
+| `threadId`, `resourceId`, `userId`, `sessionId`, `organizationId`, `experimentId` | Context identifiers recorded on the span.                                                                           |
+
+`countDistinct.<field>` accepts these dimensions and `traceId`, so `countDistinct.traceId` counts the traces the selected spans belong to. Span aggregation can't group by `metadata.<key>`, identity fields such as `traceId`, `spanId`, or `runId`, or by model and provider.
+
+### Span tokens and cost
+
+Token and cost measures use the usage metrics recorded by each span, matched by `traceId` and `spanId`. The [trace token rules](#token-and-cost-measures) apply per span: metrics from `timeRange.from` on count, retried exports count once, and averages divide by usage-bearing spans.
+
+Usage isn't added up to parent spans. Model calls record usage on `model_generation` spans, so an `agent_run` span has no tokens of its own unless a model call under it wasn't exported. When a `model_generation` span isn't exported, its usage is recorded on the nearest exported ancestor instead. For token totals per agent, select `model_generation` spans and group by the calling agent:
+
+```typescript
+const tokensByAgent = await mastraClient.aggregateSpans({
+  timeRange: {
+    from: '2026-08-01T00:00:00.000Z',
+    to: '2026-08-08T00:00:00.000Z',
+  },
+  where: { op: 'eq', left: { path: 'spanType' }, right: { literal: 'model_generation' } },
+  groupBy: ['parentEntityName'],
+  measures: ['tokens.total.sum', 'cost.sum'],
+  orderBy: { field: 'cost.sum', direction: 'desc' },
+})
+```
+
+### List the spans behind a group
+
+Aggregation never returns span records. To inspect a group, send the same `timeRange` and `where` to `querySpans()`, and add the group's dimension values as `eq` conditions. For example, add `{ op: 'eq', left: { path: 'status' }, right: { literal: 'error' } }` to list the failed agent runs from the first example.
+
 ## Trusted tenant scope
 
-Hosts that serve more than one tenant supply a trusted scope outside the query document. The server reads the reserved `organizationId` request-context key, which only server-side authentication can set, and passes `{ organizationId }` to the planner. The scope is carried on the trusted plan and ANDed into every scan: current roots, related spans, the usage metrics read by token and cost measures, and both discovery routes. A related record from another tenant that shares a `traceId` never qualifies a trace.
+Hosts that serve more than one tenant supply a trusted scope outside the query document. The server reads the reserved `organizationId` request-context key, which only server-side authentication can set, and passes `{ organizationId }` to the planner. The scope is carried on the trusted plan and ANDed into every scan: current roots, related spans, the usage metrics read by token and cost measures, span aggregation, and both discovery routes. A related record from another tenant that shares a `traceId` never qualifies a trace.
 
-Hosts that call storage directly can pass a fuller scope to `planTraceQuery()`, `planTraceAggregate()`, `planTraceQueryObservedFields()`, and `planTraceQueryValues()`:
+Hosts that call storage directly can pass a fuller scope to `planTraceQuery()`, `planTraceAggregate()`, `planSpanAggregate()`, `planTraceQueryObservedFields()`, and `planTraceQueryValues()`:
 
 ```typescript
 const plan = planTraceQuery(parseTraceQueryRequest(request), {
@@ -938,7 +1019,7 @@ Both routes require `observability:read` and use the configured observability st
 
 ## Limitations
 
-Both APIs consider completed traces only and don't include running traces. Trace queries can't return custom projections, embedded evidence, or summaries, and numbered trace pages include a total count. Aggregation can't group by span fields, `traceId`, or `attributes.*`, compute numeric measures over metadata, paginate groups, or zero-fill empty buckets. The CLI doesn't expose a trace aggregation command, so use the SDK or the HTTP endpoint.
+The query and aggregate APIs consider completed traces and spans only, not running ones. Trace queries can't return custom projections, embedded evidence, or summaries, and numbered trace pages include a total count. Trace aggregation can't group by span fields other than the root span's `name`, `spanType`, and `entityId`, or by `traceId` or `attributes.*`. Aggregation can't compute numeric measures over metadata, paginate groups, or zero-fill empty buckets. Span aggregation can't group by `model` or `provider`, and it attributes tokens only to the span that recorded them. The CLI's `mastra api trace aggregate` covers trace aggregation, and `mastra api span query` and `mastra api span aggregate` cover span queries and span aggregation.
 
 ## Related
 

package/dist/index.cjs

@@ -1080,11 +1080,51 @@ function processClientTools(clientTools) {
 	}));
 }
 //#endregion
+//#region src/utils/sse-event-splitter.ts
+/** Split SSE events without rescanning or copying an unfinished event on each read. */
+function createSseEventSplitter() {
+	let parts = [];
+	let pendingNewline = false;
+	return (text, isFinal = false) => {
+		const events = [];
+		let start = 0;
+		if (text) {
+			if (pendingNewline) {
+				if (text.startsWith("\n")) {
+					events.push(parts.join(""));
+					parts = [];
+					start = 1;
+				} else parts.push("\n");
+				pendingNewline = false;
+			}
+			let separator;
+			while ((separator = text.indexOf("\n\n", start)) !== -1) {
+				parts.push(text.slice(start, separator));
+				events.push(parts.join(""));
+				parts = [];
+				start = separator + 2;
+			}
+			if (start < text.length) {
+				pendingNewline = text.endsWith("\n");
+				const end = pendingNewline ? text.length - 1 : text.length;
+				if (start < end) parts.push(text.slice(start, end));
+			}
+		}
+		if (isFinal) {
+			if (pendingNewline) parts.push("\n");
+			events.push(parts.join(""));
+			parts = [];
+			pendingNewline = false;
+		}
+		return events;
+	};
+}
+//#endregion
 //#region src/utils/process-mastra-stream.ts
 async function sharedProcessMastraStream({ stream, onChunk, signal }) {
 	const reader = stream.getReader();
 	const decoder = new TextDecoder();
-	let buffer = "";
+	const splitEvents = createSseEventSplitter();
 	const abort = () => void reader.cancel();
 	if (signal?.aborted) abort();
 	else signal?.addEventListener("abort", abort, { once: true });
@@ -1092,9 +1132,7 @@ async function sharedProcessMastraStream({ stream, onChunk, signal }) {
 		while (true) {
 			const { done, value } = await reader.read();
 			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split("\n\n");
-			buffer = lines.pop() || "";
+			const lines = splitEvents(decoder.decode(value, { stream: true }));
 			for (const line of lines) if (line.startsWith("data: ")) {
 				const data = line.slice(6);
 				if (data === "[DONE]") return;
@@ -1894,10 +1932,18 @@ var Agent = class extends BaseResource {
 		};
 		return streamResponse;
 	}
-	async abortThread(params) {
+	/** Stops execution of a run, including runs without a memory thread. */
+	async abortRun(runId, options) {
+		return this.request(`/agents/${this.agentId}/runs/${encodeURIComponent(runId)}/abort`, {
+			method: "POST",
+			signal: options?.signal
+		});
+	}
+	async abortThread(params, options) {
 		const { resourceId, threadId, clearPendingSignals, expectedRunId } = params;
 		return this.request(`/agents/${this.agentId}/threads/abort`, {
 			method: "POST",
+			signal: options?.signal,
 			body: {
 				resourceId,
 				threadId,
@@ -2631,10 +2677,11 @@ var Agent = class extends BaseResource {
 	}
 	/**
 	* Creates the consumer-facing stream for the streaming methods. Cancelling the
-	* returned stream (or aborting `externalSignal`) aborts the underlying request
-	* and stops any client-tool continuations.
+	* returned stream or the client-wide signal detaches the HTTP observer and
+	* stops any client-tool continuations. Per-call execution cancellation is
+	* handled separately by processStreamResponse.
 	*/
-	createCancellableStream(externalSignal) {
+	createCancellableStream() {
 		const abortController = new AbortController();
 		let readableController;
 		return {
@@ -2647,10 +2694,63 @@ var Agent = class extends BaseResource {
 				}
 			}),
 			controller: readableController,
-			signal: mergeAbortSignals(abortController.signal, externalSignal, this.options.abortSignal)
+			signal: mergeAbortSignals(abortController.signal, this.options.abortSignal)
 		};
 	}
 	async processStreamResponse(processedParams, controller, route = "stream", signal) {
+		const suppliedRunId = processedParams.runId;
+		processedParams = {
+			...processedParams,
+			runId: processedParams.runId ?? (0, _lukeed_uuid.v4)()
+		};
+		const callerSignal = processedParams.abortSignal;
+		callerSignal?.throwIfAborted();
+		const transportAbort = new AbortController();
+		const cancellationAbort = new AbortController();
+		const detachSignal = signal;
+		signal = mergeAbortSignals(detachSignal, transportAbort.signal);
+		let cancellationTimer;
+		const stopCancellation = () => cancellationAbort.abort();
+		const cancelExecution = () => {
+			cancellationTimer = setTimeout(() => cancellationAbort.abort(/* @__PURE__ */ new Error("Agent run cancellation was not acknowledged")), 1e4);
+			(async () => {
+				try {
+					while (true) {
+						cancellationAbort.signal.throwIfAborted();
+						if ((await this.abortRun(processedParams.runId, { signal: cancellationAbort.signal })).aborted) return;
+						await new Promise((resolve, reject) => {
+							const onAbort = () => {
+								clearTimeout(timer);
+								reject(cancellationAbort.signal.reason);
+							};
+							const timer = setTimeout(() => {
+								cancellationAbort.signal.removeEventListener("abort", onAbort);
+								resolve();
+							}, 100);
+							cancellationAbort.signal.addEventListener("abort", onAbort, { once: true });
+							if (cancellationAbort.signal.aborted) onAbort();
+						});
+					}
+				} catch (error) {
+					if (!cancellationAbort.signal.aborted && !(error instanceof Error && "status" in error && (error.status === 404 || error.status === 501))) try {
+						controller.error(error);
+					} catch {}
+				} finally {
+					clearTimeout(cancellationTimer);
+					transportAbort.abort(callerSignal?.reason);
+				}
+			})();
+		};
+		const cleanupCancellation = () => {
+			callerSignal?.removeEventListener("abort", cancelExecution);
+			detachSignal?.removeEventListener("abort", stopCancellation);
+			clearTimeout(cancellationTimer);
+			stopCancellation();
+		};
+		detachSignal?.addEventListener("abort", stopCancellation, { once: true });
+		if (detachSignal?.aborted) stopCancellation();
+		callerSignal?.addEventListener("abort", cancelExecution, { once: true });
+		if (callerSignal?.aborted) cancelExecution();
 		const { memory } = processedParams ?? {};
 		const { resource, thread } = memory ?? {};
 		const threadId = processedParams.threadId ?? (typeof thread === "string" ? thread : thread?.id);
@@ -2667,9 +2767,15 @@ var Agent = class extends BaseResource {
 			body: requestBody,
 			stream: true,
 			signal
+		}).catch((error) => {
+			cleanupCancellation();
+			throw error;
 		});
-		if (!response.body) throw new Error("No response body");
-		const isAborted = () => Boolean(signal?.aborted);
+		if (!response.body) {
+			cleanupCancellation();
+			throw new Error("No response body");
+		}
+		const isAborted = () => Boolean(signal?.aborted || callerSignal?.aborted);
 		const isAbortError = (error) => isAborted() || error?.name === "AbortError";
 		const safeClose = () => {
 			try {
@@ -2682,18 +2788,16 @@ var Agent = class extends BaseResource {
 		};
 		try {
 			let messages = [];
-			let streamRunId = processedParams.runId;
+			let streamRunId = suppliedRunId;
 			let finishedHistory;
 			let suspended = false;
 			const resumedToolCallIds = /* @__PURE__ */ new Set();
 			const releaseOpenStream = streamRunId ? this.trackOpenStream(streamRunId) : () => {};
 			const [streamForController, streamForProcessing] = response.body.tee();
 			const decoder = new TextDecoder();
-			let pendingText = "";
+			const splitEvents = createSseEventSplitter();
 			const enqueueReadableText = (text, isFinal = false) => {
-				pendingText += text;
-				const lines = pendingText.split("\n\n");
-				pendingText = isFinal ? "" : lines.pop() ?? "";
+				const lines = splitEvents(text, isFinal);
 				for (const line of lines) {
 					if (!line.startsWith("data: ") || !line.includes("\"type\":\"finish\"")) continue;
 					try {
@@ -2799,6 +2903,7 @@ var Agent = class extends BaseResource {
 										payload: {
 											toolCallId: toolCall.toolCallId,
 											toolName: toolCall.toolName,
+											args: toolCall.args,
 											result,
 											isError: false,
 											providerExecuted: false
@@ -2899,10 +3004,12 @@ var Agent = class extends BaseResource {
 				} catch {}
 				safeClose();
 			}).finally(() => {
+				cleanupCancellation();
 				signal?.removeEventListener("abort", onAbort);
 				releaseOpenStream();
 			});
 		} catch (error) {
+			cleanupCancellation();
 			if (!isAbortError(error)) console.error("Error processing stream response:", error);
 		}
 		return response;
@@ -3000,7 +3107,7 @@ var Agent = class extends BaseResource {
 			clientTools: processClientTools(params.clientToolsResolver?.() ?? params.clientTools),
 			structuredOutput
 		};
-		const { readable, controller: readableController, signal } = this.createCancellableStream(params.abortSignal);
+		const { readable, controller: readableController, signal } = this.createCancellableStream();
 		const response = await this.processStreamResponse(processedParams, readableController, "stream", signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
@@ -3031,7 +3138,7 @@ var Agent = class extends BaseResource {
 			clientTools: processClientTools(params.clientToolsResolver?.() ?? params.clientTools),
 			structuredOutput
 		};
-		const { readable, controller: readableController, signal } = this.createCancellableStream(params.abortSignal);
+		const { readable, controller: readableController, signal } = this.createCancellableStream();
 		const response = await this.processStreamResponse(processedParams, readableController, "stream-until-idle", signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
@@ -3075,7 +3182,7 @@ var Agent = class extends BaseResource {
 			requestContext: parseClientRequestContext(requestContext),
 			clientTools: processClientTools(executableClientTools)
 		};
-		const { readable, controller: readableController, signal } = this.createCancellableStream(params.abortSignal);
+		const { readable, controller: readableController, signal } = this.createCancellableStream();
 		const response = await this.processStreamResponse(processedParams, readableController, "approve-tool-call", signal).catch((error) => {
 			releaseHold({ force: true });
 			throw error;
@@ -3112,7 +3219,7 @@ var Agent = class extends BaseResource {
 			requestContext: parseClientRequestContext(requestContext),
 			clientTools: processClientTools(executableClientTools)
 		};
-		const { readable, controller: readableController, signal } = this.createCancellableStream(params.abortSignal);
+		const { readable, controller: readableController, signal } = this.createCancellableStream();
 		const response = await this.processStreamResponse(processedParams, readableController, "decline-tool-call", signal).catch((error) => {
 			releaseHold({ force: true });
 			throw error;
@@ -3188,7 +3295,7 @@ var Agent = class extends BaseResource {
 				schema: (0, _mastra_schema_compat_schema.standardSchemaToJSONSchema)((0, _mastra_schema_compat_schema.toStandardSchema)(options.structuredOutput.schema))
 			} : void 0
 		};
-		const { readable, controller: readableController, signal } = this.createCancellableStream(options.abortSignal);
+		const { readable, controller: readableController, signal } = this.createCancellableStream();
 		const response = await this.processStreamResponse(processedParams, readableController, "resume-stream", signal).catch((error) => {
 			releaseHold({ force: true });
 			throw error;
@@ -3257,7 +3364,7 @@ var Agent = class extends BaseResource {
 				schema: (0, _mastra_schema_compat_schema.standardSchemaToJSONSchema)((0, _mastra_schema_compat_schema.toStandardSchema)(options.structuredOutput.schema))
 			} : void 0
 		};
-		const { readable, controller: readableController, signal } = this.createCancellableStream(options.abortSignal);
+		const { readable, controller: readableController, signal } = this.createCancellableStream();
 		const response = await this.processStreamResponse(processedParams, readableController, "resume-stream-until-idle", signal).catch((error) => {
 			releaseHold({ force: true });
 			throw error;
@@ -5290,6 +5397,17 @@ var Observability = class extends BaseResource {
 			body: params
 		});
 	}
+	/**
+	* Groups and measures individual completed spans selected by a time range and optional span-query predicate.
+	* Token and cost measures count usage recorded on each span itself. Check `capabilities.spanAggregate` from
+	* `getObservabilityCapabilities()` first; servers without it return 404 or 501.
+	*/
+	aggregateSpans(params) {
+		return this.request("/observability/spans/aggregate", {
+			method: "POST",
+			body: params
+		});
+	}
 	/** Returns canonical and observed fields available to the advanced trace-query grammar. */
 	getTraceQueryFields(params, options) {
 		return this.request("/observability/traces/query/fields", {
@@ -8154,6 +8272,14 @@ var MastraClient = class extends BaseResource {
 	aggregateTraces(params) {
 		return this.observability.aggregateTraces(params);
 	}
+	/**
+	* Groups and measures individual completed spans selected by a time range and optional span-query predicate.
+	* Token and cost measures count usage recorded on each span itself. Check `capabilities.spanAggregate` from
+	* `getObservabilityCapabilities()` first; servers without it return 404 or 501.
+	*/
+	aggregateSpans(params) {
+		return this.observability.aggregateSpans(params);
+	}
 	/** Returns canonical and observed fields available to the advanced trace-query grammar. */
 	getTraceQueryFields(params, options) {
 		return this.observability.getTraceQueryFields(params, options);