@mastra/client-js 0.1.9-alpha.1 → 0.1.9

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @mastra/client-js@0.1.9-alpha.1 build /home/runner/work/mastra/mastra/client-sdks/client-js
+> @mastra/client-js@0.1.9-alpha.2 build /home/runner/work/mastra/mastra/client-sdks/client-js
 > tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
@@ -9,11 +9,11 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 16.09 KB
-CJS ⚡️ Build success in 847ms
-ESM dist/index.js 16.00 KB
-ESM ⚡️ Build success in 848ms
+ESM dist/index.js 17.49 KB
+ESM ⚡️ Build success in 847ms
+CJS dist/index.cjs 17.58 KB
+CJS ⚡️ Build success in 848ms
 DTS Build start
-DTS ⚡️ Build success in 10169ms
-DTS dist/index.d.ts  14.79 KB
-DTS dist/index.d.cts 14.79 KB
+DTS ⚡️ Build success in 11271ms
+DTS dist/index.d.ts  16.15 KB
+DTS dist/index.d.cts 16.15 KB

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @mastra/client-js
 
+## 0.1.9
+
+### Patch Changes
+
+- 0850b4c: Watch and resume per run
+- 4356859: Bump types from core so it can pass instructions optionally
+- Updated dependencies [fc2f89c]
+- Updated dependencies [dfbb131]
+- Updated dependencies [f4854ee]
+- Updated dependencies [afaf73f]
+- Updated dependencies [0850b4c]
+- Updated dependencies [7bcfaee]
+- Updated dependencies [44631b1]
+- Updated dependencies [9116d70]
+- Updated dependencies [6e559a0]
+- Updated dependencies [5f43505]
+  - @mastra/core@0.6.1
+
+## 0.1.9-alpha.2
+
+### Patch Changes
+
+- 0850b4c: Watch and resume per run
+- Updated dependencies [fc2f89c]
+- Updated dependencies [dfbb131]
+- Updated dependencies [0850b4c]
+- Updated dependencies [9116d70]
+  - @mastra/core@0.6.1-alpha.2
+
 ## 0.1.9-alpha.1
 
 ### Patch Changes

package/README.md

@@ -79,10 +79,12 @@ const client = new MastraClient({
 - `getWorkflows()`: Get all workflows
 - `getWorkflow(workflowId)`: Get a workflow instance
   - `workflow.details()`: Get workflow details
-  - `workflow.execute(params)`: Execute the workflow and wait for execution results
-  - `workflow.startRun()`: Start a new workflow run
-  - `workflow.watch(params)`: Watch the workflow run
-  - `workflow.resume(params)`: Resume the workflow run
+  - `workflow.createRun()`: Create workflow run
+  - `workflow.startAsync(params)`: Execute the workflow and wait for execution results
+  - `workflow.resumeAsync(parmas)`: Resume suspended workflow step async
+  - `workflow.watch({runId},(record)=>{})`: Watch the step transitions of the workflow run
+  - `workflow.start({runId, triggerData})`: Start a workflow run sync
+  - `workflow.resume(params)`: Resume the workflow run sync
 
 ### Vectors
 

package/dist/index.cjs

@@ -267,18 +267,31 @@ var Workflow = class extends BaseResource {
     });
   }
   /**
-   * Creates a new workflow run instance and starts it
-   * @param params - Parameters required for the workflow run
+   * Creates a new workflow run
    * @returns Promise containing the generated run ID
    */
