@mastra/client-js 0.10.10 → 0.10.11-alpha.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @mastra/client-js@0.10.10-alpha.4 build /home/runner/work/mastra/mastra/client-sdks/client-js
+> @mastra/client-js@0.10.11-alpha.1 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 68.51 KB
-ESM ⚡️ Build success in 2252ms
-CJS dist/index.cjs 68.80 KB
-CJS ⚡️ Build success in 2266ms
+CJS dist/index.cjs 69.98 KB
+CJS ⚡️ Build success in 1503ms
+ESM dist/index.js 69.70 KB
+ESM ⚡️ Build success in 1504ms
 DTS Build start
-DTS ⚡️ Build success in 18063ms
-DTS dist/index.d.ts  40.65 KB
-DTS dist/index.d.cts 40.65 KB
+DTS ⚡️ Build success in 16685ms
+DTS dist/index.d.ts  40.80 KB
+DTS dist/index.d.cts 40.80 KB

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @mastra/client-js
 
+## 0.10.11-alpha.1
+
+### Patch Changes
+
+- Updated dependencies [4d5583d]
+  - @mastra/core@0.10.12-alpha.1
+
+## 0.10.11-alpha.0
+
+### Patch Changes
+
+- 9468be4: Fix error on agent generate while using antropic
+- 44731a4: Client SDK - Expose processTextStream util for agent textstream with structured output
+- Updated dependencies [b4a9811]
+  - @mastra/core@0.10.12-alpha.0
+
 ## 0.10.10
 
 ### Patch Changes

package/dist/index.cjs

