@mastra/client-js 1.21.0-alpha.6 → 1.21.0-alpha.7

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/client-js
 
+## 1.21.0-alpha.7
+
+### Patch Changes
+
+- Fixed client-side tools getting stuck in `input-available` state in React's `useChat` messages. After a client tool finished executing, the React UI never observed a terminal `tool-result` (or `tool-error`) chunk for it, so the matching `dynamic-tool` part stayed at `state: 'input-available'` indefinitely. The client now emits a synthetic Mastra-shaped terminal chunk into the streamed response right after the client tool resolves or rejects, so the React reducer correctly flips the part to `output-available` (or `output-error`) and renders the tool result. ([#16916](https://github.com/mastra-ai/mastra/pull/16916))
+
+  Also fixed the client stream parser so final `tool-call` chunks are not treated as partial streaming tool calls while preparing client-tool continuation messages.
+
+- Updated dependencies [[`168fa09`](https://github.com/mastra-ai/mastra/commit/168fa09d6b39114cb8c13bd06f1dccb9bc81c6cd)]:
+  - @mastra/core@1.37.0-alpha.7
+
 ## 1.21.0-alpha.6
 
 ### Patch Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-client-js
 description: Documentation for @mastra/client-js. Use when working with @mastra/client-js APIs, configuration, or implementation.
 metadata:
   package: "@mastra/client-js"
-  version: "1.21.0-alpha.6"
+  version: "1.21.0-alpha.7"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.21.0-alpha.6",
+  "version": "1.21.0-alpha.7",
   "package": "@mastra/client-js",
   "exports": {
     "RequestContext": {

package/dist/index.cjs

@@ -1294,6 +1294,7 @@ var Agent = class extends BaseResource {
     update,
     onToolCall,
     onFinish,
+    onStreamChunk,
     getCurrentDate = () => /* @__PURE__ */ new Date(),
     lastMessage
   }) {
@@ -1361,6 +1362,7 @@ var Agent = class extends BaseResource {
       // TODO: casting as any here because the stream types were all typed as any before in core.
       // but this is completely wrong and this fn is probably broken. Remove ":any" and you'll see a bunch of type errors
       onChunk: async (chunk) => {
+        onStreamChunk?.(chunk);
         switch (chunk.type) {
           case "tripwire": {
             message.parts.push({
@@ -1462,6 +1464,7 @@ var Agent = class extends BaseResource {
                 execUpdate();
               }
             }
+            break;
           }
           case "tool-call-input-streaming-start": {
             if (message.toolInvocations == null) {
@@ -1578,6 +1581,7 @@ var Agent = class extends BaseResource {
     try {
       let toolCalls = [];
       let messages = [];
+      let streamRunId = processedParams.runId;
       const [streamForController, streamForProcessing] = response.body.tee();
       const pipePromise = streamForController.pipeTo(
         new WritableStream({
@@ -1631,25 +1635,76 @@ var Agent = class extends BaseResource {
               const clientTool = processedParams.clientTools?.[toolCall2.toolName];
               if (clientTool && clientTool.execute) {
                 shouldExecuteClientTool = true;
-                const { result, observability } = await executeClientToolWithObservability({
-                  clientTool,
-                  args: toolCall2?.args,
-                  toolName: toolCall2.toolName,
-                  parentContext: getClientToolObservabilityContext(toolCall2),
-                  executeContext: {
-                    requestContext: processedParams.requestContext,
-                    tracingContext: { currentSpan: void 0 },
-                    agent: {
-                      agentId: this.agentId,
-                      messages: response.messages,
-                      toolCallId: toolCall2?.toolCallId,
-                      suspend: async () => {
-                      },
-                      threadId,
-                      resourceId
+                const runId = streamRunId ?? toolCall2.toolCallId;
+                let result;
+                let observability;
+                let synthetic;
+                try {
+                  ({ result, observability } = await executeClientToolWithObservability({
+                    clientTool,
+                    args: toolCall2?.args,
+                    toolName: toolCall2.toolName,
+                    parentContext: getClientToolObservabilityContext(toolCall2),
+                    executeContext: {
+                      requestContext: processedParams.requestContext,
+                      tracingContext: { currentSpan: void 0 },
+                      agent: {
+                        agentId: this.agentId,
+                        messages: response.messages,
+                        toolCallId: toolCall2?.toolCallId,
+                        suspend: async () => {
+                        },
+                        threadId,
+                        resourceId
+                      }
                     }
-                  }
-                });
+                  }));
+                  synthetic = {
+                    type: "tool-result",
+                    runId,
+                    from: "AGENT",
+                    payload: {
+                      toolCallId: toolCall2.toolCallId,
+                      toolName: toolCall2.toolName,
+                      result,
+                      isError: false,
+                      providerExecuted: false
+                    }
+                  };
+                } catch (error) {
+                  synthetic = {
+                    type: "tool-error",
+                    runId,
+                    from: "AGENT",
+                    payload: {
+                      toolCallId: toolCall2.toolCallId,
+                      toolName: toolCall2.toolName,
+                      error,
+                      args: toolCall2?.args,
+                      providerExecuted: false
+                    }
+                  };
+                  result = { error: error instanceof Error ? error.message : String(error) };
+                }
+                try {
+                  await pipePromise;
+                } catch {
+                }
+                try {
+                  const errorForSerialization = synthetic.type === "tool-error" ? synthetic.payload.error : void 0;
+                  const serializedError = errorForSerialization instanceof Error ? {
+                    name: errorForSerialization.name,
+                    message: errorForSerialization.message,
+                    stack: errorForSerialization.stack
+                  } : errorForSerialization;
+                  const payloadForWire = synthetic.type === "tool-error" ? { ...synthetic, payload: { ...synthetic.payload, error: serializedError } } : synthetic;
+                  const sseLine = `data: ${JSON.stringify(payloadForWire)}
+
+`;
+                  controller.enqueue(new TextEncoder().encode(sseLine));
+                } catch (enqueueErr) {
+                  console.error("Failed to enqueue synthetic tool-result chunk:", enqueueErr);
+                }
                 const lastMessageRaw = messages[messages.length - 1];
                 const lastMessage = lastMessageRaw != null ? JSON.parse(JSON.stringify(lastMessageRaw)) : void 0;
                 const toolInvocationPart = lastMessage?.parts?.find(
@@ -1699,6 +1754,11 @@ var Agent = class extends BaseResource {
             controller.close();
           }
         },
+        onStreamChunk: (chunk) => {
+          if (!streamRunId && typeof chunk.runId === "string") {
+            streamRunId = chunk.runId;
+          }
+        },
         lastMessage: void 0
       }).catch(async (error) => {
         console.error("Error processing stream response:", error);