-  startRun(params) {
-    return this.request(`/api/workflows/${this.workflowId}/startRun`, {
+  createRun(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    return this.request(`/api/workflows/${this.workflowId}/createRun?${searchParams.toString()}`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Starts a workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the runId and triggerData
+   * @returns Promise containing success message
+   */
+  start(params) {
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
-      body: params
+      body: params?.triggerData
     });
   }
   /**
-   * Resumes a suspended workflow step
+   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
    * @param stepId - ID of the step to resume
    * @param runId - ID of the workflow run
    * @param context - Context to resume the workflow with
@@ -297,6 +310,31 @@ 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 runId and triggerData
+   * @returns Promise containing the workflow execution results
+   */
+  startAsync(params) {
+    return this.request(`/api/workflows/${this.workflowId}/startAsync?runId=${params.runId}`, {
+      method: "POST",
+      body: params?.triggerData
+    });
+  }
+  /**
+   * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the runId, stepId, and context
+   * @returns Promise containing the workflow resume results
+   */
+  resumeAsync(params) {
+    return this.request(`/api/workflows/${this.workflowId}/resumeAsync?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        stepId: params.stepId,
+        context: params.context
+      }
+    });
+  }
   /**
    * Creates an async generator that processes a readable stream and yields records
    * separated by the Record Separator character (\x1E)
@@ -329,7 +367,7 @@ var Workflow = class extends BaseResource {
             try {
               const parsedRecord = JSON.parse(record);
               const isWorkflowCompleted = parsedRecord?.activePaths?.every(
-                (path) => path.status === "completed" || path.status === "suspended" || path.status === "failed"
+                (path) => path.status === "completed" || path.status === "suspended" || path.status === "failed" || path.status === "skipped"
               );
               if (isWorkflowCompleted) {
                 reader.cancel();
@@ -350,7 +388,7 @@ var Workflow = class extends BaseResource {
    * @param runId - Optional run ID to filter the watch stream
    * @returns AsyncGenerator that yields parsed records from the workflow watch stream
    */
-  async *watch({ runId }) {
+  async watch({ runId }, onRecord) {
     const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
       stream: true
     });
@@ -360,7 +398,9 @@ var Workflow = class extends BaseResource {
     if (!response.body) {
       throw new Error("Response body is null");
     }
-    yield* this.streamProcessor(response.body);
+    for await (const record of this.streamProcessor(response.body)) {
+      onRecord(record);
+    }
   }
 };
 

package/dist/index.d.cts

@@ -20,6 +20,7 @@ interface RequestOptions {
     headers?: Record<string, string>;
     body?: any;
     stream?: boolean;
+    signal?: AbortSignal;
 }
 interface GetAgentResponse {
     name: string;
@@ -58,7 +59,15 @@ type WorkflowRunResult = {
     }>;
     context: {
         steps: Record<string, {
-            status: 'completed' | 'suspended' | 'running';
+            status: 'success';
+            output: any;
+            [key: string]: any;
+        } | {
+            status: 'pending';
+            [key: string]: any;
+        } | {
+            status: 'suspended';
+            suspendPayload: any;
             [key: string]: any;
         }>;
     };
@@ -279,15 +288,27 @@ declare class Workflow extends BaseResource {
      */
     execute(params: Record<string, any>): Promise<WorkflowRunResult>;
     /**
-     * Creates a new workflow run instance and starts it
-     * @param params - Parameters required for the workflow run
+     * Creates a new workflow run
      * @returns Promise containing the generated run ID
      */
-    startRun(params: Record<string, any>): Promise<{
+    createRun(params?: {
+        runId?: string;
+    }): Promise<{
         runId: string;
     }>;
     /**
-     * Resumes a suspended workflow step
+     * Starts a workflow run synchronously without waiting for the workflow to complete
+     * @param params - Object containing the runId and triggerData
+     * @returns Promise containing success message
+     */
+    start(params: {
+        runId: string;
+        triggerData: Record<string, any>;
+    }): Promise<{
+        message: string;
+    }>;
+    /**
+     * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
      * @param stepId - ID of the step to resume
      * @param runId - ID of the workflow run
      * @param context - Context to resume the workflow with
@@ -297,7 +318,28 @@ declare class Workflow extends BaseResource {
         stepId: string;
         runId: string;
         context: Record<string, any>;
-    }): Promise<Record<string, any>>;
+    }): Promise<{
+        message: string;
+    }>;
+    /**
+     * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
+     * @param params - Object containing the runId and triggerData
+     * @returns Promise containing the workflow execution results
+     */
+    startAsync(params: {
+        runId: string;
+        triggerData: Record<string, any>;
+    }): Promise<WorkflowRunResult>;
+    /**
+     * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
+     * @param params - Object containing the runId, stepId, and context
+     * @returns Promise containing the workflow resume results
+     */
+    resumeAsync(params: {
+        runId: string;
+        stepId: string;
+        context: Record<string, any>;
+    }): Promise<WorkflowRunResult>;
     /**
      * Creates an async generator that processes a readable stream and yields records
      * separated by the Record Separator character (\x1E)
@@ -313,7 +355,7 @@ declare class Workflow extends BaseResource {
      */
     watch({ runId }: {
         runId?: string;
-    }): AsyncGenerator<WorkflowRunResult, void, unknown>;
+    }, onRecord: (record: WorkflowRunResult) => void): Promise<void>;
 }
 
 declare class Tool extends BaseResource {

package/dist/index.d.ts

@@ -20,6 +20,7 @@ interface RequestOptions {
     headers?: Record<string, string>;
     body?: any;
     stream?: boolean;
+    signal?: AbortSignal;
 }
 interface GetAgentResponse {
     name: string;
@@ -58,7 +59,15 @@ type WorkflowRunResult = {
     }>;
     context: {
         steps: Record<string, {
-            status: 'completed' | 'suspended' | 'running';
+            status: 'success';
+            output: any;
+            [key: string]: any;
+        } | {
+            status: 'pending';
+            [key: string]: any;
+        } | {
+            status: 'suspended';
+            suspendPayload: any;
             [key: string]: any;
         }>;
     };
@@ -279,15 +288,27 @@ declare class Workflow extends BaseResource {
      */
     execute(params: Record<string, any>): Promise<WorkflowRunResult>;
     /**
-     * Creates a new workflow run instance and starts it
-     * @param params - Parameters required for the workflow run
+     * Creates a new workflow run
      * @returns Promise containing the generated run ID
      */
-    startRun(params: Record<string, any>): Promise<{
+    createRun(params?: {
+        runId?: string;
+    }): Promise<{
         runId: string;
     }>;
     /**
-     * Resumes a suspended workflow step
+     * Starts a workflow run synchronously without waiting for the workflow to complete
+     * @param params - Object containing the runId and triggerData
+     * @returns Promise containing success message
+     */
+    start(params: {
+        runId: string;
+        triggerData: Record<string, any>;
+    }): Promise<{
+        message: string;
+    }>;
+    /**
+     * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
      * @param stepId - ID of the step to resume
      * @param runId - ID of the workflow run
      * @param context - Context to resume the workflow with
@@ -297,7 +318,28 @@ declare class Workflow extends BaseResource {
         stepId: string;
         runId: string;
         context: Record<string, any>;
-    }): Promise<Record<string, any>>;
+    }): Promise<{
+        message: string;
+    }>;
+    /**
+     * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
+     * @param params - Object containing the runId and triggerData
+     * @returns Promise containing the workflow execution results
+     */
+    startAsync(params: {
+        runId: string;
+        triggerData: Record<string, any>;
+    }): Promise<WorkflowRunResult>;
+    /**
+     * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
+     * @param params - Object containing the runId, stepId, and context
+     * @returns Promise containing the workflow resume results
+     */
+    resumeAsync(params: {
+        runId: string;
+        stepId: string;
+        context: Record<string, any>;
+    }): Promise<WorkflowRunResult>;
     /**
      * Creates an async generator that processes a readable stream and yields records
      * separated by the Record Separator character (\x1E)
@@ -313,7 +355,7 @@ declare class Workflow extends BaseResource {
      */
     watch({ runId }: {
         runId?: string;
-    }): AsyncGenerator<WorkflowRunResult, void, unknown>;
+    }, onRecord: (record: WorkflowRunResult) => void): Promise<void>;
 }
 
 declare class Tool extends BaseResource {

package/dist/index.js

@@ -265,18 +265,31 @@ var Workflow = class extends BaseResource {
     });
   }
   /**
-   * Creates a new workflow run instance and starts it
-   * @param params - Parameters required for the workflow run
+   * Creates a new workflow run
    * @returns Promise containing the generated run ID
    */
-  startRun(params) {
-    return this.request(`/api/workflows/${this.workflowId}/startRun`, {
+  createRun(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    return this.request(`/api/workflows/${this.workflowId}/createRun?${searchParams.toString()}`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Starts a workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the runId and triggerData
+   * @returns Promise containing success message
+   */
+  start(params) {
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
-      body: params
+      body: params?.triggerData
     });
   }
   /**
-   * Resumes a suspended workflow step
+   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
    * @param stepId - ID of the step to resume
    * @param runId - ID of the workflow run
    * @param context - Context to resume the workflow with
@@ -295,6 +308,31 @@ 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 runId and triggerData
+   * @returns Promise containing the workflow execution results
+   */
+  startAsync(params) {
+    return this.request(`/api/workflows/${this.workflowId}/startAsync?runId=${params.runId}`, {
+      method: "POST",
+      body: params?.triggerData
+    });
+  }
+  /**
+   * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the runId, stepId, and context
+   * @returns Promise containing the workflow resume results
+   */
+  resumeAsync(params) {
+    return this.request(`/api/workflows/${this.workflowId}/resumeAsync?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        stepId: params.stepId,
+        context: params.context
+      }
+    });
+  }
   /**
    * Creates an async generator that processes a readable stream and yields records
    * separated by the Record Separator character (\x1E)
@@ -327,7 +365,7 @@ var Workflow = class extends BaseResource {
             try {
               const parsedRecord = JSON.parse(record);
               const isWorkflowCompleted = parsedRecord?.activePaths?.every(
-                (path) => path.status === "completed" || path.status === "suspended" || path.status === "failed"
+                (path) => path.status === "completed" || path.status === "suspended" || path.status === "failed" || path.status === "skipped"
               );
               if (isWorkflowCompleted) {
                 reader.cancel();
@@ -348,7 +386,7 @@ var Workflow = class extends BaseResource {
    * @param runId - Optional run ID to filter the watch stream
    * @returns AsyncGenerator that yields parsed records from the workflow watch stream
    */
-  async *watch({ runId }) {
+  async watch({ runId }, onRecord) {
     const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
       stream: true
     });
@@ -358,7 +396,9 @@ var Workflow = class extends BaseResource {
     if (!response.body) {
       throw new Error("Response body is null");
     }
-    yield* this.streamProcessor(response.body);
+    for await (const record of this.streamProcessor(response.body)) {
+      onRecord(record);
+    }
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.1.9-alpha.1",
+  "version": "0.1.9",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -25,7 +25,7 @@
     "json-schema": "^0.4.0",
     "zod": "^3.24.2",
     "zod-to-json-schema": "^3.24.3",
-    "@mastra/core": "^0.6.1-alpha.1"
+    "@mastra/core": "^0.6.1"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.26.9",

package/src/example.ts

@@ -46,31 +46,29 @@ import type { WorkflowRunResult } from './types';
 // })();
 
 // Workflow
-
 // (async () => {
 //   const client = new MastraClient({
 //     baseUrl: 'http://localhost:4111',
 //   });
 
-//   let finalWorkflowResult: WorkflowRunResult | null = null;
+//   try {
+//     const workflowId = 'myWorkflow';
+//     const workflow = client.getWorkflow(workflowId);
 
-//   try{
-//     const workflowId = 'weatherWorkflow';
+//     const { runId } = await workflow.createRun();
 
-//     const workflow = client.getWorkflow(workflowId);
+//     workflow.watch({ runId }, record => {
+//       console.log(new Date().toTimeString(), record);
+//     });
 
-//     const {runId} = await workflow.startRun({
-//       city: 'New York',
+//     await workflow.start({
+//       runId,
+//       triggerData: {
+//         city: 'New York',
+//       },
 //     });
 
-//     for await (const record of workflow.watch({runId})) {
-//       console.log(new Date().toTimeString(), record);
-//       finalWorkflowResult = record;
-//     }
-//   }catch(e){
-//     console.log(e);
-//   }finally{
-//     console.log('Done')
-//     console.log({finalWorkflowResult});
+//   } catch (e) {
+//     console.error('Workflow error:', e);
 //   }
 // })();

package/src/resources/workflow.ts

@@ -31,19 +31,35 @@ export class Workflow extends BaseResource {
   }
 
   /**
-   * Creates a new workflow run instance and starts it
-   * @param params - Parameters required for the workflow run
+   * Creates a new workflow run
    * @returns Promise containing the generated run ID
    */
-  startRun(params: Record<string, any>): Promise<{ runId: string }> {
-    return this.request(`/api/workflows/${this.workflowId}/startRun`, {
+  createRun(params?: { runId?: string }): Promise<{ runId: string }> {
+    const searchParams = new URLSearchParams();
+
+    if (!!params?.runId) {
+      searchParams.set('runId', params.runId);
+    }
+
+    return this.request(`/api/workflows/${this.workflowId}/createRun?${searchParams.toString()}`, {
       method: 'POST',
-      body: params,
     });
   }
 
   /**
-   * Resumes a suspended workflow step
+   * Starts a workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the runId and triggerData
+   * @returns Promise containing success message
+   */
+  start(params: { runId: string; triggerData: Record<string, any> }): Promise<{ message: string }> {
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
+      method: 'POST',
+      body: params?.triggerData,
+    });
+  }
+
+  /**
+   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
    * @param stepId - ID of the step to resume
    * @param runId - ID of the workflow run
    * @param context - Context to resume the workflow with
@@ -57,7 +73,7 @@ export class Workflow extends BaseResource {
     stepId: string;
     runId: string;
     context: Record<string, any>;
-  }): Promise<Record<string, any>> {
+  }): Promise<{ message: string }> {
     return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: 'POST',
       body: {
@@ -67,6 +83,33 @@ export class Workflow extends BaseResource {
     });
   }
 
+  /**
+   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the runId and triggerData
+   * @returns Promise containing the workflow execution results
+   */
+  startAsync(params: { runId: string; triggerData: Record<string, any> }): Promise<WorkflowRunResult> {
+    return this.request(`/api/workflows/${this.workflowId}/startAsync?runId=${params.runId}`, {
+      method: 'POST',
+      body: params?.triggerData,
+    });
+  }
+
+  /**
+   * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the runId, stepId, and context
+   * @returns Promise containing the workflow resume results
+   */
+  resumeAsync(params: { runId: string; stepId: string; context: Record<string, any> }): Promise<WorkflowRunResult> {
+    return this.request(`/api/workflows/${this.workflowId}/resumeAsync?runId=${params.runId}`, {
+      method: 'POST',
+      body: {
+        stepId: params.stepId,
+        context: params.context,
+      },
+    });
+  }
+
   /**
    * Creates an async generator that processes a readable stream and yields records
    * separated by the Record Separator character (\x1E)
@@ -113,7 +156,11 @@ export class Workflow extends BaseResource {
 
               //Check to see if all steps are completed and cancel reader
               const isWorkflowCompleted = parsedRecord?.activePaths?.every(
-                (path: any) => path.status === 'completed' || path.status === 'suspended' || path.status === 'failed',
+                (path: any) =>
+                  path.status === 'completed' ||
+                  path.status === 'suspended' ||
+                  path.status === 'failed' ||
+                  path.status === 'skipped',
               );
               if (isWorkflowCompleted) {
                 reader.cancel();
@@ -135,7 +182,7 @@ export class Workflow extends BaseResource {
    * @param runId - Optional run ID to filter the watch stream
    * @returns AsyncGenerator that yields parsed records from the workflow watch stream
    */
-  async *watch({ runId }: { runId?: string }) {
+  async watch({ runId }: { runId?: string }, onRecord: (record: WorkflowRunResult) => void) {
     const response: Response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
       stream: true,
     });
@@ -148,6 +195,8 @@ export class Workflow extends BaseResource {
       throw new Error('Response body is null');
     }
 
-    yield* this.streamProcessor(response.body);
+    for await (const record of this.streamProcessor(response.body)) {
+      onRecord(record);
+    }
   }
 }

package/src/types.ts

@@ -25,6 +25,7 @@ export interface ClientOptions {
   maxBackoffMs?: number;
   /** Custom headers to include with requests */
   headers?: Record<string, string>;
+  /** Abort signal for request */
 }
 
 export interface RequestOptions {
@@ -32,6 +33,7 @@ export interface RequestOptions {
   headers?: Record<string, string>;
   body?: any;
   stream?: boolean;
+  signal?: AbortSignal;
 }
 
 export interface GetAgentResponse {
@@ -78,10 +80,20 @@ export type WorkflowRunResult = {
   context: {
     steps: Record<
       string,
-      {
-        status: 'completed' | 'suspended' | 'running';
-        [key: string]: any;
-      }
+      | {
+          status: 'success';
+          output: any;
+          [key: string]: any;
+        }
+      | {
+          status: 'pending';
+          [key: string]: any;
+        }
+      | {
+          status: 'suspended';
+          suspendPayload: any;
+          [key: string]: any;
+        }
     >;
   };
   timestamp: number;