@mastra/client-js 0.0.0-ai-v5-20250718021026 → 0.0.0-ai-v5-20250729181825

package/dist/index.cjs

@@ -5,7 +5,7 @@ var rxjs = require('rxjs');
 var uiUtils = require('@ai-sdk/ui-utils');
 var zod = require('zod');
 var originalZodToJsonSchema = require('zod-to-json-schema');
-var tools = require('@mastra/core/tools');
+var isVercelTool = require('@mastra/core/tools/is-vercel-tool');
 var uuid = require('@lukeed/uuid');
 var runtimeContext = require('@mastra/core/runtime-context');
 
@@ -210,7 +210,7 @@ function processClientTools(clientTools) {
   }
   return Object.fromEntries(
     Object.entries(clientTools).map(([key, value]) => {
-      if (tools.isVercelTool(value)) {
+      if (isVercelTool.isVercelTool(value)) {
         return [
           key,
           {
@@ -253,7 +253,7 @@ var BaseResource = class {
         const response = await fetch(`${baseUrl.replace(/\/$/, "")}${path}`, {
           ...options,
           headers: {
-            ...options.method === "POST" || options.method === "PUT" ? { "content-type": "application/json" } : {},
+            ...options.body && !(options.body instanceof FormData) && (options.method === "POST" || options.method === "PUT") ? { "content-type": "application/json" } : {},
             ...headers,
             ...options.headers
             // TODO: Bring this back once we figure out what we/users need to do to make this work with cross-origin requests
@@ -378,10 +378,13 @@ var Agent = class extends BaseResource {
       clientTools: processClientTools(params.clientTools)
     };
     const { runId, resourceId, threadId, runtimeContext } = processedParams;
-    const response = await this.request(`/api/agents/${this.agentId}/generate`, {
-      method: "POST",
-      body: processedParams
-    });
+    const response = await this.request(
+      `/api/agents/${this.agentId}/generate`,
+      {
+        method: "POST",
+        body: processedParams
+      }
+    );
     if (response.finishReason === "tool-calls") {
       const toolCalls = response.toolCalls;
       if (!toolCalls || !Array.isArray(toolCalls)) {
@@ -430,8 +433,7 @@ var Agent = class extends BaseResource {
     onToolCall,
     onFinish,
     getCurrentDate = () => /* @__PURE__ */ new Date(),
-    lastMessage,
-    streamProtocol
+    lastMessage
   }) {
     const replaceLastMessage = lastMessage?.role === "assistant";
     let step = replaceLastMessage ? 1 + // find max step in existing tool invocations:
@@ -492,213 +494,228 @@ var Agent = class extends BaseResource {
         replaceLastMessage
       });
     }
-    if (streamProtocol === "text") {
-      await uiUtils.processTextStream({
-        stream,
-        onTextPart(value) {
-          message.content += value;
-          execUpdate();
+    await uiUtils.processDataStream({
+      stream,
+      onTextPart(value) {
+        if (currentTextPart == null) {
+          currentTextPart = {
+            type: "text",
+            text: value
+          };
+          message.parts.push(currentTextPart);
+        } else {
+          currentTextPart.text += value;
         }
-      });
-      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;
-          }
-          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);
+        message.content += value;
+        execUpdate();
+      },
+      onReasoningPart(value) {
+        if (currentReasoningTextDetail == null) {
+          currentReasoningTextDetail = { type: "text", text: value };
+          if (currentReasoningPart != null) {
+            currentReasoningPart.details.push(currentReasoningTextDetail);
           }
-          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) {
+        } 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 {
           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 {
-            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;
+        }
+        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();
           }
-        },
-        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
       });
-      onFinish?.({ message, finishReason, usage });
-    }
+    };
+    return streamResponse;
   }
   /**
    * Processes the stream response and handles tool calls
@@ -713,7 +730,6 @@ 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();
@@ -725,7 +741,12 @@ var Agent = class extends BaseResource {
       this.processChatResponse({
         stream: streamForProcessing,
         update: ({ message }) => {
-          messages.push(message);
+          const existingIndex = messages.findIndex((m) => m.id === message.id);
+          if (existingIndex !== -1) {
+            messages[existingIndex] = message;
+          } else {
+            messages.push(message);
+          }
         },
         onFinish: async ({ finishReason, message }) => {
           if (finishReason === "tool-calls") {
@@ -785,63 +806,29 @@ var Agent = class extends BaseResource {
                 this.processStreamResponse(
                   {
                     ...processedParams,
-                    messages: [...messageArray, ...messages, lastMessage]
+                    messages: [...messageArray, ...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
                   },
                   writable
-                );
+                ).catch((error) => {
+                  console.error("Error processing stream response:", error);
+                });
               }
             }
           } else {
             setTimeout(() => {
-              if (!writable.locked) {
-                writable.close();
-              }
+              writable.close();
             }, 0);
           }
         },
-        lastMessage: void 0,
-        streamProtocol
+        lastMessage: void 0
+      }).catch((error) => {
+        console.error("Error processing stream response:", error);
       });
     } 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
@@ -985,6 +972,36 @@ var MemoryThread = class extends BaseResource {
     });
     return this.request(`/api/memory/threads/${this.threadId}/messages?${query.toString()}`);
   }
+  /**
+   * Retrieves paginated messages associated with the thread with advanced filtering and selection options
+   * @param params - Pagination parameters including selectBy criteria, page, perPage, date ranges, and message inclusion options
+   * @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
+   */
+  getMessagesPaginated({
+    selectBy,
+    ...rest
+  }) {
+    const query = new URLSearchParams({
+      ...rest,
+      ...selectBy ? { selectBy: JSON.stringify(selectBy) } : {}
+    });
+    return this.request(`/api/memory/threads/${this.threadId}/messages/paginated?${query.toString()}`);
+  }
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(messageIds) {
+    const query = new URLSearchParams({
+      agentId: this.agentId
+    });
+    return this.request(`/api/memory/messages/delete?${query.toString()}`, {
+      method: "POST",
+      body: { messageIds }
+    });
+  }
 };
 
 // src/resources/vector.ts
@@ -1406,6 +1423,14 @@ var Workflow = class extends BaseResource {
       method: "POST"
     });
   }
+  /**
+   * Creates a new workflow run (alias for createRun)
+   * @param params - Optional object containing the optional runId
+   * @returns Promise containing the runId of the created run
+   */
+  createRunAsync(params) {
+    return this.createRun(params);
+  }
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
    * @param params - Object containing the runId, inputData and runtimeContext
@@ -1725,6 +1750,21 @@ var NetworkMemoryThread = class extends BaseResource {
     });
     return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
   }
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(messageIds) {
+    const query = new URLSearchParams({
+      networkId: this.networkId
+    });
+    return this.request(`/api/memory/network/messages/delete?${query.toString()}`, {
+      method: "POST",
+      body: { messageIds }
+    });
+  }
 };
 
 // src/resources/vNextNetwork.ts
@@ -2294,6 +2334,84 @@ var MastraClient = class extends BaseResource {
       }
     });
   }
