@mastra/client-js 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/index.cjs

@@ -5,12 +5,7 @@ var uuid = require('@lukeed/uuid');
 var error = require('@mastra/core/error');
 var requestContext = require('@mastra/core/request-context');
 var isVercelTool = require('@mastra/core/tools/is-vercel-tool');
-var zod = require('zod');
-var originalZodToJsonSchema = require('zod-to-json-schema');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var originalZodToJsonSchema__default = /*#__PURE__*/_interopDefault(originalZodToJsonSchema);
+var zodToJson = require('@mastra/schema-compat/zod-to-json');
 
 // src/resources/agent.ts
 function parseClientRequestContext(requestContext$1) {
@@ -43,11 +38,7 @@ function zodToJsonSchema(zodSchema) {
   if (!isZodType(zodSchema)) {
     return zodSchema;
   }
-  if ("toJSONSchema" in zod.z) {
-    const fn = "toJSONSchema";
-    return zod.z[fn].call(zod.z, zodSchema);
-  }
-  return originalZodToJsonSchema__default.default(zodSchema, { $refStrategy: "relative" });
+  return zodToJson.zodToJsonSchema(zodSchema);
 }
 
 // src/utils/process-client-tools.ts
@@ -150,11 +141,20 @@ var BaseResource = class {
    */
   async request(path, options = {}) {
     let lastError = null;
-    const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1e3, headers = {}, credentials } = this.options;
+    const {
+      baseUrl,
+      retries = 3,
+      backoffMs = 100,
+      maxBackoffMs = 1e3,
+      headers = {},
+      credentials,
+      fetch: customFetch
+    } = this.options;
+    const fetchFn = customFetch || fetch;
     let delay = backoffMs;
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
-        const response = await fetch(`${baseUrl.replace(/\/$/, "")}${path}`, {
+        const response = await fetchFn(`${baseUrl.replace(/\/$/, "")}${path}`, {
           ...options,
           headers: {
             ...options.body && !(options.body instanceof FormData) && (options.method === "POST" || options.method === "PUT") ? { "content-type": "application/json" } : {},
@@ -793,7 +793,7 @@ var Agent = class extends BaseResource {
           case "tripwire": {
             message.parts.push({
               type: "text",
-              text: chunk.payload.tripwireReason
+              text: chunk.payload.reason
             });
             execUpdate();
             break;
@@ -1458,7 +1458,7 @@ var MemoryThread = class extends BaseResource {
     if (include) queryParams.include = JSON.stringify(include);
     const query = new URLSearchParams(queryParams);
     const queryString = query.toString();
-    const url = `/api/memory/threads/${this.threadId}/messages${queryString ? `?${queryString}` : ""}${requestContextQueryString(requestContext, queryString ? "&" : "?")}`;
+    const url = `/api/memory/threads/${this.threadId}/messages?agentId=${this.agentId}${queryString ? `&${queryString}` : ""}${requestContextQueryString(requestContext, "&")}`;
     return this.request(url);
   }
   /**
@@ -1617,15 +1617,21 @@ var Workflow = class extends BaseResource {
     if (params?.toDate) {
       searchParams.set("toDate", params.toDate.toISOString());
     }
-    if (params?.perPage !== null && params?.perPage !== void 0) {
-      if (params.perPage === false) {
-        searchParams.set("perPage", "false");
-      } else if (typeof params.perPage === "number" && params.perPage > 0 && Number.isInteger(params.perPage)) {
-        searchParams.set("perPage", String(params.perPage));
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
+    }
+    if (params?.perPage !== void 0) {
+      searchParams.set("perPage", String(params.perPage));
+    }
+    if (params?.limit !== null && params?.limit !== void 0) {
+      if (params.limit === false) {
+        searchParams.set("limit", "false");
+      } else if (typeof params.limit === "number" && params.limit > 0 && Number.isInteger(params.limit)) {
+        searchParams.set("limit", String(params.limit));
       }
     }
-    if (params?.page !== null && params?.page !== void 0 && !isNaN(Number(params?.page))) {
-      searchParams.set("page", String(params.page));
+    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
+      searchParams.set("offset", String(params.offset));
     }
     if (params?.resourceId) {
       searchParams.set("resourceId", params.resourceId);
@@ -1648,6 +1654,16 @@ var Workflow = class extends BaseResource {
   runById(runId, requestContext) {
     return this.request(`/api/workflows/${this.workflowId}/runs/${runId}${requestContextQueryString(requestContext)}`);
   }
+  /**
+   * Deletes a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to delete
+   * @returns Promise containing a success message
+   */
+  deleteRunById(runId) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}`, {
+      method: "DELETE"
+    });
+  }
   /**
    * Retrieves the execution result for a specific workflow run by its ID
    * @param runId - The ID of the workflow run to retrieve the execution result for
@@ -1692,6 +1708,7 @@ var Workflow = class extends BaseResource {
         return this.start({
           runId,
           inputData: p.inputData,
+          initialState: p.initialState,
           requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
@@ -1700,12 +1717,18 @@ var Workflow = class extends BaseResource {
         return this.startAsync({
           runId,
           inputData: p.inputData,
+          initialState: p.initialState,
           requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
       },
       stream: async (p) => {
-        return this.stream({ runId, inputData: p.inputData, requestContext: p.requestContext });
+        return this.stream({
+          runId,
+          inputData: p.inputData,
+          initialState: p.initialState,
+          requestContext: p.requestContext
+        });
       },
       resume: async (p) => {
         return this.resume({
@@ -1737,14 +1760,19 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId, inputData and requestContext
+   * @param params - Object containing the runId, inputData, initialState and requestContext
    * @returns Promise containing success message
    */
   start(params) {
     const requestContext = parseClientRequestContext(params.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
-      body: { inputData: params?.inputData, requestContext, tracingOptions: params.tracingOptions }
+      body: {
+        inputData: params?.inputData,
+        initialState: params?.initialState,
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
     });
   }
   /**
@@ -1772,7 +1800,7 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the optional runId, inputData and requestContext
+   * @param params - Object containing the optional runId, inputData, initialState and requestContext
    * @returns Promise containing the workflow execution results
    */
   startAsync(params) {
@@ -1783,12 +1811,17 @@ var Workflow = class extends BaseResource {
     const requestContext = parseClientRequestContext(params.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: "POST",
-      body: { inputData: params.inputData, requestContext, tracingOptions: params.tracingOptions }
+      body: {
+        inputData: params.inputData,
+        initialState: params.initialState,
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
     });
   }
   /**
    * Starts a workflow run and returns a stream
-   * @param params - Object containing the optional runId, inputData and requestContext
+   * @param params - Object containing the optional runId, inputData, initialState and requestContext
    * @returns Promise containing the workflow execution results
    */
   async stream(params) {
@@ -1801,7 +1834,12 @@ var Workflow = class extends BaseResource {
       `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
       {
         method: "POST",
-        body: { inputData: params.inputData, requestContext, tracingOptions: params.tracingOptions },
+        body: {
+          inputData: params.inputData,
+          initialState: params.initialState,
+          requestContext,
+          tracingOptions: params.tracingOptions
+        },
         stream: true
       }
     );
@@ -1886,7 +1924,7 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Starts a workflow run and returns a stream
-   * @param params - Object containing the optional runId, inputData and requestContext
+   * @param params - Object containing the optional runId, inputData, initialState and requestContext
    * @returns Promise containing the workflow execution results
    */
   async streamVNext(params) {
@@ -1901,6 +1939,7 @@ var Workflow = class extends BaseResource {
         method: "POST",
         body: {
           inputData: params.inputData,
+          initialState: params.initialState,
           requestContext,
           closeOnSuspend: params.closeOnSuspend,
           tracingOptions: params.tracingOptions
@@ -2081,6 +2120,142 @@ var Workflow = class extends BaseResource {
       }
     });
   }
+  /**
+   * Restarts an active workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the runId and requestContext
+   * @returns Promise containing success message
+   */
+  restart(params) {
+    const requestContext = parseClientRequestContext(params.requestContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
+    });
+  }
+  /**
+   * Restarts an active workflow run asynchronously
+   * @param params - Object containing the runId and requestContext
+   * @returns Promise containing the workflow restart results
+   */
+  restartAsync(params) {
+    const requestContext = parseClientRequestContext(params.requestContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart-async?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
+    });
+  }
+  /**
+   * Restart all active workflow runs synchronously without waiting for the workflow to complete
+   * @returns Promise containing success message
+   */
+  restartAllActiveWorkflowRuns() {
+    return this.request(`/api/workflows/${this.workflowId}/restart-all-active-workflow-runs`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Restart all active workflow runs asynchronously
+   * @returns Promise containing success message
+   */
+  restartAllActiveWorkflowRunsAsync() {
+    return this.request(`/api/workflows/${this.workflowId}/restart-all-active-workflow-runs-async`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Time travels a workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing success message
+   */
+  timeTravel({
+    runId,
+    requestContext: paramsRequestContext,
+    ...params
+  }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    return this.request(`/api/workflows/${this.workflowId}/time-travel?runId=${runId}`, {
+      method: "POST",
+      body: {
+        ...params,
+        requestContext
+      }
+    });
+  }
+  /**
+   * Time travels a workflow run asynchronously
+   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing the workflow time travel results
+   */
+  timeTravelAsync({
+    runId,
+    requestContext: paramsRequestContext,
+    ...params
+  }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    return this.request(`/api/workflows/${this.workflowId}/time-travel-async?runId=${runId}`, {
+      method: "POST",
+      body: {
+        ...params,
+        requestContext
+      }
+    });
+  }
+  /**
+   * Time travels a workflow run and returns a stream
+   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing the workflow execution results
+   */
+  async timeTravelStream({ runId, requestContext: paramsRequestContext, ...params }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/time-travel-stream?runId=${runId}`,
+      {
+        method: "POST",
+        body: {
+          ...params,
+          requestContext
+        },
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to time travel workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
 };
 
 // src/resources/a2a.ts
@@ -2123,7 +2298,8 @@ var A2A = class extends BaseResource {
       body: {
         method: "message/stream",
         params
-      }
+      },
+      stream: true
     });
     return response;
   }
@@ -2554,6 +2730,16 @@ var AgentBuilder = class extends BaseResource {
     if (params?.page !== void 0) {
       searchParams.set("page", String(params.page));
     }
+    if (params?.limit !== null && params?.limit !== void 0) {
+      if (params.limit === false) {
+        searchParams.set("limit", "false");
+      } else if (typeof params.limit === "number" && params.limit > 0 && Number.isInteger(params.limit)) {
+        searchParams.set("limit", String(params.limit));
+      }
+    }
+    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
+      searchParams.set("offset", String(params.offset));
+    }
     if (params?.resourceId) {
       searchParams.set("resourceId", params.resourceId);
     }
@@ -2660,6 +2846,41 @@ var Observability = class extends BaseResource {
   }
 };
 
+// src/resources/stored-agent.ts
+var StoredAgent = class extends BaseResource {
+  constructor(options, storedAgentId) {
+    super(options);
+    this.storedAgentId = storedAgentId;
+  }
+  /**
+   * Retrieves details about the stored agent
+   * @returns Promise containing stored agent details
+   */
+  details() {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`);
+  }
+  /**
+   * Updates the stored agent with the provided fields
+   * @param params - Fields to update
+   * @returns Promise containing the updated stored agent
+   */
+  update(params) {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  /**
+   * Deletes the stored agent
+   * @returns Promise containing deletion confirmation
+   */
+  delete() {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`, {
+      method: "DELETE"
+    });
+  }
+};
+
 // src/client.ts
 var MastraClient = class extends BaseResource {
   observability;
@@ -2672,12 +2893,15 @@ var MastraClient = class extends BaseResource {
    * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing map of agent IDs to agent details
    */
-  listAgents(requestContext) {
+  listAgents(requestContext, partial) {
     const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
     const searchParams = new URLSearchParams();
     if (requestContextParam) {
       searchParams.set("requestContext", requestContextParam);
     }
+    if (partial) {
+      searchParams.set("partial", "true");
+    }
     const queryString = searchParams.toString();
     return this.request(`/api/agents${queryString ? `?${queryString}` : ""}`);
   }
@@ -2819,12 +3043,15 @@ var MastraClient = class extends BaseResource {
    * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing map of workflow IDs to workflow details
    */
-  listWorkflows(requestContext) {
+  listWorkflows(requestContext, partial) {
     const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
     const searchParams = new URLSearchParams();
     if (requestContextParam) {
       searchParams.set("requestContext", requestContextParam);
     }
+    if (partial) {
+      searchParams.set("partial", "true");
+    }
     const queryString = searchParams.toString();
     return this.request(`/api/workflows${queryString ? `?${queryString}` : ""}`);
   }
@@ -2954,16 +3181,22 @@ var MastraClient = class extends BaseResource {
   }
   /**
    * Retrieves a list of available MCP servers.
-   * @param params - Optional parameters for pagination (perPage, page).
+   * @param params - Optional parameters for pagination (page, perPage, or deprecated offset, limit).
    * @returns Promise containing the list of MCP servers and pagination info.
    */
   getMcpServers(params) {
     const searchParams = new URLSearchParams();
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
+    }
     if (params?.perPage !== void 0) {
       searchParams.set("perPage", String(params.perPage));
     }
-    if (params?.page !== void 0) {
-      searchParams.set("page", String(params.page));
+    if (params?.limit !== void 0) {
+      searchParams.set("limit", String(params.limit));
+    }
+    if (params?.offset !== void 0) {
+      searchParams.set("offset", String(params.offset));
     }
     const queryString = searchParams.toString();
     return this.request(`/api/mcp/v0/servers${queryString ? `?${queryString}` : ""}`);
@@ -3163,6 +3396,52 @@ var MastraClient = class extends BaseResource {
   score(params) {
     return this.observability.score(params);
   }
+  // ============================================================================
+  // Stored Agents
+  // ============================================================================
+  /**
+   * Lists all stored agents with optional pagination
+   * @param params - Optional pagination and ordering parameters
+   * @returns Promise containing paginated list of stored agents
+   */
+  listStoredAgents(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
+    }
+    if (params?.perPage !== void 0) {
+      searchParams.set("perPage", String(params.perPage));
+    }
+    if (params?.orderBy) {
+      if (params.orderBy.field) {
+        searchParams.set("orderBy[field]", params.orderBy.field);
+      }
+      if (params.orderBy.direction) {
+        searchParams.set("orderBy[direction]", params.orderBy.direction);
+      }
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/stored/agents${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Creates a new stored agent
+   * @param params - Agent configuration including id, name, instructions, model, etc.
+   * @returns Promise containing the created stored agent
+   */
+  createStoredAgent(params) {
+    return this.request("/api/stored/agents", {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Gets a stored agent instance by ID for further operations (details, update, delete)
+   * @param storedAgentId - ID of the stored agent to retrieve
+   * @returns StoredAgent instance
+   */
+  getStoredAgent(storedAgentId) {
+    return new StoredAgent(this.options, storedAgentId);
+  }
 };
 
 // src/tools.ts