@mastra/client-js 0.10.6-alpha.4 → 0.10.6-alpha.6

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @mastra/client-js@0.10.6-alpha.4 build /home/runner/work/mastra/mastra/client-sdks/client-js
+> @mastra/client-js@0.10.6-alpha.6 build /home/runner/work/mastra/mastra/client-sdks/client-js
 > tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
@@ -9,11 +9,11 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 66.22 KB
-ESM ⚡️ Build success in 2601ms
-CJS dist/index.cjs 66.51 KB
-CJS ⚡️ Build success in 2613ms
+ESM dist/index.js 66.44 KB
+ESM ⚡️ Build success in 2290ms
+CJS dist/index.cjs 66.73 KB
+CJS ⚡️ Build success in 2290ms
 DTS Build start
-DTS ⚡️ Build success in 19250ms
+DTS ⚡️ Build success in 17954ms
 DTS dist/index.d.ts  39.17 KB
 DTS dist/index.d.cts 39.17 KB

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @mastra/client-js
 
+## 0.10.6-alpha.6
+
+### Patch Changes
+
+- c0d41f6: Fix streaming for agent tool calls
+
+## 0.10.6-alpha.5
+
+### Patch Changes
+
+- bee3fe4: Fix client side tool calling
+  - @mastra/core@0.10.7-alpha.5
+
 ## 0.10.6-alpha.4
 
 ### Patch Changes

package/dist/index.cjs

@@ -702,7 +702,7 @@ var Agent = class extends BaseResource {
     });
     streamResponse.processDataStream = async (options = {}) => {
       await uiUtils.processDataStream({
-        stream: readable,
+        stream: streamResponse.body,
         ...options
       });
     };
