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

package/dist/index.js

@@ -3,8 +3,7 @@ import { v4 } from '@lukeed/uuid';
 import { getErrorFromUnknown } from '@mastra/core/error';
 import { RequestContext } from '@mastra/core/request-context';
 import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
-import { z } from 'zod';
-import originalZodToJsonSchema from 'zod-to-json-schema';
+import { zodToJsonSchema as zodToJsonSchema$1 } from '@mastra/schema-compat/zod-to-json';
 
 // src/resources/agent.ts
 function parseClientRequestContext(requestContext) {
@@ -37,11 +36,7 @@ function zodToJsonSchema(zodSchema) {
   if (!isZodType(zodSchema)) {
     return zodSchema;
   }
-  if ("toJSONSchema" in z) {
-    const fn = "toJSONSchema";
-    return z[fn].call(z, zodSchema);
-  }
-  return originalZodToJsonSchema(zodSchema, { $refStrategy: "relative" });
+  return zodToJsonSchema$1(zodSchema);
 }
 
 // src/utils/process-client-tools.ts
@@ -144,11 +139,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" } : {},
@@ -787,7 +791,7 @@ var Agent = class extends BaseResource {
           case "tripwire": {
             message.parts.push({
               type: "text",
-              text: chunk.payload.tripwireReason
+              text: chunk.payload.reason
             });
             execUpdate();
             break;
@@ -1452,7 +1456,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);
   }
   /**
@@ -1611,15 +1615,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);
@@ -1642,6 +1652,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
@@ -1686,6 +1706,7 @@ var Workflow = class extends BaseResource {
         return this.start({
           runId,
           inputData: p.inputData,
+          initialState: p.initialState,
           requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
@@ -1694,12 +1715,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({
@@ -1731,14 +1758,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
+      }
     });
   }
   /**
@@ -1766,7 +1798,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) {
@@ -1777,12 +1809,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) {
@@ -1795,7 +1832,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
       }
     );
@@ -1880,7 +1922,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) {
@@ -1895,6 +1937,7 @@ var Workflow = class extends BaseResource {
         method: "POST",
         body: {
           inputData: params.inputData,
+          initialState: params.initialState,
           requestContext,
           closeOnSuspend: params.closeOnSuspend,
           tracingOptions: params.tracingOptions
@@ -2075,6 +2118,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
@@ -2117,7 +2296,8 @@ var A2A = class extends BaseResource {
       body: {
         method: "message/stream",
         params
-      }
+      },
+      stream: true
     });
     return response;
   }
@@ -2548,6 +2728,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);
     }
@@ -2654,6 +2844,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;
@@ -2666,12 +2891,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}` : ""}`);
   }
@@ -2813,12 +3041,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}` : ""}`);
   }
@@ -2948,16 +3179,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}` : ""}`);
@@ -3157,6 +3394,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