@mastra/client-js 1.18.0-alpha.9 → 1.18.1-alpha.0

package/dist/docs/references/docs-agents-signals.md

@@ -0,0 +1,151 @@
+# Signals
+
+> **Experimental:** Agent signals are experimental. The API may change in a future release.
+
+Signals are a way to interact with an agent through a thread. Instead of starting every interaction with `agent.stream()`, subscribe to a thread and send signals. Mastra either wakes the agent when the thread is idle or drops the signal into the running agent loop.
+
+Signals are a context engineering tool for guiding the agent in real time as the agent loop progresses. Use them to add system-generated content from external event sources, such as incoming email notifications, GitHub pull request comments, background task notifications, and similar events.
+
+## Quickstart
+
+Subscribe to the thread before sending signals. The subscription receives the active stream when the signal wakes the agent or enters a running loop.
+
+```typescript
+const subscription = await agent.subscribeToThread({
+  resourceId: 'user_123',
+  threadId: 'thread_456',
+})
+
+agent.sendSignal(
+  {
+    type: 'user-message',
+    contents: 'Compare that with the previous option.',
+  },
+  {
+    resourceId: 'user_123',
+    threadId: 'thread_456',
+  },
+)
+
+for await (const chunk of subscription.stream) {
+  console.log(chunk)
+}
+```
+
+When the thread has a running agent stream, the signal becomes new input inside that agent loop. When the thread is idle, Mastra starts a stream with the signal as the first input.
+
+## Control signal behavior
+
+By default, Mastra delivers signals to active runs and wakes idle threads. Use `ifActive.behavior` and `ifIdle.behavior` to change that behavior.
+
+```typescript
+const result = agent.sendSignal(
+  {
+    type: 'user-message',
+    contents: 'Store this for later, but do not wake the agent.',
+  },
+  {
+    resourceId: 'user_123',
+    threadId: 'thread_456',
+    ifIdle: {
+      behavior: 'persist',
+    },
+  },
+)
+
+await result.persisted
+```
+
+The behavior options are:
+
+- `ifActive.behavior: 'deliver'`: Add the signal to the running agent loop. This is the default.
+- `ifActive.behavior: 'persist'`: Save the signal to memory without adding it to the running loop.
+- `ifActive.behavior: 'discard'`: Ignore the signal while the thread is active.
+- `ifIdle.behavior: 'wake'`: Start a stream with the signal as the first input. This is the default.
+- `ifIdle.behavior: 'persist'`: Save the signal to memory without starting a stream.
+- `ifIdle.behavior: 'discard'`: Ignore the signal while the thread is idle.
+
+Pass `ifIdle.streamOptions` when the idle wake-up stream needs options such as model settings, tools, or runtime context. You do not need to repeat `memory.resource` or `memory.thread`; Mastra uses the top-level `resourceId` and `threadId` for the thread.
+
+```typescript
+agent.sendSignal(
+  {
+    type: 'user-message',
+    contents: 'Continue with the next step.',
+  },
+  {
+    resourceId: 'user_123',
+    threadId: 'thread_456',
+    ifIdle: {
+      behavior: 'wake',
+      streamOptions: {
+        maxSteps: 3,
+      },
+    },
+  },
+)
+```
+
+## Send external event context
+
+Use custom signal types for system-generated context. Non-user signal types are rendered as XML-style user-role context so they can appear inside conversation history without looking like assistant output.
+
+```typescript
+agent.sendSignal(
+  {
+    type: 'system-reminder',
+    contents: 'User X has left a new PR comment asking for a smaller API surface.',
+    attributes: {
+      type: 'github',
+      pr: '123',
+    },
+  },
+  {
+    resourceId: 'user_123',
+    threadId: 'thread_456',
+  },
+)
+```
+
+The model receives the custom signal as context like this:
+
+```xml
+<system-reminder type="github" pr="123">User X has left a new PR comment asking for a smaller API surface.</system-reminder>
+```
+
+Use XML-safe signal type names and attribute names. Signal type names and attribute names can contain letters, numbers, underscores, periods, and hyphens. They must start with a letter or underscore.
+
+## Use the client SDK
+
+The JavaScript client exposes the same thread signal APIs. Use `subscribeToThread()` before `sendSignal()` so the client can render the stream that wakes from, or receives, the signal.
+
+```typescript
+const agent = client.getAgent('supportAgent')
+
+const subscription = await agent.subscribeToThread({
+  resourceId: 'user_123',
+  threadId: 'thread_456',
+})
+
+await agent.sendSignal({
+  signal: {
+    type: 'user-message',
+    contents: 'Show the shorter version.',
+  },
+  resourceId: 'user_123',
+  threadId: 'thread_456',
+})
+
+await subscription.processDataStream({
+  onChunk: chunk => {
+    console.log(chunk)
+  },
+})
+```
+
+## Related
+
+- [`Agent.sendSignal()`](https://mastra.ai/reference/agents/agent)
+- [`Agent.subscribeToThread()`](https://mastra.ai/reference/agents/agent)
+- [`client.getAgent().sendSignal()`](https://mastra.ai/reference/client-js/agents)
+- [`client.getAgent().subscribeToThread()`](https://mastra.ai/reference/client-js/agents)

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

@@ -151,6 +151,95 @@ for await (const part of uiMessageStream) {
 }
 ```
 
+### `sendSignal()`
+
+Send a signal to an active agent run or memory thread. Use this with `subscribeToThread()` so the client can render the stream that wakes from, or receives, the signal.
+
+```typescript
+const agent = mastraClient.getAgent('support-agent')
+
+const result = await agent.sendSignal({
+  signal: {
+    type: 'user-message',
+    contents: 'Also consider the customer note I just added.',
+  },
+  resourceId: 'user-123',
+  threadId: 'thread-abc',
+})
+
+console.log(result.runId)
+```
+
+Use `ifActive.behavior` and `ifIdle.behavior` to control whether Mastra delivers, persists, discards, or wakes from a signal:
+
+```typescript
+await agent.sendSignal({
+  signal: { type: 'user-message', contents: 'Store this for later.' },
+  resourceId: 'user-123',
+  threadId: 'thread-abc',
+  ifIdle: {
+    behavior: 'persist',
+  },
+})
+```
+
+Pass `ifIdle.streamOptions` when the idle wake-up stream needs options such as model settings, tools, or runtime context:
+
+```typescript
+await agent.sendSignal({
+  signal: { type: 'user-message', contents: 'Start from this signal.' },
+  resourceId: 'user-123',
+  threadId: 'thread-abc',
+  ifIdle: {
+    behavior: 'wake',
+    streamOptions: {
+      maxSteps: 3,
+    },
+  },
+})
+```
+
+Returns `{ accepted: true, runId: string }`.
+
+**signal** (`{ type: 'user-message'; contents: MessageListInput } | { type: string; contents: string }`): \`user-message\` signals are treated as user input. Other signal types are converted to contextual XML before the next model call.
+
+**runId** (`string`): Run ID to target directly.
+
+**resourceId** (`string`): Resource ID for the memory thread. Use with \`threadId\` for thread-targeted signals.
+
+**threadId** (`string`): Thread ID to target. Use with \`resourceId\` for thread-targeted signals.
+
+**ifActive.behavior** (`'deliver' | 'persist' | 'discard'`): Controls what happens when the target thread is active. Defaults to \`deliver\`.
+
+**ifIdle.behavior** (`'wake' | 'persist' | 'discard'`): Controls what happens when the target thread is idle. Defaults to \`wake\`.
+
+**ifIdle.streamOptions** (`Omit<AgentExecutionOptions, 'messages'>`): Options for the stream that starts when \`ifIdle.behavior\` is \`wake\`.
+
+### `subscribeToThread()`
+
+Subscribe to raw stream chunks for a memory thread. Use this to render output from a thread that may be started or continued by `sendSignal()`.
+
+```typescript
+const agent = mastraClient.getAgent('support-agent')
+
+const subscription = await agent.subscribeToThread({
+  resourceId: 'user-123',
+  threadId: 'thread-abc',
+})
+
+await subscription.processDataStream({
+  onChunk: async chunk => {
+    console.log(chunk)
+  },
+})
+```
+
+`subscribeToThread()` returns the underlying `Response` plus a `processDataStream()` helper. The helper reads the subscription stream until the connection closes or the request is aborted.
+
+**resourceId** (`string`): Resource ID for the memory thread.
+
+**threadId** (`string`): Thread ID to subscribe to.
+
 ### `streamUntilIdle()`
 
 Stream a response and keep the stream open until every [background task](https://mastra.ai/docs/agents/background-tasks) dispatched during the run completes. The server re-enters the agentic loop on each task completion so the LLM can react to results in the same call. Requires background tasks to be [enabled on the Mastra instance](https://mastra.ai/reference/configuration) and a memory thread; otherwise the call falls through to a plain `stream()`.

package/dist/index.cjs

@@ -6,7 +6,7 @@ var error = require('@mastra/core/error');
 var schema = require('@mastra/schema-compat/schema');
 var requestContext = require('@mastra/core/request-context');
 var zodToJson = require('@mastra/schema-compat/zod-to-json');
-var a2a = require('@mastra/core/a2a');
+var client = require('@mastra/core/a2a/client');
 var canonicalize = require('canonicalize');
 var jose = require('jose');
 
@@ -135,11 +135,15 @@ function processClientTools(clientTools) {
 // src/utils/process-mastra-stream.ts
 async function sharedProcessMastraStream({
   stream,
-  onChunk
+  onChunk,
+  signal
 }) {
   const reader = stream.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
+  const abort = () => void reader.cancel();
+  if (signal?.aborted) abort();
+  else signal?.addEventListener("abort", abort, { once: true });
   try {
     while (true) {
       const { done, value } = await reader.read();
@@ -167,25 +171,30 @@ async function sharedProcessMastraStream({
       }
     }
   } finally {
+    signal?.removeEventListener("abort", abort);
     reader.releaseLock();
   }
 }
 async function processMastraNetworkStream({
   stream,
-  onChunk
+  onChunk,
+  signal
 }) {
   return sharedProcessMastraStream({
     stream,
-    onChunk
+    onChunk,
+    signal
   });
 }
 async function processMastraStream({
   stream,
-  onChunk
+  onChunk,
+  signal
 }) {
   return sharedProcessMastraStream({
     stream,
-    onChunk
+    onChunk,
+    signal
   });
 }
 
@@ -348,8 +357,6 @@ var AgentVoice = class extends BaseResource {
     this.version = version;
     this.agentId = agentId;
   }
-  agentId;
-  version;
   getQueryString(requestContext, delimiter = "?") {
     const searchParams = new URLSearchParams(requestContextQueryString(requestContext).slice(1));
     if (this.version) {
@@ -419,8 +426,6 @@ var Agent = class extends BaseResource {
     this.version = version;
     this.voice = new AgentVoice(options, this.agentId, this.version);
   }
-  agentId;
-  version;
   voice;
   getQueryString(requestContext, delimiter = "?") {
     const searchParams = new URLSearchParams(requestContextQueryString(requestContext).slice(1));
@@ -446,6 +451,38 @@ var Agent = class extends BaseResource {
       body: { instructions, comment }
     });
   }
+  /**
+   * @experimental Agent signals are experimental and may change in a future release.
+   */
+  sendSignal(params) {
+    return this.request(`/agents/${this.agentId}/signals`, {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * @experimental Agent signals are experimental and may change in a future release.
+   */
+  async subscribeToThread(params) {
+    const streamResponse = await this.request(`/agents/${this.agentId}/threads/subscribe`, {
+      method: "POST",
+      body: params,
+      stream: true
+    });
+    if (!streamResponse.body) {
+      throw new Error("No response body");
+    }
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraStream({
+        stream: streamResponse.body,
+        onChunk,
+        signal: this.options.abortSignal
+      });
+    };
+    return streamResponse;
+  }
   /**
    * Clones this agent to a new stored agent in the database
    * @param params - Clone parameters including optional newId, newName, metadata, authorId, and requestContext
@@ -1905,13 +1942,25 @@ var MemoryThread = class extends BaseResource {
     this.threadId = threadId;
     this.agentId = agentId;
   }
-  threadId;
-  agentId;
   /**
    * Builds the query string for agentId (if provided)
    */
-  getAgentIdQueryParam(prefix = "?") {
-    return this.agentId ? `${prefix}agentId=${this.agentId}` : "";
+  getAgentIdQueryParam(prefix = "?", overrideAgentId) {
+    const agentId = overrideAgentId ?? this.agentId;
+    return agentId ? `${prefix}agentId=${agentId}` : "";
+  }
+  /**
+   * Resolves the agentId to use for a write request. Prefers the per-call value, falls back
+   * to the constructor value, and throws if neither is set.
+   */
+  requireAgentId(perCallAgentId, methodName) {
+    const agentId = perCallAgentId ?? this.agentId;
+    if (!agentId) {
+      throw new Error(
+        `MemoryThread.${methodName}() requires an agentId. Pass it via getMemoryThread({ threadId, agentId }) or as a parameter to ${methodName}().`
+      );
+    }
+    return agentId;
   }
   /**
    * Retrieves the memory thread details
@@ -1925,25 +1974,30 @@ var MemoryThread = class extends BaseResource {
   }
   /**
    * Updates the memory thread properties
-   * @param params - Update parameters including title, metadata, and optional request context
+   * @param params - Update parameters including title, metadata, and optional request context.
+   *                 `agentId` is required by the server; pass it here if not supplied on the constructor.
    * @returns Promise containing updated thread details
    */
   update(params) {
-    const agentIdParam = this.getAgentIdQueryParam("?");
-    const contextParam = requestContextQueryString(params.requestContext, agentIdParam ? "&" : "?");
+    const agentId = this.requireAgentId(params.agentId, "update");
+    const { agentId: _omitAgentId, requestContext, ...body } = params;
+    const agentIdParam = `?agentId=${agentId}`;
+    const contextParam = requestContextQueryString(requestContext, "&");
     return this.request(`/memory/threads/${this.threadId}${agentIdParam}${contextParam}`, {
       method: "PATCH",
-      body: params
+      body
     });
   }
   /**
    * Deletes the memory thread
-   * @param requestContext - Optional request context to pass as query parameter
+   * @param opts - Optional `agentId` (required by the server when not supplied on the constructor)
+   *               and request context.
    * @returns Promise containing deletion result
    */
-  delete(requestContext) {
-    const agentIdParam = this.getAgentIdQueryParam("?");
-    const contextParam = requestContextQueryString(requestContext, agentIdParam ? "&" : "?");
+  delete(opts = {}) {
+    const agentId = this.requireAgentId(opts.agentId, "delete");
+    const agentIdParam = `?agentId=${agentId}`;
+    const contextParam = requestContextQueryString(opts.requestContext, "&");
     return this.request(`/memory/threads/${this.threadId}${agentIdParam}${contextParam}`, {
       method: "DELETE"
     });
@@ -1973,37 +2027,46 @@ var MemoryThread = class extends BaseResource {
    * Deletes one or more messages from the thread
    * @param messageIds - Can be a single message ID (string), array of message IDs,
    *                     message object with id property, or array of message objects
-   * @param requestContext - Optional request context to pass as query parameter
+   * @param opts - Optional `agentId` (required by the server when not supplied on the constructor)
+   *               and request context. For backwards compatibility a `RequestContext` may also be
+   *               passed directly as the second argument.
    * @returns Promise containing deletion result
    */
-  deleteMessages(messageIds, requestContext) {
-    const queryParams = {};
-    if (this.agentId) queryParams.agentId = this.agentId;
-    const query = new URLSearchParams(queryParams);
-    const queryString = query.toString();
-    return this.request(
-      `/memory/messages/delete${queryString ? `?${queryString}` : ""}${requestContextQueryString(requestContext, queryString ? "&" : "?")}`,
-      {
-        method: "POST",
-        body: { messageIds }
-      }
-    );
+  deleteMessages(messageIds, opts = {}) {
+    const { agentId: explicitAgentId, requestContext } = normalizeWriteOpts(opts);
+    const agentId = this.requireAgentId(explicitAgentId, "deleteMessages");
+    const queryString = `agentId=${agentId}`;
+    return this.request(`/memory/messages/delete?${queryString}${requestContextQueryString(requestContext, "&")}`, {
+      method: "POST",
+      body: { messageIds }
+    });
   }
   /**
    * Clones the thread with all its messages to a new thread
-   * @param params - Clone parameters including optional new thread ID, title, metadata, and message filters
+   * @param params - Clone parameters including optional new thread ID, title, metadata, and message filters.
+   *                 `agentId` is required by the server; pass it here if not supplied on the constructor.
    * @returns Promise containing the cloned thread and copied messages
    */
   clone(params = {}) {
-    const { requestContext, ...body } = params;
-    const agentIdParam = this.getAgentIdQueryParam("?");
-    const contextParam = requestContextQueryString(requestContext, agentIdParam ? "&" : "?");
+    const agentId = this.requireAgentId(params.agentId, "clone");
+    const { agentId: _omitAgentId, requestContext, ...body } = params;
+    const agentIdParam = `?agentId=${agentId}`;
+    const contextParam = requestContextQueryString(requestContext, "&");
     return this.request(`/memory/threads/${this.threadId}/clone${agentIdParam}${contextParam}`, {
       method: "POST",
       body
     });
   }
 };
+function normalizeWriteOpts(opts) {
+  if (!opts || typeof opts !== "object") return {};
+  if ("agentId" in opts || "requestContext" in opts) {
+    const o = opts;
+    return { agentId: o.agentId, requestContext: o.requestContext };
+  }
+  if (Object.keys(opts).length === 0) return {};
+  return { requestContext: opts };
+}
 
 // src/resources/vector.ts
 var Vector = class extends BaseResource {
@@ -2011,7 +2074,6 @@ var Vector = class extends BaseResource {
     super(options);
     this.vectorName = vectorName;
   }
-  vectorName;
   /**
    * Retrieves details about a specific vector index
    * @param indexName - Name of the index to get details for
@@ -2084,7 +2146,6 @@ var Tool = class extends BaseResource {
     super(options);
     this.toolId = toolId;
   }
-  toolId;
   /**
    * Retrieves details about the tool
    * @param requestContext - Optional request context to pass as query parameter
@@ -2120,7 +2181,6 @@ var Processor = class extends BaseResource {
     super(options);
     this.processorId = processorId;
   }
-  processorId;
   /**
    * Retrieves details about the processor
    * @param requestContext - Optional request context to pass as query parameter
@@ -2202,8 +2262,6 @@ var Run = class extends BaseResource {
     this.workflowId = workflowId;
     this.runId = runId;
   }
-  workflowId;
-  runId;
   /**
    * Creates a transform stream that parses RECORD_SEPARATOR-delimited JSON chunks
    */
@@ -2596,7 +2654,6 @@ var Workflow = class extends BaseResource {
     super(options);
     this.workflowId = workflowId;
   }
-  workflowId;
   /**
    * Retrieves details about the workflow
    * @param requestContext - Optional request context to pass as query parameter
@@ -2925,7 +2982,7 @@ async function verifyAgentCardSignatureIfPresent(agentCard, options) {
 function createA2AJsonRpcError(response) {
   const error = response.error;
   const message = error?.message ?? "Unknown A2A JSON-RPC error";
-  return typeof error?.code === "number" ? new a2a.MastraA2AError(error.code, message, error.data) : new MastraClientError(200, "OK", `A2A JSON-RPC error - ${message}`, error);
+  return typeof error?.code === "number" ? new client.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) {
@@ -2959,7 +3016,6 @@ var A2A = class extends BaseResource {
     super(options);
     this.agentId = agentId;
   }
-  agentId;
   /**
    * Get the agent card with metadata about the agent.
    * @param options - Optional Agent Card verification settings
@@ -3191,12 +3247,10 @@ var MCPTool = class extends BaseResource {
   execute(params) {
     const body = {};
     if (params.data !== void 0) body.data = params.data;
-    if (params.requestContext !== void 0) {
-      body.requestContext = params.requestContext;
-    }
+    if (params.requestContext !== void 0) body.requestContext = params.requestContext;
     return this.request(`/mcp/${encodeURIComponent(this.serverId)}/tools/${encodeURIComponent(this.toolId)}/execute`, {
       method: "POST",
-      body: Object.keys(body).length > 0 ? body : void 0
+      body
     });
   }
 };
@@ -3208,7 +3262,6 @@ var AgentBuilder = class extends BaseResource {
     super(options);
     this.actionId = actionId;
   }
-  actionId;
   // Helper function to transform workflow result to action result
   transformWorkflowResult(result) {
     if (result.status === "success") {
@@ -3395,13 +3448,14 @@ var AgentBuilder = class extends BaseResource {
    * This calls `/agent-builder/:actionId/stream`.
    */
   async stream(params, runId) {
-    const searchParams = new URLSearchParams();
-    if (runId) {
-      searchParams.set("runId", runId);
+    if (!runId) {
+      throw new Error("runId is required to stream an agent builder action");
     }
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", runId);
     const requestContext = parseClientRequestContext(params.requestContext);
     const { requestContext: _, ...actionParams } = params;
-    const url = `/agent-builder/${this.actionId}/stream${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+    const url = `/agent-builder/${this.actionId}/stream?${searchParams.toString()}`;
     const response = await this.request(url, {
       method: "POST",
       body: { ...actionParams, requestContext },
@@ -3935,7 +3989,6 @@ var StoredAgent = class extends BaseResource {
     super(options);
     this.storedAgentId = storedAgentId;
   }
-  storedAgentId;
   /**
    * Retrieves details about the stored agent
    * @param requestContext - Optional request context to pass as query parameter
@@ -4095,7 +4148,6 @@ var StoredPromptBlock = class extends BaseResource {
     super(options);
     this.storedPromptBlockId = storedPromptBlockId;
   }
-  storedPromptBlockId;
   /**
    * Retrieves details about the stored prompt block
    * @param requestContext - Optional request context to pass as query parameter
@@ -4255,7 +4307,6 @@ var StoredMCPClient = class extends BaseResource {
     super(options);
     this.storedMCPClientId = storedMCPClientId;
   }
-  storedMCPClientId;
   /**
    * Retrieves details about the stored MCP client
    * @param requestContext - Optional request context to pass as query parameter
@@ -4302,7 +4353,6 @@ var StoredScorer = class extends BaseResource {
     super(options);
     this.storedScorerId = storedScorerId;
   }
-  storedScorerId;
   /**
    * Retrieves details about the stored scorer definition
    * @param requestContext - Optional request context to pass as query parameter
@@ -4463,7 +4513,6 @@ var ToolProvider = class extends BaseResource {
     super(options);
     this.providerId = providerId;
   }
-  providerId;
   /**
    * Lists available toolkits from this provider
    * @returns Promise containing list of toolkits
@@ -4513,7 +4562,6 @@ var ProcessorProvider = class extends BaseResource {
     super(options);
     this.providerId = providerId;
   }
-  providerId;
   /**
    * Gets details about this processor provider and its available processors
    * @returns Promise containing provider info and processor list
@@ -4533,9 +4581,6 @@ var WorkspaceSkillResource = class extends BaseResource {
     this.basePath = `/workspaces/${encodeURIComponent(this.workspaceId)}/skills/${encodeURIComponent(this.skillName)}`;
     this.pathQuery = this.skillPath ? `?path=${encodeURIComponent(this.skillPath)}` : "";
   }
-  workspaceId;
-  skillName;
-  skillPath;
   basePath;
   pathQuery;
   /**
@@ -4755,7 +4800,6 @@ var StoredSkill = class extends BaseResource {
     super(options);
     this.storedSkillId = storedSkillId;
   }
-  storedSkillId;
   /**
    * Retrieves details about the stored skill
    * @param requestContext - Optional request context to pass as query parameter
@@ -4852,7 +4896,6 @@ var ResponsesStream = class {
   constructor(response) {
     this.response = response;
   }
-  response;
   asResponse() {
     return this.response;
   }
@@ -5112,13 +5155,13 @@ var MastraClient = class extends BaseResource {
     }
     return this.request(url);
   }
-  deleteThread(threadId, opts = {}) {
-    let url = "";
-    if (opts.agentId) {
-      url = `/memory/threads/${threadId}?agentId=${opts.agentId}${requestContextQueryString(opts.requestContext, "&")}`;
-    } else if (opts.networkId) {
-      url = `/memory/network/threads/${threadId}?networkId=${opts.networkId}${requestContextQueryString(opts.requestContext, "&")}`;
+  deleteThread(threadId, opts) {
+    if (!opts || !!opts.agentId === !!opts.networkId) {
+      throw new Error(
+        "MastraClient.deleteThread() requires exactly one of agentId or networkId. The server cannot resolve which memory store owns the thread without one, and passing both is ambiguous."
+      );
     }
+    const url = opts.agentId ? `/memory/threads/${threadId}?agentId=${opts.agentId}${requestContextQueryString(opts.requestContext, "&")}` : `/memory/network/threads/${threadId}?networkId=${opts.networkId}${requestContextQueryString(opts.requestContext, "&")}`;
     return this.request(url, { method: "DELETE" });
   }
   /**
@@ -5262,7 +5305,7 @@ var MastraClient = class extends BaseResource {
    * @returns Promise containing map of action IDs to action details
    */
   getAgentBuilderActions() {
-    return this.request("/agent-builder/");
+    return this.request("/agent-builder");
   }
   /**
    * Gets an agent builder instance for executing agent-builder workflows