@@ -382,7 +382,11 @@ var Agent = class extends BaseResource {
       body: processedParams
     });
     if (response.finishReason === "tool-calls") {
-      for (const toolCall of response.toolCalls) {
+      const toolCalls = response.toolCalls;
+      if (!toolCalls || !Array.isArray(toolCalls)) {
+        return response;
+      }
+      for (const toolCall of toolCalls) {
         const clientTool = params.clientTools?.[toolCall.toolName];
         if (clientTool && clientTool.execute) {
           const result = await clientTool.execute(
@@ -425,7 +429,8 @@ var Agent = class extends BaseResource {
     onToolCall,
     onFinish,
     getCurrentDate = () => /* @__PURE__ */ new Date(),
-    lastMessage
+    lastMessage,
+    streamProtocol
   }) {
     const replaceLastMessage = lastMessage?.role === "assistant";
     let step = replaceLastMessage ? 1 + // find max step in existing tool invocations:
@@ -486,228 +491,213 @@ var Agent = class extends BaseResource {
         replaceLastMessage
       });
     }
-    await uiUtils.processDataStream({
-      stream,
-      onTextPart(value) {
-        if (currentTextPart == null) {
-          currentTextPart = {
-            type: "text",
-            text: value
-          };
-          message.parts.push(currentTextPart);
-        } else {
-          currentTextPart.text += value;
+    if (streamProtocol === "text") {
+      await uiUtils.processTextStream({
+        stream,
+        onTextPart(value) {
+          message.content += value;
+          execUpdate();
         }
-        message.content += value;
-        execUpdate();
-      },
-      onReasoningPart(value) {
-        if (currentReasoningTextDetail == null) {
-          currentReasoningTextDetail = { type: "text", text: value };
-          if (currentReasoningPart != null) {
-            currentReasoningPart.details.push(currentReasoningTextDetail);
+      });
+      onFinish?.({ message, finishReason, usage });
+    } else {
+      await uiUtils.processDataStream({
+        stream,
+        onTextPart(value) {
+          if (currentTextPart == null) {
+            currentTextPart = {
+              type: "text",
+              text: value
+            };
+            message.parts.push(currentTextPart);
+          } else {
+            currentTextPart.text += value;
           }
-        } else {
-          currentReasoningTextDetail.text += value;
-        }
-        if (currentReasoningPart == null) {
-          currentReasoningPart = {
-            type: "reasoning",
-            reasoning: value,
-            details: [currentReasoningTextDetail]
-          };
-          message.parts.push(currentReasoningPart);
-        } else {
-          currentReasoningPart.reasoning += value;
-        }
-        message.reasoning = (message.reasoning ?? "") + value;
-        execUpdate();
-      },
-      onReasoningSignaturePart(value) {
-        if (currentReasoningTextDetail != null) {
-          currentReasoningTextDetail.signature = value.signature;
-        }
-      },
-      onRedactedReasoningPart(value) {
-        if (currentReasoningPart == null) {
-          currentReasoningPart = {
-            type: "reasoning",
-            reasoning: "",
-            details: []
-          };
-          message.parts.push(currentReasoningPart);
-        }
-        currentReasoningPart.details.push({
-          type: "redacted",
-          data: value.data
-        });
-        currentReasoningTextDetail = void 0;
-        execUpdate();
-      },
-      onFilePart(value) {
-        message.parts.push({
-          type: "file",
-          mimeType: value.mimeType,
-          data: value.data
-        });
-        execUpdate();
-      },
-      onSourcePart(value) {
-        message.parts.push({
-          type: "source",
-          source: value
-        });
-        execUpdate();
-      },
-      onToolCallStreamingStartPart(value) {
-        if (message.toolInvocations == null) {
-          message.toolInvocations = [];
-        }
-        partialToolCalls[value.toolCallId] = {
-          text: "",
-          step,
-          toolName: value.toolName,
-          index: message.toolInvocations.length
-        };
-        const invocation = {
-          state: "partial-call",
-          step,
-          toolCallId: value.toolCallId,
-          toolName: value.toolName,
-          args: void 0
-        };
-        message.toolInvocations.push(invocation);
-        updateToolInvocationPart(value.toolCallId, invocation);
-        execUpdate();
-      },
-      onToolCallDeltaPart(value) {
-        const partialToolCall = partialToolCalls[value.toolCallId];
-        partialToolCall.text += value.argsTextDelta;
-        const { value: partialArgs } = uiUtils.parsePartialJson(partialToolCall.text);
-        const invocation = {
-          state: "partial-call",
-          step: partialToolCall.step,
-          toolCallId: value.toolCallId,
-          toolName: partialToolCall.toolName,
-          args: partialArgs
-        };
-        message.toolInvocations[partialToolCall.index] = invocation;
-        updateToolInvocationPart(value.toolCallId, invocation);
-        execUpdate();
-      },
-      async onToolCallPart(value) {
-        const invocation = {
-          state: "call",
-          step,
-          ...value
-        };
-        if (partialToolCalls[value.toolCallId] != null) {
-          message.toolInvocations[partialToolCalls[value.toolCallId].index] = invocation;
-        } else {
+          message.content += value;
+          execUpdate();
+        },
+        onReasoningPart(value) {
+          if (currentReasoningTextDetail == null) {
+            currentReasoningTextDetail = { type: "text", text: value };
+            if (currentReasoningPart != null) {
+              currentReasoningPart.details.push(currentReasoningTextDetail);
+            }
+          } else {
+            currentReasoningTextDetail.text += value;
+          }
+          if (currentReasoningPart == null) {
+            currentReasoningPart = {
+              type: "reasoning",
+              reasoning: value,
+              details: [currentReasoningTextDetail]
+            };
+            message.parts.push(currentReasoningPart);
+          } else {
+            currentReasoningPart.reasoning += value;
+          }
+          message.reasoning = (message.reasoning ?? "") + value;
+          execUpdate();
+        },
+        onReasoningSignaturePart(value) {
+          if (currentReasoningTextDetail != null) {
+            currentReasoningTextDetail.signature = value.signature;
+          }
+        },
+        onRedactedReasoningPart(value) {
+          if (currentReasoningPart == null) {
+            currentReasoningPart = {
+              type: "reasoning",
+              reasoning: "",
+              details: []
+            };
+            message.parts.push(currentReasoningPart);
+          }
+          currentReasoningPart.details.push({
+            type: "redacted",
+            data: value.data
+          });
+          currentReasoningTextDetail = void 0;
+          execUpdate();
+        },
+        onFilePart(value) {
+          message.parts.push({
+            type: "file",
+            mimeType: value.mimeType,
+            data: value.data
+          });
+          execUpdate();
+        },
+        onSourcePart(value) {
+          message.parts.push({
+            type: "source",
+            source: value
+          });
+          execUpdate();
+        },
+        onToolCallStreamingStartPart(value) {
           if (message.toolInvocations == null) {
             message.toolInvocations = [];
           }
+          partialToolCalls[value.toolCallId] = {
+            text: "",
+            step,
+            toolName: value.toolName,
+            index: message.toolInvocations.length
+          };
+          const invocation = {
+            state: "partial-call",
+            step,
+            toolCallId: value.toolCallId,
+            toolName: value.toolName,
+            args: void 0
+          };
           message.toolInvocations.push(invocation);
-        }
-        updateToolInvocationPart(value.toolCallId, invocation);
-        execUpdate();
-        if (onToolCall) {
-          const result = await onToolCall({ toolCall: value });
-          if (result != null) {
-            const invocation2 = {
-              state: "result",
-              step,
-              ...value,
-              result
-            };
-            message.toolInvocations[message.toolInvocations.length - 1] = invocation2;
-            updateToolInvocationPart(value.toolCallId, invocation2);
-            execUpdate();
+          updateToolInvocationPart(value.toolCallId, invocation);
+          execUpdate();
+        },
+        onToolCallDeltaPart(value) {
+          const partialToolCall = partialToolCalls[value.toolCallId];
+          partialToolCall.text += value.argsTextDelta;
+          const { value: partialArgs } = uiUtils.parsePartialJson(partialToolCall.text);
+          const invocation = {
+            state: "partial-call",
+            step: partialToolCall.step,
+            toolCallId: value.toolCallId,
+            toolName: partialToolCall.toolName,
+            args: partialArgs
+          };
+          message.toolInvocations[partialToolCall.index] = invocation;
+          updateToolInvocationPart(value.toolCallId, invocation);
+          execUpdate();
+        },
+        async onToolCallPart(value) {
+          const invocation = {
+            state: "call",
+            step,
+            ...value
+          };
+          if (partialToolCalls[value.toolCallId] != null) {
+            message.toolInvocations[partialToolCalls[value.toolCallId].index] = invocation;
+          } else {
+            if (message.toolInvocations == null) {
+              message.toolInvocations = [];
+            }
+            message.toolInvocations.push(invocation);
           }
+          updateToolInvocationPart(value.toolCallId, invocation);
+          execUpdate();
+          if (onToolCall) {
+            const result = await onToolCall({ toolCall: value });
+            if (result != null) {
+              const invocation2 = {
+                state: "result",
+                step,
+                ...value,
+                result
+              };
+              message.toolInvocations[message.toolInvocations.length - 1] = invocation2;
+              updateToolInvocationPart(value.toolCallId, invocation2);
+              execUpdate();
+            }
+          }
+        },
+        onToolResultPart(value) {
+          const toolInvocations = message.toolInvocations;
+          if (toolInvocations == null) {
+            throw new Error("tool_result must be preceded by a tool_call");
+          }
+          const toolInvocationIndex = toolInvocations.findIndex(
+            (invocation2) => invocation2.toolCallId === value.toolCallId
+          );
+          if (toolInvocationIndex === -1) {
+            throw new Error("tool_result must be preceded by a tool_call with the same toolCallId");
+          }
+          const invocation = {
+            ...toolInvocations[toolInvocationIndex],
+            state: "result",
+            ...value
+          };
+          toolInvocations[toolInvocationIndex] = invocation;
+          updateToolInvocationPart(value.toolCallId, invocation);
+          execUpdate();
+        },
+        onDataPart(value) {
+          data.push(...value);
+          execUpdate();
+        },
+        onMessageAnnotationsPart(value) {
+          if (messageAnnotations == null) {
+            messageAnnotations = [...value];
+          } else {
+            messageAnnotations.push(...value);
+          }
+          execUpdate();
+        },
+        onFinishStepPart(value) {
+          step += 1;
+          currentTextPart = value.isContinued ? currentTextPart : void 0;
+          currentReasoningPart = void 0;
+          currentReasoningTextDetail = void 0;
+        },
+        onStartStepPart(value) {
+          if (!replaceLastMessage) {
+            message.id = value.messageId;
+          }
+          message.parts.push({ type: "step-start" });
+          execUpdate();
+        },
+        onFinishMessagePart(value) {
+          finishReason = value.finishReason;
+          if (value.usage != null) {
+            usage = value.usage;
+          }
+        },
+        onErrorPart(error) {
+          throw new Error(error);
         }
-      },
-      onToolResultPart(value) {
-        const toolInvocations = message.toolInvocations;
-        if (toolInvocations == null) {
-          throw new Error("tool_result must be preceded by a tool_call");
-        }
-        const toolInvocationIndex = toolInvocations.findIndex((invocation2) => invocation2.toolCallId === value.toolCallId);
-        if (toolInvocationIndex === -1) {
-          throw new Error("tool_result must be preceded by a tool_call with the same toolCallId");
-        }
-        const invocation = {
-          ...toolInvocations[toolInvocationIndex],
-          state: "result",
-          ...value
-        };
-        toolInvocations[toolInvocationIndex] = invocation;
-        updateToolInvocationPart(value.toolCallId, invocation);
-        execUpdate();
-      },
-      onDataPart(value) {
-        data.push(...value);
-        execUpdate();
-      },
-      onMessageAnnotationsPart(value) {
-        if (messageAnnotations == null) {
-          messageAnnotations = [...value];
-        } else {
-          messageAnnotations.push(...value);
-        }
-        execUpdate();
-      },
-      onFinishStepPart(value) {
-        step += 1;
-        currentTextPart = value.isContinued ? currentTextPart : void 0;
-        currentReasoningPart = void 0;
-        currentReasoningTextDetail = void 0;
-      },
-      onStartStepPart(value) {
-        if (!replaceLastMessage) {
-          message.id = value.messageId;
-        }
-        message.parts.push({ type: "step-start" });
-        execUpdate();
-      },
-      onFinishMessagePart(value) {
-        finishReason = value.finishReason;
-        if (value.usage != null) {
-          usage = value.usage;
-        }
-      },
-      onErrorPart(error) {
-        throw new Error(error);
-      }
-    });
-    onFinish?.({ message, finishReason, usage });
-  }
-  /**
-   * Streams a response from the agent
-   * @param params - Stream parameters including prompt
-   * @returns Promise containing the enhanced Response object with processDataStream method
-   */
-  async stream(params) {
-    const processedParams = {
-      ...params,
-      output: params.output ? zodToJsonSchema(params.output) : void 0,
-      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
-      clientTools: processClientTools(params.clientTools)
-    };
-    const { readable, writable } = new TransformStream();
-    const response = await this.processStreamResponse(processedParams, writable);
-    const streamResponse = new Response(readable, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-    streamResponse.processDataStream = async (options = {}) => {
-      await uiUtils.processDataStream({
-        stream: streamResponse.body,
-        ...options
       });
-    };
-    return streamResponse;
+      onFinish?.({ message, finishReason, usage });
+    }
   }
   /**
    * Processes the stream response and handles tool calls
@@ -722,6 +712,7 @@ var Agent = class extends BaseResource {
       throw new Error("No response body");
     }
     try {
+      const streamProtocol = processedParams.output ? "text" : "data";
       let toolCalls = [];
       let messages = [];
       const [streamForWritable, streamForProcessing] = response.body.tee();
@@ -801,17 +792,55 @@ var Agent = class extends BaseResource {
             }
           } else {
             setTimeout(() => {
-              writable.close();
+              if (!writable.locked) {
+                writable.close();
+              }
             }, 0);
           }
         },
-        lastMessage: void 0
+        lastMessage: void 0,
+        streamProtocol
       });
     } catch (error) {
       console.error("Error processing stream response:", error);
     }
     return response;
   }
+  /**
+   * Streams a response from the agent
+   * @param params - Stream parameters including prompt
+   * @returns Promise containing the enhanced Response object with processDataStream and processTextStream methods
+   */
+  async stream(params) {
+    const processedParams = {
+      ...params,
+      output: params.output ? zodToJsonSchema(params.output) : void 0,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      clientTools: processClientTools(params.clientTools)
+    };
+    const { readable, writable } = new TransformStream();
+    const response = await this.processStreamResponse(processedParams, writable);
+    const streamResponse = new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async (options = {}) => {
+      await uiUtils.processDataStream({
+        stream: streamResponse.body,
+        ...options
+      });
+    };
+    streamResponse.processTextStream = async (options) => {
+      await uiUtils.processTextStream({
+        stream: streamResponse.body,
+        onTextPart: options?.onTextPart ?? (() => {
+        })
+      });
+    };
+    return streamResponse;
+  }
   /**
    * Gets details about a specific tool available to the agent
    * @param toolId - ID of the tool to retrieve

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import { AbstractAgent } from '@ag-ui/client';
 import { ServerInfo, MCPToolType, ServerDetailInfo } from '@mastra/core/mcp';
-import { processDataStream } from '@ai-sdk/ui-utils';
+import { processDataStream, processTextStream } from '@ai-sdk/ui-utils';
 import { CoreMessage, AiMessageType, StorageThreadType, MastraMessageV1, LegacyWorkflowRuns, WorkflowRuns, WorkflowRun, QueryResult, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
@@ -440,18 +440,19 @@ declare class Agent extends BaseResource {
         experimental_output: T;
     }): Promise<GenerateReturn<T>>;
     private processChatResponse;
+    /**
+     * Processes the stream response and handles tool calls
+     */
+    private processStreamResponse;
     /**
      * Streams a response from the agent
      * @param params - Stream parameters including prompt
-     * @returns Promise containing the enhanced Response object with processDataStream method
+     * @returns Promise containing the enhanced Response object with processDataStream and processTextStream methods
      */
     stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response & {
         processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+        processTextStream: (options?: Omit<Parameters<typeof processTextStream>[0], 'stream'>) => Promise<void>;
     }>;
-    /**
-     * Processes the stream response and handles tool calls
-     */
-    private processStreamResponse;
     /**
      * Gets details about a specific tool available to the agent
      * @param toolId - ID of the tool to retrieve

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { AbstractAgent } from '@ag-ui/client';
 import { ServerInfo, MCPToolType, ServerDetailInfo } from '@mastra/core/mcp';
-import { processDataStream } from '@ai-sdk/ui-utils';
+import { processDataStream, processTextStream } from '@ai-sdk/ui-utils';
 import { CoreMessage, AiMessageType, StorageThreadType, MastraMessageV1, LegacyWorkflowRuns, WorkflowRuns, WorkflowRun, QueryResult, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
@@ -440,18 +440,19 @@ declare class Agent extends BaseResource {
         experimental_output: T;
     }): Promise<GenerateReturn<T>>;
     private processChatResponse;
+    /**
+     * Processes the stream response and handles tool calls
+     */
+    private processStreamResponse;
     /**
      * Streams a response from the agent
      * @param params - Stream parameters including prompt
-     * @returns Promise containing the enhanced Response object with processDataStream method
+     * @returns Promise containing the enhanced Response object with processDataStream and processTextStream methods
      */
     stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response & {
         processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+        processTextStream: (options?: Omit<Parameters<typeof processTextStream>[0], 'stream'>) => Promise<void>;
     }>;
-    /**
-     * Processes the stream response and handles tool calls
-     */
-    private processStreamResponse;
     /**
      * Gets details about a specific tool available to the agent
      * @param toolId - ID of the tool to retrieve