@mastra/client-js 0.1.23-alpha.0 → 0.10.0

package/src/resources/{vnext-workflow.ts → legacy-workflow.ts}

@@ -1,18 +1,16 @@
-import type { RuntimeContext } from '@mastra/core/runtime-context';
 import type {
   ClientOptions,
-  GetVNextWorkflowResponse,
-  GetVNextWorkflowRunsResponse,
+  LegacyWorkflowRunResult,
+  GetLegacyWorkflowRunsResponse,
   GetWorkflowRunsParams,
-  VNextWorkflowRunResult,
-  VNextWorkflowWatchResult,
+  GetLegacyWorkflowResponse,
 } from '../types';
 
 import { BaseResource } from './base';
 
 const RECORD_SEPARATOR = '\x1E';
 
-export class VNextWorkflow extends BaseResource {
+export class LegacyWorkflow extends BaseResource {
   constructor(
     options: ClientOptions,
     private workflowId: string,
@@ -21,90 +19,19 @@ export class VNextWorkflow extends BaseResource {
   }
 
   /**
-   * Creates an async generator that processes a readable stream and yields vNext workflow records
-   * separated by the Record Separator character (\x1E)
-   *
-   * @param stream - The readable stream to process
-   * @returns An async generator that yields parsed records
+   * Retrieves details about the legacy workflow
+   * @returns Promise containing legacy workflow details including steps and graphs
    */
-  private async *streamProcessor(stream: ReadableStream): AsyncGenerator<VNextWorkflowWatchResult, void, unknown> {
-    const reader = stream.getReader();
-
-    // Track if we've finished reading from the stream
-    let doneReading = false;
-    // Buffer to accumulate partial chunks
-    let buffer = '';
-
-    try {
-      while (!doneReading) {
-        // Read the next chunk from the stream
-        const { done, value } = await reader.read();
-        doneReading = done;
-
-        // Skip processing if we're done and there's no value
-        if (done && !value) continue;
-
-        try {
-          // Decode binary data to text
-          const decoded = value ? new TextDecoder().decode(value) : '';
-
-          // Split the combined buffer and new data by record separator
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
-
-          // The last chunk might be incomplete, so save it for the next iteration
-          buffer = chunks.pop() || '';
-
-          // Process complete chunks
-          for (const chunk of chunks) {
-            if (chunk) {
-              // Only process non-empty chunks
-              if (typeof chunk === 'string') {
-                try {
-                  const parsedChunk = JSON.parse(chunk);
-                  yield parsedChunk;
-                } catch {
-                  // Silently ignore parsing errors to maintain stream processing
-                  // This allows the stream to continue even if one record is malformed
-                }
-              }
-            }
-          }
-        } catch {
-          // Silently ignore parsing errors to maintain stream processing
-          // This allows the stream to continue even if one record is malformed
-        }
-      }
-
-      // Process any remaining data in the buffer after stream is done
-      if (buffer) {
-        try {
-          yield JSON.parse(buffer);
-        } catch {
-          // Ignore parsing error for final chunk
-        }
-      }
-    } finally {
-      // Always ensure we clean up the reader
-      reader.cancel().catch(() => {
-        // Ignore cancel errors
-      });
-    }
-  }
-
-  /**
-   * Retrieves details about the vNext workflow
-   * @returns Promise containing vNext workflow details including steps and graphs
-   */
-  details(): Promise<GetVNextWorkflowResponse> {
-    return this.request(`/api/workflows/v-next/${this.workflowId}`);
+  details(): Promise<GetLegacyWorkflowResponse> {
+    return this.request(`/api/workflows/legacy/${this.workflowId}`);
   }
 
   /**
-   * Retrieves all runs for a vNext workflow
+   * Retrieves all runs for a legacy workflow
    * @param params - Parameters for filtering runs
-   * @returns Promise containing vNext workflow runs array
+   * @returns Promise containing legacy workflow runs array
    */
-  runs(params?: GetWorkflowRunsParams): Promise<GetVNextWorkflowRunsResponse> {
+  runs(params?: GetWorkflowRunsParams): Promise<GetLegacyWorkflowRunsResponse> {
     const searchParams = new URLSearchParams();
     if (params?.fromDate) {
       searchParams.set('fromDate', params.fromDate.toISOString());
@@ -123,16 +50,15 @@ export class VNextWorkflow extends BaseResource {
     }
 
     if (searchParams.size) {
-      return this.request(`/api/workflows/v-next/${this.workflowId}/runs?${searchParams}`);
+      return this.request(`/api/workflows/legacy/${this.workflowId}/runs?${searchParams}`);
     } else {
-      return this.request(`/api/workflows/v-next/${this.workflowId}/runs`);
+      return this.request(`/api/workflows/legacy/${this.workflowId}/runs`);
     }
   }
 
   /**
-   * Creates a new vNext workflow run
-   * @param params - Optional object containing the optional runId
-   * @returns Promise containing the runId of the created run
+   * Creates a new legacy workflow run
+   * @returns Promise containing the generated run ID
    */
   createRun(params?: { runId?: string }): Promise<{ runId: string }> {
     const searchParams = new URLSearchParams();
@@ -141,113 +67,168 @@ export class VNextWorkflow extends BaseResource {
       searchParams.set('runId', params.runId);
     }
 
-    return this.request(`/api/workflows/v-next/${this.workflowId}/create-run?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/create-run?${searchParams.toString()}`, {
       method: 'POST',
     });
   }
 
   /**
-   * Starts a vNext workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId, inputData and runtimeContext
+   * Starts a legacy 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;
-    inputData: Record<string, any>;
-    runtimeContext?: RuntimeContext;
-  }): Promise<{ message: string }> {
-    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined;
-    return this.request(`/api/workflows/v-next/${this.workflowId}/start?runId=${params.runId}`, {
+  start(params: { runId: string; triggerData: Record<string, any> }): Promise<{ message: string }> {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/start?runId=${params.runId}`, {
       method: 'POST',
-      body: { inputData: params?.inputData, runtimeContext },
+      body: params?.triggerData,
     });
   }
 
   /**
-   * Resumes a suspended vNext workflow step synchronously without waiting for the vNext workflow to complete
-   * @param params - Object containing the runId, step, resumeData and runtimeContext
-   * @returns Promise containing success message
+   * Resumes a suspended legacy workflow step synchronously without waiting for the workflow to complete
+   * @param stepId - ID of the step to resume
+   * @param runId - ID of the legacy workflow run
+   * @param context - Context to resume the legacy workflow with
+   * @returns Promise containing the legacy workflow resume results
    */
   resume({
-    step,
+    stepId,
     runId,
-    resumeData,
-    ...rest
+    context,
   }: {
-    step: string | string[];
+    stepId: string;
     runId: string;
-    resumeData?: Record<string, any>;
-    runtimeContext?: RuntimeContext;
+    context: Record<string, any>;
   }): Promise<{ message: string }> {
-    const runtimeContext = rest.runtimeContext ? Object.fromEntries(rest.runtimeContext.entries()) : undefined;
-    return this.request(`/api/workflows/v-next/${this.workflowId}/resume?runId=${runId}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/resume?runId=${runId}`, {
       method: 'POST',
-      stream: true,
       body: {
-        step,
-        resumeData,
-        runtimeContext,
+        stepId,
+        context,
       },
     });
   }
 
   /**
-   * Starts a vNext workflow run asynchronously and returns a promise that resolves when the vNext workflow is complete
-   * @param params - Object containing the optional runId, inputData and runtimeContext
-   * @returns Promise containing the vNext workflow execution results
+   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the optional runId and triggerData
+   * @returns Promise containing the workflow execution results
    */
-  startAsync(params: {
-    runId?: string;
-    inputData: Record<string, any>;
-    runtimeContext?: RuntimeContext;
-  }): Promise<VNextWorkflowRunResult> {
+  startAsync(params: { runId?: string; triggerData: Record<string, any> }): Promise<LegacyWorkflowRunResult> {
     const searchParams = new URLSearchParams();
 
     if (!!params?.runId) {
       searchParams.set('runId', params.runId);
     }
 
-    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined;
-    return this.request(`/api/workflows/v-next/${this.workflowId}/start-async?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: 'POST',
-      body: { inputData: params.inputData, runtimeContext },
+      body: params?.triggerData,
     });
   }
 
   /**
-   * Resumes a suspended vNext workflow step asynchronously and returns a promise that resolves when the vNext workflow is complete
-   * @param params - Object containing the runId, step, resumeData and runtimeContext
-   * @returns Promise containing the vNext workflow resume results
+   * Resumes a suspended legacy 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;
-    step: string | string[];
-    resumeData?: Record<string, any>;
-    runtimeContext?: RuntimeContext;
-  }): Promise<VNextWorkflowRunResult> {
-    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined;
-    return this.request(`/api/workflows/v-next/${this.workflowId}/resume-async?runId=${params.runId}`, {
+    stepId: string;
+    context: Record<string, any>;
+  }): Promise<LegacyWorkflowRunResult> {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/resume-async?runId=${params.runId}`, {
       method: 'POST',
       body: {
-        step: params.step,
-        resumeData: params.resumeData,
-        runtimeContext,
+        stepId: params.stepId,
+        context: params.context,
       },
     });
   }
 
   /**
-   * Watches vNext workflow transitions in real-time
+   * Creates an async generator that processes a readable stream and yields records
+   * separated by the Record Separator character (\x1E)
+   *
+   * @param stream - The readable stream to process
+   * @returns An async generator that yields parsed records
+   */
+  private async *streamProcessor(stream: ReadableStream): AsyncGenerator<LegacyWorkflowRunResult, void, unknown> {
+    const reader = stream.getReader();
+
+    // Track if we've finished reading from the stream
+    let doneReading = false;
+    // Buffer to accumulate partial chunks
+    let buffer = '';
+
+    try {
+      while (!doneReading) {
+        // Read the next chunk from the stream
+        const { done, value } = await reader.read();
+        doneReading = done;
+
+        // Skip processing if we're done and there's no value
+        if (done && !value) continue;
+
+        try {
+          // Decode binary data to text
+          const decoded = value ? new TextDecoder().decode(value) : '';
+
+          // Split the combined buffer and new data by record separator
+          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
+
+          // The last chunk might be incomplete, so save it for the next iteration
+          buffer = chunks.pop() || '';
+
+          // Process complete chunks
+          for (const chunk of chunks) {
+            if (chunk) {
+              // Only process non-empty chunks
+              if (typeof chunk === 'string') {
+                try {
+                  const parsedChunk = JSON.parse(chunk);
+                  yield parsedChunk;
+                } catch {
+                  // Silently ignore parsing errors to maintain stream processing
+                  // This allows the stream to continue even if one record is malformed
+                }
+              }
+            }
+          }
+        } catch {
+          // Silently ignore parsing errors to maintain stream processing
+          // This allows the stream to continue even if one record is malformed
+        }
+      }
+
+      // Process any remaining data in the buffer after stream is done
+      if (buffer) {
+        try {
+          yield JSON.parse(buffer);
+        } catch {
+          // Ignore parsing error for final chunk
+        }
+      }
+    } finally {
+      // Always ensure we clean up the reader
+      reader.cancel().catch(() => {
+        // Ignore cancel errors
+      });
+    }
+  }
+
+  /**
+   * Watches legacy workflow transitions in real-time
    * @param runId - Optional run ID to filter the watch stream
-   * @returns AsyncGenerator that yields parsed records from the vNext workflow watch stream
+   * @returns AsyncGenerator that yields parsed records from the legacy workflow watch stream
    */
-  async watch({ runId }: { runId?: string }, onRecord: (record: VNextWorkflowWatchResult) => void) {
-    const response: Response = await this.request(`/api/workflows/v-next/${this.workflowId}/watch?runId=${runId}`, {
+  async watch({ runId }: { runId?: string }, onRecord: (record: LegacyWorkflowRunResult) => void) {
+    const response: Response = await this.request(`/api/workflows/legacy/${this.workflowId}/watch?runId=${runId}`, {
       stream: true,
     });
 
     if (!response.ok) {
-      throw new Error(`Failed to watch vNext workflow: ${response.statusText}`);
+      throw new Error(`Failed to watch legacy workflow: ${response.statusText}`);
     }
 
     if (!response.body) {

package/src/resources/tool.ts

@@ -1,7 +1,8 @@
-import type { RuntimeContext } from '@mastra/core/di';
+import type { RuntimeContext } from '@mastra/core/runtime-context';
 import type { GetToolResponse, ClientOptions } from '../types';
 
 import { BaseResource } from './base';
+import { parseClientRuntimeContext } from '../utils';
 
 export class Tool extends BaseResource {
   constructor(
@@ -24,7 +25,7 @@ export class Tool extends BaseResource {
    * @param params - Parameters required for tool execution
    * @returns Promise containing the tool execution results
    */
-  execute(params: { data: any; runId?: string; runtimeContext?: RuntimeContext }): Promise<any> {
+  execute(params: { data: any; runId?: string; runtimeContext?: RuntimeContext | Record<string, any> }): Promise<any> {
     const url = new URLSearchParams();
 
     if (params.runId) {
@@ -33,7 +34,7 @@ export class Tool extends BaseResource {
 
     const body = {
       data: params.data,
-      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
     };
 
     return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {