@mastra/client-js 0.0.0-default-storage-virtual-file-20250410035748 → 0.0.0-expose-more-playground-ui-20250502050852

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.0.0-default-storage-virtual-file-20250410035748",
+  "version": "0.0.0-expose-more-playground-ui-20250502050852",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -20,13 +20,16 @@
     "./package.json": "./package.json"
   },
   "repository": "github:mastra-ai/client-js",
-  "license": "ISC",
+  "license": "Elastic-2.0",
   "dependencies": {
     "@ai-sdk/ui-utils": "^1.1.19",
     "json-schema": "^0.4.0",
     "zod": "^3.24.2",
     "zod-to-json-schema": "^3.24.3",
-    "@mastra/core": "0.0.0-default-storage-virtual-file-20250410035748"
+    "@mastra/core": "0.0.0-expose-more-playground-ui-20250502050852"
+  },
+  "peerDependencies": {
+    "zod": "^3.24.2"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.26.9",
@@ -36,8 +39,8 @@
     "@types/node": "^20.17.27",
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
-    "vitest": "^3.0.9",
-    "@internal/lint": "0.0.1"
+    "vitest": "^3.1.2",
+    "@internal/lint": "0.0.2"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting",

package/src/client.ts

@@ -1,4 +1,4 @@
-import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource, Network } from './resources';
+import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource, Network, VNextWorkflow } from './resources';
 import type {
   ClientOptions,
   CreateMemoryThreadParams,
@@ -13,8 +13,8 @@ import type {
   GetTelemetryParams,
   GetTelemetryResponse,
   GetToolResponse,
+  GetVNextWorkflowResponse,
   GetWorkflowResponse,
-  RequestOptions,
   SaveMessageToMemoryParams,
   SaveMessageToMemoryResponse,
 } from './types';
@@ -122,6 +122,23 @@ export class MastraClient extends BaseResource {
     return new Workflow(this.options, workflowId);
   }
 
+  /**
+   * Retrieves all available vNext workflows
+   * @returns Promise containing map of vNext workflow IDs to vNext workflow details
+   */
+  public getVNextWorkflows(): Promise<Record<string, GetVNextWorkflowResponse>> {
+    return this.request('/api/workflows/v-next');
+  }
+
+  /**
+   * Gets a vNext workflow instance by ID
+   * @param workflowId - ID of the vNext workflow to retrieve
+   * @returns vNext Workflow instance
+   */
+  public getVNextWorkflow(workflowId: string) {
+    return new VNextWorkflow(this.options, workflowId);
+  }
+
   /**
    * Gets a vector instance by name
    * @param vectorName - Name of the vector to retrieve
@@ -166,14 +183,6 @@ export class MastraClient extends BaseResource {
     const { name, scope, page, perPage, attribute } = params || {};
     const _attribute = attribute ? Object.entries(attribute).map(([key, value]) => `${key}:${value}`) : [];
 
-    const queryObj = {
-      ...(name ? { name } : {}),
-      ...(scope ? { scope } : {}),
-      ...(page ? { page: String(page) } : {}),
-      ...(perPage ? { perPage: String(perPage) } : {}),
-      ...(_attribute?.length ? { attribute: _attribute } : {}),
-    } as const;
-
     const searchParams = new URLSearchParams();
     if (name) {
       searchParams.set('name', name);

package/src/index.test.ts

@@ -1,4 +1,3 @@
-import type { MessageType } from '@mastra/core';
 import { describe, expect, beforeEach, it, vi } from 'vitest';
 
 import { MastraClient } from './client';
@@ -489,7 +488,7 @@ describe('MastraClient Resources', () => {
       const result = await memoryThread.update({
         title: 'Updated Thread',
         metadata: { updated: true },
-        resourceid: 'test-resource',
+        resourceId: 'test-resource',
       });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
@@ -536,6 +535,7 @@ describe('MastraClient Resources', () => {
           content: 'test',
           role: 'user' as const,
           threadId: 'test-thread',
+          resourceId: 'test-resource',
           createdAt: new Date('2025-03-26T10:40:55.116Z'),
         },
       ];
@@ -584,10 +584,10 @@ describe('MastraClient Resources', () => {
     it('should execute tool', async () => {
       const mockResponse = { data: 'test' };
       mockFetchResponse(mockResponse);
-      const result = await tool.execute({ data: '' });
+      const result = await tool.execute({ data: '', runId: 'test-run-id' });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
-        `${clientOptions.baseUrl}/api/tools/test-tool/execute`,
+        `${clientOptions.baseUrl}/api/tools/test-tool/execute?runId=test-run-id`,
         expect.objectContaining({
           method: 'POST',
           headers: expect.objectContaining({

package/src/resources/agent.ts

@@ -1,8 +1,8 @@
+import { processDataStream } from '@ai-sdk/ui-utils';
 import type { GenerateReturn } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
-import { processDataStream } from '@ai-sdk/ui-utils';
 
 import type {
   GenerateParams,
@@ -29,7 +29,6 @@ export class AgentTool extends BaseResource {
    * @param params - Parameters required for tool execution
    * @returns Promise containing tool execution results
    */
-  /** @deprecated use CreateRun/startRun */
   execute(params: { data: any }): Promise<any> {
     return this.request(`/api/agents/${this.agentId}/tools/${this.toolId}/execute`, {
       method: 'POST',

package/src/resources/base.ts

@@ -1,4 +1,4 @@
-import type { RequestFunction, RequestOptions, ClientOptions } from '../types';
+import type { RequestOptions, ClientOptions } from '../types';
 
 export class BaseResource {
   readonly options: ClientOptions;

package/src/resources/index.ts

@@ -5,3 +5,4 @@ export * from './vector';
 export * from './workflow';
 export * from './tool';
 export * from './base';
+export * from './vnext-workflow';

package/src/resources/memory-thread.ts

@@ -1,13 +1,6 @@
 import type { StorageThreadType } from '@mastra/core';
 
-import type {
-  CreateMemoryThreadParams,
-  GetMemoryThreadMessagesResponse,
-  GetMemoryThreadResponse,
-  ClientOptions,
-  SaveMessageToMemoryParams,
-  UpdateMemoryThreadParams,
-} from '../types';
+import type { GetMemoryThreadMessagesResponse, ClientOptions, UpdateMemoryThreadParams } from '../types';
 
 import { BaseResource } from './base';
 

package/src/resources/network.ts

@@ -1,3 +1,4 @@
+import { processDataStream } from '@ai-sdk/ui-utils';
 import type { GenerateReturn } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
@@ -6,7 +7,6 @@ import { zodToJsonSchema } from 'zod-to-json-schema';
 import type { GenerateParams, ClientOptions, StreamParams, GetNetworkResponse } from '../types';
 
 import { BaseResource } from './base';
-import { processDataStream } from '@ai-sdk/ui-utils';
 
 export class Network extends BaseResource {
   constructor(

package/src/resources/tool.ts

@@ -23,10 +23,16 @@ export class Tool extends BaseResource {
    * @param params - Parameters required for tool execution
    * @returns Promise containing the tool execution results
    */
-  execute(params: { data: any }): Promise<any> {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
+  execute(params: { data: any; runId?: string }): Promise<any> {
+    const url = new URLSearchParams();
+
+    if (params.runId) {
+      url.set('runId', params.runId);
+    }
+
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: 'POST',
-      body: params,
+      body: params.data,
     });
   }
 }

package/src/resources/vnext-workflow.ts

@@ -0,0 +1,234 @@
+import type { RuntimeContext } from '@mastra/core/runtime-context';
+import type {
+  ClientOptions,
+  GetVNextWorkflowResponse,
+  GetWorkflowRunsResponse,
+  VNextWorkflowRunResult,
+  VNextWorkflowWatchResult,
+} from '../types';
+
+import { BaseResource } from './base';
+
+const RECORD_SEPARATOR = '\x1E';
+
+export class VNextWorkflow extends BaseResource {
+  constructor(
+    options: ClientOptions,
+    private workflowId: string,
+  ) {
+    super(options);
+  }
+
+  /**
+   * 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
+   */
+  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}`);
+  }
+
+  /**
+   * Retrieves all runs for a vNext workflow
+   * @returns Promise containing vNext workflow runs array
+   */
+  runs(): Promise<GetWorkflowRunsResponse> {
+    return this.request(`/api/workflows/v-next/${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
+   */
+  createRun(params?: { runId?: string }): Promise<{ runId: string }> {
+    const searchParams = new URLSearchParams();
+
+    if (!!params?.runId) {
+      searchParams.set('runId', params.runId);
+    }
+
+    return this.request(`/api/workflows/v-next/${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
+   * @returns Promise containing success message
+   */
+  start(params: {
+    runId: string;
+    inputData: Record<string, any>;
+    runtimeContext?: RuntimeContext;
+  }): Promise<{ message: string }> {
+    return this.request(`/api/workflows/v-next/${this.workflowId}/start?runId=${params.runId}`, {
+      method: 'POST',
+      body: { inputData: params?.inputData, runtimeContext: params.runtimeContext },
+    });
+  }
+
+  /**
+   * 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
+   */
+  resume({
+    step,
+    runId,
+    resumeData,
+    runtimeContext,
+  }: {
+    step: string | string[];
+    runId: string;
+    resumeData?: Record<string, any>;
+    runtimeContext?: RuntimeContext;
+  }): Promise<{ message: string }> {
+    return this.request(`/api/workflows/v-next/${this.workflowId}/resume?runId=${runId}`, {
+      method: 'POST',
+      stream: true,
+      body: {
+        step,
+        resumeData,
+        runtimeContext,
+      },
+    });
+  }
+
+  /**
+   * 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
+   */
+  startAsync(params: {
+    runId?: string;
+    inputData: Record<string, any>;
+    runtimeContext?: RuntimeContext;
+  }): Promise<VNextWorkflowRunResult> {
+    const searchParams = new URLSearchParams();
+
+    if (!!params?.runId) {
+      searchParams.set('runId', params.runId);
+    }
+
+    return this.request(`/api/workflows/v-next/${this.workflowId}/start-async?${searchParams.toString()}`, {
+      method: 'POST',
+      body: { inputData: params.inputData, runtimeContext: params.runtimeContext },
+    });
+  }
+
+  /**
+   * 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
+   */
+  resumeAsync(params: {
+    runId: string;
+    step: string | string[];
+    resumeData?: Record<string, any>;
+    runtimeContext?: RuntimeContext;
+  }): Promise<VNextWorkflowRunResult> {
+    return this.request(`/api/workflows/v-next/${this.workflowId}/resume-async?runId=${params.runId}`, {
+      method: 'POST',
+      body: {
+        step: params.step,
+        resumeData: params.resumeData,
+        runtimeContext: params.runtimeContext,
+      },
+    });
+  }
+
+  /**
+   * Watches vNext 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
+   */
+  async watch({ runId }: { runId?: string }, onRecord: (record: VNextWorkflowWatchResult) => void) {
+    const response: Response = await this.request(`/api/workflows/v-next/${this.workflowId}/watch?runId=${runId}`, {
+      stream: true,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to watch vNext workflow: ${response.statusText}`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+
+    for await (const record of this.streamProcessor(response.body)) {
+      onRecord(record);
+    }
+  }
+}

package/src/resources/workflow.ts

@@ -1,4 +1,4 @@
-import type { GetWorkflowResponse, ClientOptions, WorkflowRunResult } from '../types';
+import type { GetWorkflowResponse, ClientOptions, WorkflowRunResult, GetWorkflowRunsResponse } from '../types';
 
 import { BaseResource } from './base';
 
@@ -20,6 +20,14 @@ export class Workflow extends BaseResource {
     return this.request(`/api/workflows/${this.workflowId}`);
   }
 
+  /**
+   * Retrieves all runs for a workflow
+   * @returns Promise containing workflow runs array
+   */
+  runs(): Promise<GetWorkflowRunsResponse> {
+    return this.request(`/api/workflows/${this.workflowId}/runs`);
+  }
+
   /**
    * @deprecated Use `startAsync` instead
    * Executes the workflow with the provided parameters
@@ -168,7 +176,7 @@ export class Workflow extends BaseResource {
               }
             }
           }
-        } catch (error) {
+        } catch {
           // Silently ignore parsing errors to maintain stream processing
           // This allows the stream to continue even if one record is malformed
         }

package/src/types.ts

@@ -8,9 +8,11 @@ import type {
   StorageThreadType,
   BaseLogMessage,
   WorkflowRunResult as CoreWorkflowRunResult,
+  WorkflowRuns,
 } from '@mastra/core';
 
 import type { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
+import type { NewWorkflow, WatchEvent, WorkflowResult as VNextWorkflowResult } from '@mastra/core/workflows/vNext';
 import type { JSONSchema7 } from 'json-schema';
 import type { ZodSchema } from 'zod';
 
@@ -54,6 +56,9 @@ export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefin
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
   evals: any[];
+  instructions: string;
+  name: string;
+  id: string;
 }
 
 export interface GetToolResponse {
@@ -72,12 +77,35 @@ export interface GetWorkflowResponse {
   workflowId?: string;
 }
 
+export type GetWorkflowRunsResponse = WorkflowRuns;
+
 export type WorkflowRunResult = {
   activePaths: Record<string, { status: string; suspendPayload?: any; stepPath: string[] }>;
   results: CoreWorkflowRunResult<any, any, any>['results'];
   timestamp: number;
   runId: string;
 };
+
+export interface GetVNextWorkflowResponse {
+  name: string;
+  steps: {
+    [key: string]: {
+      id: string;
+      description: string;
+      inputSchema: string;
+      outputSchema: string;
+      resumeSchema: string;
+      suspendSchema: string;
+    };
+  };
+  stepGraph: NewWorkflow['serializedStepGraph'];
+  inputSchema: string;
+  outputSchema: string;
+}
+
+export type VNextWorkflowWatchResult = WatchEvent & { runId: string };
+
+export type VNextWorkflowRunResult = VNextWorkflowResult<any, any>;
 export interface UpsertVectorParams {
   indexName: string;
   vectors: number[][];
@@ -118,7 +146,7 @@ export type SaveMessageToMemoryResponse = MessageType[];
 export interface CreateMemoryThreadParams {
   title: string;
   metadata: Record<string, any>;
-  resourceid: string;
+  resourceId: string;
   threadId: string;
   agentId: string;
 }
@@ -135,7 +163,7 @@ export type GetMemoryThreadResponse = StorageThreadType[];
 export interface UpdateMemoryThreadParams {
   title: string;
   metadata: Record<string, any>;
-  resourceid: string;
+  resourceId: string;
 }
 
 export interface GetMemoryThreadMessagesResponse {
@@ -197,7 +225,7 @@ type Span = {
 };
 
 export interface GetTelemetryResponse {
-  traces: { traces: Span[] };
+  traces: Span[];
 }
 
 export interface GetTelemetryParams {