+  /**
+   * Retrieves all available scorers
+   * @returns Promise containing list of available scorers
+   */
+  getScorers() {
+    return this.request("/api/scores/scorers");
+  }
+  /**
+   * Retrieves a scorer by ID
+   * @param scorerId - ID of the scorer to retrieve
+   * @returns Promise containing the scorer
+   */
+  getScorer(scorerId) {
+    return this.request(`/api/scores/scorers/${scorerId}`);
+  }
+  getScoresByScorerId(params) {
+    const { page, perPage, scorerId, entityId, entityType } = params;
+    const searchParams = new URLSearchParams();
+    if (entityId) {
+      searchParams.set("entityId", entityId);
+    }
+    if (entityType) {
+      searchParams.set("entityType", entityType);
+    }
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/scores/scorer/${scorerId}${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Retrieves scores by run ID
+   * @param params - Parameters containing run ID and pagination options
+   * @returns Promise containing scores and pagination info
+   */
+  getScoresByRunId(params) {
+    const { runId, page, perPage } = params;
+    const searchParams = new URLSearchParams();
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/scores/run/${runId}${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Retrieves scores by entity ID and type
+   * @param params - Parameters containing entity ID, type, and pagination options
+   * @returns Promise containing scores and pagination info
+   */
+  getScoresByEntityId(params) {
+    const { entityId, entityType, page, perPage } = params;
+    const searchParams = new URLSearchParams();
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/scores/entity/${entityType}/${entityId}${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Saves a score
+   * @param params - Parameters containing the score data to save
+   * @returns Promise containing the saved score
+   */
+  saveScore(params) {
+    return this.request("/api/scores", {
+      method: "POST",
+      body: params
+    });
+  }
 };
 
 exports.MastraClient = MastraClient;