@mastra/client-js 1.22.0-alpha.5 → 1.22.0-alpha.6

package/dist/index.js

@@ -857,173 +857,216 @@ var Agent = class extends BaseResource {
       throw new Error("No response body");
     }
     const agent = this;
+    streamResponse.abort = async () => (await agent.abortThread({ resourceId, threadId })).aborted;
+    let unsubscribed = false;
+    let processAbortController;
+    let processStarted = false;
+    streamResponse.unsubscribe = () => {
+      if (unsubscribed) return;
+      unsubscribed = true;
+      processAbortController?.abort();
+      if (!processStarted) {
+        void streamResponse.body?.cancel().catch(() => {
+        });
+      }
+    };
     streamResponse.processDataStream = async ({ onChunk, reconnect }) => {
-      const pendingToolCallsByRunId = /* @__PURE__ */ new Map();
-      const handleSubscribedChunk = async (chunk) => {
-        if (chunk.type === "tool-call") {
-          const payload = chunk.payload;
-          const toolCallId = payload?.toolCallId;
-          const toolName = payload?.toolName;
-          const runId2 = chunk.runId;
-          if (!toolCallId || !toolName || !runId2) return;
-          const pendingToolCalls2 = pendingToolCallsByRunId.get(runId2) ?? [];
-          pendingToolCalls2.push({ toolCallId, toolName, args: payload.args, observability: payload.observability });
-          pendingToolCallsByRunId.set(runId2, pendingToolCalls2);
-          return;
-        }
-        if (chunk.type !== "finish") return;
-        const runId = chunk.runId;
-        const finishPayload = chunk;
-        if (!runId) return;
-        if (finishPayload.payload?.stepResult?.reason !== "tool-calls") {
-          agent.deleteSignalRuntimeOptions(runId);
-          return;
-        }
-        const pendingToolCalls = pendingToolCallsByRunId.get(runId);
-        pendingToolCallsByRunId.delete(runId);
-        if (!pendingToolCalls?.length) {
-          agent.deleteSignalRuntimeOptions(runId);
-          return;
-        }
-        const activeRuntimeOptions = agent.getSignalRuntimeOptions({ runId, resourceId, threadId });
-        const activeClientTools = activeRuntimeOptions?.clientTools;
-        if (!activeClientTools) {
-          agent.deleteSignalRuntimeOptions(runId);
-          return;
-        }
-        const activeRequestContext = activeRuntimeOptions.requestContext;
-        const processedClientTools = processClientTools(activeClientTools);
-        const processedRequestContext = parseClientRequestContext(activeRequestContext);
-        const toolResultMessages = [];
-        for (const toolCall of pendingToolCalls) {
-          const clientTool = activeClientTools[toolCall.toolName];
-          if (!clientTool || typeof clientTool.execute !== "function") continue;
-          let result;
-          let observability;
-          try {
-            const execution = await executeClientToolWithObservability({
-              clientTool,
-              args: toolCall.args,
-              toolName: toolCall.toolName,
-              parentContext: toolCall.observability,
-              executeContext: {
-                requestContext: activeRequestContext,
-                tracingContext: { currentSpan: void 0 },
-                agent: {
-                  agentId: agent.agentId,
-                  messages: finishPayload.payload?.messages?.nonUser ?? [],
-                  toolCallId: toolCall.toolCallId,
-                  suspend: async () => {
-                  },
-                  threadId,
-                  resourceId
-                }
-              }
-            });
-            result = execution.result;
-            observability = execution.observability;
-          } catch (error) {
-            result = { error: String(error) };
+      if (unsubscribed) return;
+      processStarted = true;
+      processAbortController = new AbortController();
+      const abortProcessStream = () => processAbortController?.abort();
+      const isClosed = () => unsubscribed || processAbortController?.signal.aborted || this.options.abortSignal?.aborted;
+      if (this.options.abortSignal?.aborted) {
+        abortProcessStream();
+      } else {
+        this.options.abortSignal?.addEventListener("abort", abortProcessStream, { once: true });
+      }
+      try {
+        const pendingToolCallsByRunId = /* @__PURE__ */ new Map();
+        const handleSubscribedChunk = async (chunk) => {
+          if (chunk.type === "tool-call") {
+            const payload = chunk.payload;
+            const toolCallId = payload?.toolCallId;
+            const toolName = payload?.toolName;
+            const runId2 = chunk.runId;
+            if (!toolCallId || !toolName || !runId2) return;
+            const pendingToolCalls2 = pendingToolCallsByRunId.get(runId2) ?? [];
+            pendingToolCalls2.push({ toolCallId, toolName, args: payload.args, observability: payload.observability });
+            pendingToolCallsByRunId.set(runId2, pendingToolCalls2);
+            return;
           }
-          const toolResultContent = {
-            type: "tool-result",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            result
-          };
-          if (observability) {
-            toolResultContent.__mastraObservability = observability;
+          if (chunk.type !== "finish") return;
+          const runId = chunk.runId;
+          const finishPayload = chunk;
+          if (!runId) return;
+          if (finishPayload.payload?.stepResult?.reason !== "tool-calls") {
+            agent.deleteSignalRuntimeOptions(runId);
+            return;
           }
-          await onChunk({
-            type: "tool-result",
-            runId,
-            payload: toolResultContent
-          });
-          toolResultMessages.push({
-            role: "tool",
-            content: [toolResultContent]
-          });
-        }
-        if (toolResultMessages.length === 0) {
-          agent.deleteSignalRuntimeOptions(runId);
-          return;
-        }
-        try {
-          const continuation = await agent.streamUntilIdle(
-            [...finishPayload.payload?.messages?.nonUser ?? [], ...toolResultMessages],
-            {
-              ...activeRuntimeOptions,
-              runId: v4(),
-              requestContext: processedRequestContext,
-              memory: threadId ? { thread: threadId, resource: resourceId } : void 0,
-              clientTools: processedClientTools
-            }
-          );
-          try {
-            void continuation.body?.cancel?.();
-          } catch {
+          const pendingToolCalls = pendingToolCallsByRunId.get(runId);
+          pendingToolCallsByRunId.delete(runId);
+          if (!pendingToolCalls?.length) {
+            agent.deleteSignalRuntimeOptions(runId);
+            return;
           }
-        } catch (error) {
-          console.error("Error running client-tool continuation:", error);
-        } finally {
-          agent.deleteSignalRuntimeOptions(runId);
-        }
-      };
-      const reconnectOptions = reconnect === true ? { maxRetries: Infinity, delayMs: 1e3 } : reconnect ? { maxRetries: reconnect.maxRetries ?? Infinity, delayMs: reconnect.delayMs ?? 1e3 } : null;
-      let response = streamResponse;
-      let attempts = 0;
-      const onChunkErrorSentinel = /* @__PURE__ */ Symbol("onChunkErrorSentinel");
-      const guardedOnChunk = async (chunk) => {
-        try {
-          await onChunk(chunk);
-          await handleSubscribedChunk(chunk);
-        } catch (cause) {
-          throw { [onChunkErrorSentinel]: true, cause };
-        }
-      };
-      while (true) {
-        if (!response.body) {
-          throw new Error("No response body");
-        }
-        try {
-          await processMastraStream({
-            stream: response.body,
-            onChunk: guardedOnChunk,
-            signal: this.options.abortSignal
-          });
-        } catch (error) {
-          if (typeof error === "object" && error !== null && error[onChunkErrorSentinel]) {
-            throw error.cause;
+          const activeRuntimeOptions = agent.getSignalRuntimeOptions({ runId, resourceId, threadId });
+          const activeClientTools = activeRuntimeOptions?.clientTools;
+          if (!activeClientTools) {
+            agent.deleteSignalRuntimeOptions(runId);
+            return;
           }
-          if (!reconnectOptions || this.options.abortSignal?.aborted || attempts >= reconnectOptions.maxRetries) {
-            throw error;
+          const activeRequestContext = activeRuntimeOptions.requestContext;
+          const processedClientTools = processClientTools(activeClientTools);
+          const processedRequestContext = parseClientRequestContext(activeRequestContext);
+          const toolResultMessages = [];
+          for (const toolCall of pendingToolCalls) {
+            const clientTool = activeClientTools[toolCall.toolName];
+            if (!clientTool || typeof clientTool.execute !== "function") continue;
+            let result;
+            let observability;
+            try {
+              const execution = await executeClientToolWithObservability({
+                clientTool,
+                args: toolCall.args,
+                toolName: toolCall.toolName,
+                parentContext: toolCall.observability,
+                executeContext: {
+                  requestContext: activeRequestContext,
+                  tracingContext: { currentSpan: void 0 },
+                  agent: {
+                    agentId: agent.agentId,
+                    messages: finishPayload.payload?.messages?.nonUser ?? [],
+                    toolCallId: toolCall.toolCallId,
+                    suspend: async () => {
+                    },
+                    threadId,
+                    resourceId
+                  }
+                }
+              });
+              result = execution.result;
+              observability = execution.observability;
+            } catch (error) {
+              result = { error: String(error) };
+            }
+            const toolResultContent = {
+              type: "tool-result",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              result
+            };
+            if (observability) {
+              toolResultContent.__mastraObservability = observability;
+            }
+            await onChunk({
+              type: "tool-result",
+              runId,
+              payload: toolResultContent
+            });
+            toolResultMessages.push({
+              role: "tool",
+              content: [toolResultContent]
+            });
           }
-        }
-        if (!reconnectOptions || this.options.abortSignal?.aborted || attempts >= reconnectOptions.maxRetries) {
-          return;
-        }
-        while (attempts < reconnectOptions.maxRetries) {
-          attempts++;
-          if (this.options.abortSignal?.aborted) {
+          if (toolResultMessages.length === 0) {
+            agent.deleteSignalRuntimeOptions(runId);
             return;
           }
-          await new Promise((resolve) => setTimeout(resolve, reconnectOptions.delayMs));
-          if (this.options.abortSignal?.aborted) {
-            return;
+          try {
+            const continuation = await agent.streamUntilIdle(
+              [...finishPayload.payload?.messages?.nonUser ?? [], ...toolResultMessages],
+              {
+                ...activeRuntimeOptions,
+                runId: v4(),
+                requestContext: processedRequestContext,
+                memory: threadId ? { thread: threadId, resource: resourceId } : void 0,
+                clientTools: processedClientTools
+              }
+            );
+            try {
+              void continuation.body?.cancel?.();
+            } catch {
+            }
+          } catch (error) {
+            console.error("Error running client-tool continuation:", error);
+          } finally {
+            agent.deleteSignalRuntimeOptions(runId);
           }
+        };
+        const reconnectOptions = reconnect === true ? { maxRetries: Infinity, delayMs: 1e3 } : reconnect ? { maxRetries: reconnect.maxRetries ?? Infinity, delayMs: reconnect.delayMs ?? 1e3 } : null;
+        let response = streamResponse;
+        let attempts = 0;
+        const onChunkErrorSentinel = /* @__PURE__ */ Symbol("onChunkErrorSentinel");
+        const guardedOnChunk = async (chunk) => {
           try {
-            response = await requestSubscription();
-            break;
+            await onChunk(chunk);
+            await handleSubscribedChunk(chunk);
+          } catch (cause) {
+            throw { [onChunkErrorSentinel]: true, cause };
+          }
+        };
+        while (true) {
+          if (!response.body) {
+            throw new Error("No response body");
+          }
+          try {
+            await processMastraStream({
+              stream: response.body,
+              onChunk: guardedOnChunk,
+              signal: processAbortController.signal
+            });
           } catch (error) {
-            if (this.options.abortSignal?.aborted || attempts >= reconnectOptions.maxRetries) {
+            if (typeof error === "object" && error !== null && error[onChunkErrorSentinel]) {
+              throw error.cause;
+            }
+            if (!reconnectOptions || isClosed() || attempts >= reconnectOptions.maxRetries) {
+              if (isClosed()) return;
               throw error;
             }
           }
+          if (!reconnectOptions || isClosed() || attempts >= reconnectOptions.maxRetries) {
+            return;
+          }
+          while (attempts < reconnectOptions.maxRetries) {
+            attempts++;
+            if (isClosed()) {
+              return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, reconnectOptions.delayMs));
+            if (isClosed()) {
+              return;
+            }
+            try {
+              response = await requestSubscription();
+              break;
+            } catch (error) {
+              if (isClosed() || attempts >= reconnectOptions.maxRetries) {
+                if (isClosed()) return;
+                throw error;
+              }
+            }
+          }
+        }
+      } finally {
+        this.options.abortSignal?.removeEventListener("abort", abortProcessStream);
+        if (processAbortController?.signal.aborted) {
+          unsubscribed = true;
         }
+        processAbortController = void 0;
       }
     };
     return streamResponse;
   }
+  /**
+   * @experimental Agent signals are experimental and may change in a future release.
+   */
+  async abortThread(params) {
+    const { resourceId, threadId } = params;
+    return this.request(`/agents/${this.agentId}/threads/abort`, {
+      method: "POST",
+      body: { resourceId, threadId }
+    });
+  }
   /**
    * Clones this agent to a new stored agent in the database
    * @param params - Clone parameters including optional newId, newName, metadata, authorId, and requestContext
@@ -2215,6 +2258,16 @@ var Agent = class extends BaseResource {
     };
     return streamResponse;
   }
+  async sendToolApproval(params) {
+    const { requestContext, ...rest } = params;
+    return this.request(
+      `/agents/${this.agentId}/send-tool-approval`,
+      {
+        method: "POST",
+        body: { ...rest, requestContext: parseClientRequestContext(requestContext) }
+      }
+    );
+  }
   async declineToolCall(params) {
     const { requestContext, ...rest } = params;
     const processedParams = { ...rest, requestContext: parseClientRequestContext(requestContext) };