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

package/dist/index.js

@@ -1,6 +1,6 @@
 import { AbstractAgent, EventType } from '@ag-ui/client';
 import { Observable } from 'rxjs';
-import { processDataStream } from '@ai-sdk/ui-utils';
+import { processDataStream, parsePartialJson } from '@ai-sdk/ui-utils';
 import { ZodSchema } from 'zod';
 import originalZodToJsonSchema from 'zod-to-json-schema';
 import { isVercelTool } from '@mastra/core/tools';
@@ -293,8 +293,6 @@ function parseClientRuntimeContext(runtimeContext) {
   }
   return void 0;
 }
-
-// src/resources/agent.ts
 var AgentVoice = class extends BaseResource {
   constructor(options, agentId) {
     super(options);
@@ -363,7 +361,7 @@ var Agent = class extends BaseResource {
   details() {
     return this.request(`/api/agents/${this.agentId}`);
   }
-  generate(params) {
+  async generate(params) {
     const processedParams = {
       ...params,
       output: params.output ? zodToJsonSchema(params.output) : void 0,
@@ -371,10 +369,310 @@ var Agent = class extends BaseResource {
       runtimeContext: parseClientRuntimeContext(params.runtimeContext),
       clientTools: processClientTools(params.clientTools)
     };
-    return this.request(`/api/agents/${this.agentId}/generate`, {
+    const { runId, resourceId, threadId, runtimeContext } = processedParams;
+    const response = await this.request(`/api/agents/${this.agentId}/generate`, {
       method: "POST",
       body: processedParams
     });
+    if (response.finishReason === "tool-calls") {
+      for (const toolCall of response.toolCalls) {
+        const clientTool = params.clientTools?.[toolCall.toolName];
+        if (clientTool && clientTool.execute) {
+          const result = await clientTool.execute(
+            { context: toolCall?.args, runId, resourceId, threadId, runtimeContext },
+            {
+              messages: response.messages,
+              toolCallId: toolCall?.toolCallId
+            }
+          );
+          const updatedMessages = [
+            {
+              role: "user",
+              content: params.messages
+            },
+            ...response.response.messages,
+            {
+              role: "tool",
+              content: [
+                {
+                  type: "tool-result",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  result
+                }
+              ]
+            }
+          ];
+          return this.generate({
+            ...params,
+            messages: updatedMessages
+          });
+        }
+      }
+    }
+    return response;
+  }
+  async processChatResponse({
+    stream,
+    update,
+    onToolCall,
+    onFinish,
+    getCurrentDate = () => /* @__PURE__ */ new Date(),
+    lastMessage
+  }) {
+    const replaceLastMessage = lastMessage?.role === "assistant";
+    let step = replaceLastMessage ? 1 + // find max step in existing tool invocations:
+    (lastMessage.toolInvocations?.reduce((max, toolInvocation) => {
+      return Math.max(max, toolInvocation.step ?? 0);
+    }, 0) ?? 0) : 0;
+    const message = replaceLastMessage ? structuredClone(lastMessage) : {
+      id: crypto.randomUUID(),
+      createdAt: getCurrentDate(),
+      role: "assistant",
+      content: "",
+      parts: []
+    };
+    let currentTextPart = void 0;
+    let currentReasoningPart = void 0;
+    let currentReasoningTextDetail = void 0;
+    function updateToolInvocationPart(toolCallId, invocation) {
+      const part = message.parts.find(
+        (part2) => part2.type === "tool-invocation" && part2.toolInvocation.toolCallId === toolCallId
+      );
+      if (part != null) {
+        part.toolInvocation = invocation;
+      } else {
+        message.parts.push({
+          type: "tool-invocation",
+          toolInvocation: invocation
+        });
+      }
+    }
+    const data = [];
+    let messageAnnotations = replaceLastMessage ? lastMessage?.annotations : void 0;
+    const partialToolCalls = {};
+    let usage = {
+      completionTokens: NaN,
+      promptTokens: NaN,
+      totalTokens: NaN
+    };
+    let finishReason = "unknown";
+    function execUpdate() {
+      const copiedData = [...data];
+      if (messageAnnotations?.length) {
+        message.annotations = messageAnnotations;
+      }
+      const copiedMessage = {
+        // deep copy the message to ensure that deep changes (msg attachments) are updated
+        // with SolidJS. SolidJS uses referential integration of sub-objects to detect changes.
+        ...structuredClone(message),
+        // add a revision id to ensure that the message is updated with SWR. SWR uses a
+        // hashing approach by default to detect changes, but it only works for shallow
+        // changes. This is why we need to add a revision id to ensure that the message
+        // is updated with SWR (without it, the changes get stuck in SWR and are not
+        // forwarded to rendering):
+        revisionId: crypto.randomUUID()
+      };
+      update({
+        message: copiedMessage,
+        data: copiedData,
+        replaceLastMessage
+      });
+    }
+    await processDataStream({
+      stream,
+      onTextPart(value) {
+        if (currentTextPart == null) {
+          currentTextPart = {
+            type: "text",
+            text: value
+          };
+          message.parts.push(currentTextPart);
+        } else {
+          currentTextPart.text += value;
+        }
+        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();
+      },
+      onToolCallDeltaPart(value) {
+        const partialToolCall = partialToolCalls[value.toolCallId];
+        partialToolCall.text += value.argsTextDelta;
+        const { value: partialArgs } = 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);
+      }
+    });
+    onFinish?.({ message, finishReason, usage });
   }
   /**
    * Streams a response from the agent
@@ -389,6 +687,25 @@ var Agent = class extends BaseResource {
       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 processDataStream({
+        stream: readable,
+        ...options
+      });
+    };
+    return streamResponse;
+  }
+  /**
+   * Processes the stream response and handles tool calls
+   */
+  async processStreamResponse(processedParams, writable) {
     const response = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: "POST",
       body: processedParams,
@@ -397,12 +714,81 @@ var Agent = class extends BaseResource {
     if (!response.body) {
       throw new Error("No response body");
     }
-    response.processDataStream = async (options = {}) => {
-      await processDataStream({
-        stream: response.body,
-        ...options
+    try {
+      let toolCalls = [];
+      let finishReasonToolCalls = false;
+      let messages = [];
+      let hasProcessedToolCalls = false;
+      response.clone().body.pipeTo(writable, {
+        preventClose: true
       });
-    };
+      await this.processChatResponse({
+        stream: response.clone().body,
+        update: ({ message }) => {
+          messages.push(message);
+        },
+        onFinish: ({ 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);
+            }
+          }
+        },
+        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);
+    }
     return response;
   }
   /**
@@ -797,7 +1183,7 @@ var LegacyWorkflow = class extends BaseResource {
 };
 
 // src/resources/tool.ts
-var Tool = class extends BaseResource {
+var Tool2 = class extends BaseResource {
   constructor(options, toolId) {
     super(options);
     this.toolId = toolId;
@@ -1497,7 +1883,7 @@ var MastraClient = class extends BaseResource {
    * @returns Tool instance
    */
   getTool(toolId) {
-    return new Tool(this.options, toolId);
+    return new Tool2(this.options, toolId);
   }
   /**
    * Retrieves all available legacy workflows

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.10.6-alpha.2",
+  "version": "0.10.6-alpha.4",
   "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.2"
+    "@mastra/core": "0.10.7-alpha.4"
   },
   "peerDependencies": {
     "zod": "^3.0.0"

package/src/example.ts

@@ -1,8 +1,8 @@
 import { MastraClient } from './client';
+import z from 'zod';
 // import type { WorkflowRunResult } from './types';
 
 // Agent
-
 (async () => {
   const client = new MastraClient({
     baseUrl: 'http://localhost:4111',
@@ -29,6 +29,9 @@ import { MastraClient } from './client';
       onErrorPart: error => {
         console.error(error);
       },
+      onToolCallPart(streamPart) {
+        console.log(streamPart);
+      },
     });
   } catch (error) {
     console.error(error);