@@ -722,76 +722,77 @@ var Agent = class extends BaseResource {
     }
     try {
       let toolCalls = [];
-      let finishReasonToolCalls = false;
       let messages = [];
-      let hasProcessedToolCalls = false;
-      response.clone().body.pipeTo(writable, {
+      const [streamForWritable, streamForProcessing] = response.body.tee();
+      streamForWritable.pipeTo(writable, {
         preventClose: true
+      }).catch((error) => {
+        console.error("Error piping to writable stream:", error);
       });
-      await this.processChatResponse({
-        stream: response.clone().body,
+      this.processChatResponse({
+        stream: streamForProcessing,
         update: ({ message }) => {
           messages.push(message);
         },
-        onFinish: ({ finishReason, message }) => {
+        onFinish: async ({ finishReason, message }) => {
           if (finishReason === "tool-calls") {
-            finishReasonToolCalls = true;
             const toolCall = [...message?.parts ?? []].reverse().find((part) => part.type === "tool-invocation")?.toolInvocation;
             if (toolCall) {
               toolCalls.push(toolCall);
             }
+            for (const toolCall2 of toolCalls) {
+              const clientTool = processedParams.clientTools?.[toolCall2.toolName];
+              if (clientTool && clientTool.execute) {
+                const result = await clientTool.execute(
+                  {
+                    context: toolCall2?.args,
+                    runId: processedParams.runId,
+                    resourceId: processedParams.resourceId,
+                    threadId: processedParams.threadId,
+                    runtimeContext: processedParams.runtimeContext
+                  },
+                  {
+                    messages: response.messages,
+                    toolCallId: toolCall2?.toolCallId
+                  }
+                );
+                const lastMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
+                const toolInvocationPart = lastMessage?.parts?.find(
+                  (part) => part.type === "tool-invocation" && part.toolInvocation?.toolCallId === toolCall2.toolCallId
+                );
+                if (toolInvocationPart) {
+                  toolInvocationPart.toolInvocation = {
+                    ...toolInvocationPart.toolInvocation,
+                    state: "result",
+                    result
+                  };
+                }
+                const toolInvocation = lastMessage?.toolInvocations?.find(
+                  (toolInvocation2) => toolInvocation2.toolCallId === toolCall2.toolCallId
+                );
+                if (toolInvocation) {
+                  toolInvocation.state = "result";
+                  toolInvocation.result = result;
+                }
+                const originalMessages = processedParams.messages;
+                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
+                this.processStreamResponse(
+                  {
+                    ...processedParams,
+                    messages: [...messageArray, ...messages, lastMessage]
+                  },
+                  writable
+                );
+              }
+            }
+          } else {
+            setTimeout(() => {
+              writable.close();
+            }, 0);
           }
         },
         lastMessage: void 0
       });
-      if (finishReasonToolCalls && !hasProcessedToolCalls) {
-        hasProcessedToolCalls = true;
-        for (const toolCall of toolCalls) {
-          const clientTool = processedParams.clientTools?.[toolCall.toolName];
-          if (clientTool && clientTool.execute) {
-            const result = await clientTool.execute(
-              {
-                context: toolCall?.args,
-                runId: processedParams.runId,
-                resourceId: processedParams.resourceId,
-                threadId: processedParams.threadId,
-                runtimeContext: processedParams.runtimeContext
-              },
-              {
-                messages: response.messages,
-                toolCallId: toolCall?.toolCallId
-              }
-            );
-            const lastMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
-            const toolInvocationPart = lastMessage?.parts?.find(
-              (part) => part.type === "tool-invocation" && part.toolInvocation?.toolCallId === toolCall.toolCallId
-            );
-            if (toolInvocationPart) {
-              toolInvocationPart.toolInvocation = {
-                ...toolInvocationPart.toolInvocation,
-                state: "result",
-                result
-              };
-            }
-            const toolInvocation = lastMessage?.toolInvocations?.find(
-              (toolInvocation2) => toolInvocation2.toolCallId === toolCall.toolCallId
-            );
-            if (toolInvocation) {
-              toolInvocation.state = "result";
-              toolInvocation.result = result;
-            }
-            const originalMessages = processedParams.messages;
-            const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
-            this.processStreamResponse(
-              {
-                ...processedParams,
-                messages: [...messageArray, ...messages, lastMessage]
-              },
-              writable
-            );
-          }
-        }
-      }
     } catch (error) {
       console.error("Error processing stream response:", error);
     }

package/dist/index.js

@@ -696,7 +696,7 @@ var Agent = class extends BaseResource {
     });
     streamResponse.processDataStream = async (options = {}) => {
       await processDataStream({
-        stream: readable,
+        stream: streamResponse.body,
         ...options
       });
     };
@@ -716,76 +716,77 @@ var Agent = class extends BaseResource {
     }
     try {
       let toolCalls = [];
-      let finishReasonToolCalls = false;
       let messages = [];
-      let hasProcessedToolCalls = false;
-      response.clone().body.pipeTo(writable, {
+      const [streamForWritable, streamForProcessing] = response.body.tee();
+      streamForWritable.pipeTo(writable, {
         preventClose: true
+      }).catch((error) => {
+        console.error("Error piping to writable stream:", error);
       });
-      await this.processChatResponse({
-        stream: response.clone().body,
+      this.processChatResponse({
+        stream: streamForProcessing,
         update: ({ message }) => {
           messages.push(message);
         },
-        onFinish: ({ finishReason, message }) => {
+        onFinish: async ({ finishReason, message }) => {
           if (finishReason === "tool-calls") {
-            finishReasonToolCalls = true;
             const toolCall = [...message?.parts ?? []].reverse().find((part) => part.type === "tool-invocation")?.toolInvocation;
             if (toolCall) {
               toolCalls.push(toolCall);
             }
+            for (const toolCall2 of toolCalls) {
+              const clientTool = processedParams.clientTools?.[toolCall2.toolName];
+              if (clientTool && clientTool.execute) {
+                const result = await clientTool.execute(
+                  {
+                    context: toolCall2?.args,
+                    runId: processedParams.runId,
+                    resourceId: processedParams.resourceId,
+                    threadId: processedParams.threadId,
+                    runtimeContext: processedParams.runtimeContext
+                  },
+                  {
+                    messages: response.messages,
+                    toolCallId: toolCall2?.toolCallId
+                  }
+                );
+                const lastMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
+                const toolInvocationPart = lastMessage?.parts?.find(
+                  (part) => part.type === "tool-invocation" && part.toolInvocation?.toolCallId === toolCall2.toolCallId
+                );
+                if (toolInvocationPart) {
+                  toolInvocationPart.toolInvocation = {
+                    ...toolInvocationPart.toolInvocation,
+                    state: "result",
+                    result
+                  };
+                }
+                const toolInvocation = lastMessage?.toolInvocations?.find(
+                  (toolInvocation2) => toolInvocation2.toolCallId === toolCall2.toolCallId
+                );
+                if (toolInvocation) {
+                  toolInvocation.state = "result";
+                  toolInvocation.result = result;
+                }
+                const originalMessages = processedParams.messages;
+                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
+                this.processStreamResponse(
+                  {
+                    ...processedParams,
+                    messages: [...messageArray, ...messages, lastMessage]
+                  },
+                  writable
+                );
+              }
+            }
+          } else {
+            setTimeout(() => {
+              writable.close();
+            }, 0);
           }
         },
         lastMessage: void 0
       });
-      if (finishReasonToolCalls && !hasProcessedToolCalls) {
-        hasProcessedToolCalls = true;
-        for (const toolCall of toolCalls) {
-          const clientTool = processedParams.clientTools?.[toolCall.toolName];
-          if (clientTool && clientTool.execute) {
-            const result = await clientTool.execute(
-              {
-                context: toolCall?.args,
-                runId: processedParams.runId,
-                resourceId: processedParams.resourceId,
-                threadId: processedParams.threadId,
-                runtimeContext: processedParams.runtimeContext
-              },
-              {
-                messages: response.messages,
-                toolCallId: toolCall?.toolCallId
-              }
-            );
-            const lastMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
-            const toolInvocationPart = lastMessage?.parts?.find(
-              (part) => part.type === "tool-invocation" && part.toolInvocation?.toolCallId === toolCall.toolCallId
-            );
-            if (toolInvocationPart) {
-              toolInvocationPart.toolInvocation = {
-                ...toolInvocationPart.toolInvocation,
-                state: "result",
-                result
-              };
-            }
-            const toolInvocation = lastMessage?.toolInvocations?.find(
-              (toolInvocation2) => toolInvocation2.toolCallId === toolCall.toolCallId
-            );
-            if (toolInvocation) {
-              toolInvocation.state = "result";
-              toolInvocation.result = result;
-            }
-            const originalMessages = processedParams.messages;
-            const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
-            this.processStreamResponse(
-              {
-                ...processedParams,
-                messages: [...messageArray, ...messages, lastMessage]
-              },
-              writable
-            );
-          }
-        }
-      }
     } catch (error) {
       console.error("Error processing stream response:", error);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.10.6-alpha.4",
+  "version": "0.10.6-alpha.6",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -33,7 +33,7 @@
     "rxjs": "7.8.1",
     "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.5",
-    "@mastra/core": "0.10.7-alpha.4"
+    "@mastra/core": "0.10.7-alpha.5"
   },
   "peerDependencies": {
     "zod": "^3.0.0"

package/src/resources/agent.ts

@@ -574,7 +574,7 @@ export class Agent extends BaseResource {
     // Add the processDataStream method to the response
     streamResponse.processDataStream = async (options = {}) => {
       await processDataStream({
-        stream: readable as ReadableStream<Uint8Array>,
+        stream: streamResponse.body as ReadableStream<Uint8Array>,
         ...options,
       });
     };
@@ -604,90 +604,97 @@ export class Agent extends BaseResource {
       let messages: UIMessage[] = [];
       let hasProcessedToolCalls = false;
 
-      // If no tool calls or they've been processed, pipe the original response
-      response.clone().body!.pipeTo(writable, {
-        preventClose: true,
-      });
+      // Use tee() to split the stream into two branches
+      const [streamForWritable, streamForProcessing] = response.body.tee();
+
+      // Pipe one branch to the writable stream
+      streamForWritable
+        .pipeTo(writable, {
+          preventClose: true,
+        })
+        .catch(error => {
+          console.error('Error piping to writable stream:', error);
+        });
 
-      await this.processChatResponse({
-        stream: response.clone().body!,
+      // Process the other branch for chat response handling
+      this.processChatResponse({
+        stream: streamForProcessing,
         update: ({ message }) => {
           messages.push(message);
         },
-        onFinish: ({ finishReason, message }) => {
+        onFinish: async ({ finishReason, message }) => {
           if (finishReason === 'tool-calls') {
-            finishReasonToolCalls = true;
             const toolCall = [...(message?.parts ?? [])]
               .reverse()
               .find(part => part.type === 'tool-invocation')?.toolInvocation;
             if (toolCall) {
               toolCalls.push(toolCall);
             }
+
+            // Handle tool calls if needed
+            for (const toolCall of toolCalls) {
+              const clientTool = processedParams.clientTools?.[toolCall.toolName] as Tool;
+              if (clientTool && clientTool.execute) {
+                const result = await clientTool.execute(
+                  {
+                    context: toolCall?.args,
+                    runId: processedParams.runId,
+                    resourceId: processedParams.resourceId,
+                    threadId: processedParams.threadId,
+                    runtimeContext: processedParams.runtimeContext as RuntimeContext,
+                  },
+                  {
+                    messages: (response as unknown as { messages: CoreMessage[] }).messages,
+                    toolCallId: toolCall?.toolCallId,
+                  },
+                );
+
+                const lastMessage: UIMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
+
+                const toolInvocationPart = lastMessage?.parts?.find(
+                  part => part.type === 'tool-invocation' && part.toolInvocation?.toolCallId === toolCall.toolCallId,
+                ) as ToolInvocationUIPart | undefined;
+
+                if (toolInvocationPart) {
+                  toolInvocationPart.toolInvocation = {
+                    ...toolInvocationPart.toolInvocation,
+                    state: 'result',
+                    result,
+                  };
+                }
+
+                const toolInvocation = lastMessage?.toolInvocations?.find(
+                  toolInvocation => toolInvocation.toolCallId === toolCall.toolCallId,
+                ) as ToolInvocation | undefined;
+
+                if (toolInvocation) {
+                  toolInvocation.state = 'result';
+                  // @ts-ignore
+                  toolInvocation.result = result;
+                }
+
+                // Convert messages to the correct format for the recursive call
+                const originalMessages = processedParams.messages;
+                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
+
+                // Recursively call stream with updated messages
+                this.processStreamResponse(
+                  {
+                    ...processedParams,
+                    messages: [...messageArray, ...messages, lastMessage],
+                  },
+                  writable,
+                );
+              }
+            }
+          } else {
+            setTimeout(() => {
+              writable.close();
+            }, 0);
           }
         },
         lastMessage: undefined,
       });
-
-      // Handle tool calls if needed
-      if (finishReasonToolCalls && !hasProcessedToolCalls) {
-        hasProcessedToolCalls = true;
-
-        for (const toolCall of toolCalls) {
-          const clientTool = processedParams.clientTools?.[toolCall.toolName] as Tool;
-          if (clientTool && clientTool.execute) {
-            const result = await clientTool.execute(
-              {
-                context: toolCall?.args,
-                runId: processedParams.runId,
-                resourceId: processedParams.resourceId,
-                threadId: processedParams.threadId,
-                runtimeContext: processedParams.runtimeContext as RuntimeContext,
-              },
-              {
-                messages: (response as unknown as { messages: CoreMessage[] }).messages,
-                toolCallId: toolCall?.toolCallId,
-              },
-            );
-
-            const lastMessage: UIMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
-
-            const toolInvocationPart = lastMessage?.parts?.find(
-              part => part.type === 'tool-invocation' && part.toolInvocation?.toolCallId === toolCall.toolCallId,
-            ) as ToolInvocationUIPart | undefined;
-
-            if (toolInvocationPart) {
-              toolInvocationPart.toolInvocation = {
-                ...toolInvocationPart.toolInvocation,
-                state: 'result',
-                result,
-              };
-            }
-
-            const toolInvocation = lastMessage?.toolInvocations?.find(
-              toolInvocation => toolInvocation.toolCallId === toolCall.toolCallId,
-            ) as ToolInvocation | undefined;
-
-            if (toolInvocation) {
-              toolInvocation.state = 'result';
-              // @ts-ignore
-              toolInvocation.result = result;
-            }
-
-            // Convert messages to the correct format for the recursive call
-            const originalMessages = processedParams.messages;
-            const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
-
-            // Recursively call stream with updated messages
-            this.processStreamResponse(
-              {
-                ...processedParams,
-                messages: [...messageArray, ...messages, lastMessage],
-              },
-              writable,
-            );
-          }
-        }
-      }
     } catch (error) {
       console.error('Error processing stream response:', error);
     }