@mastra/client-js 0.16.16-alpha.0 → 0.17.0-alpha.2

package/dist/index.js

@@ -3,8 +3,7 @@ import { v4 } from '@lukeed/uuid';
 import { getErrorFromUnknown } from '@mastra/core/error';
 import { RuntimeContext } from '@mastra/core/runtime-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 parseClientRuntimeContext(runtimeContext) {
@@ -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" } : {},
@@ -2211,6 +2215,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 runtimeContext
+   * @returns Promise containing success message
+   */
+  restart(params) {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        runtimeContext,
+        tracingOptions: params.tracingOptions
+      }
+    });
+  }
+  /**
+   * Restarts an active workflow run asynchronously
+   * @param params - Object containing the runId and runtimeContext
+   * @returns Promise containing the workflow restart results
+   */
+  restartAsync(params) {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart-async?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        runtimeContext,
+        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, runtimeContext and tracingOptions
+   * @returns Promise containing success message
+   */
+  timeTravel({
+    runId,
+    runtimeContext: paramsRuntimeContext,
+    ...params
+  }) {
+    const runtimeContext = parseClientRuntimeContext(paramsRuntimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/time-travel?runId=${runId}`, {
+      method: "POST",
+      body: {
+        ...params,
+        runtimeContext
+      }
+    });
+  }
+  /**
+   * Time travels a workflow run asynchronously
+   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, runtimeContext and tracingOptions
+   * @returns Promise containing the workflow time travel results
+   */
+  timeTravelAsync({
+    runId,
+    runtimeContext: paramsRuntimeContext,
+    ...params
+  }) {
+    const runtimeContext = parseClientRuntimeContext(paramsRuntimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/time-travel-async?runId=${runId}`, {
+      method: "POST",
+      body: {
+        ...params,
+        runtimeContext
+      }
+    });
+  }
+  /**
+   * Time travels a workflow run and returns a stream
+   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, runtimeContext and tracingOptions
+   * @returns Promise containing the workflow execution results
+   */
+  async timeTravelStream({ runId, runtimeContext: paramsRuntimeContext, ...params }) {
+    const runtimeContext = parseClientRuntimeContext(paramsRuntimeContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/time-travel-stream?runId=${runId}`,
+      {
+        method: "POST",
+        body: {
+          ...params,
+          runtimeContext
+        },
+        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
@@ -2841,14 +2981,18 @@ var MastraClient = class extends BaseResource {
   /**
    * Retrieves all available agents
    * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param partial - Optional flag to return minimal data without schemas
    * @returns Promise containing map of agent IDs to agent details
    */
-  getAgents(runtimeContext) {
+  getAgents(runtimeContext, partial) {
     const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
     const searchParams = new URLSearchParams();
     if (runtimeContextParam) {
       searchParams.set("runtimeContext", runtimeContextParam);
     }
+    if (partial) {
+      searchParams.set("partial", "true");
+    }
     const queryString = searchParams.toString();
     return this.request(`/api/agents${queryString ? `?${queryString}` : ""}`);
   }
@@ -3007,14 +3151,18 @@ var MastraClient = class extends BaseResource {
   /**
    * Retrieves all available workflows
    * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param partial - Optional flag to return minimal data without schemas
    * @returns Promise containing map of workflow IDs to workflow details
    */
-  getWorkflows(runtimeContext) {
+  getWorkflows(runtimeContext, partial) {
     const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
     const searchParams = new URLSearchParams();
     if (runtimeContextParam) {
       searchParams.set("runtimeContext", runtimeContextParam);
     }
+    if (partial) {
+      searchParams.set("partial", "true");
+    }
     const queryString = searchParams.toString();
     return this.request(`/api/workflows${queryString ? `?${queryString}` : ""}`);
   }