@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-vnextWorkflows-20250416071310

package/src/resources/workflow.ts

@@ -1,7 +1,9 @@
-import type { GetWorkflowResponse, ClientOptions } from '../types';
+import type { GetWorkflowResponse, ClientOptions, WorkflowRunResult } from '../types';
 
 import { BaseResource } from './base';
 
+const RECORD_SEPARATOR = '\x1E';
+
 export class Workflow extends BaseResource {
   constructor(
     options: ClientOptions,
@@ -19,11 +21,12 @@ export class Workflow extends BaseResource {
   }
 
   /**
+   * @deprecated Use `startAsync` instead
    * Executes the workflow with the provided parameters
    * @param params - Parameters required for workflow execution
    * @returns Promise containing the workflow execution results
    */
-  execute(params: Record<string, any>): Promise<Record<string, any>> {
+  execute(params: Record<string, any>): Promise<WorkflowRunResult> {
     return this.request(`/api/workflows/${this.workflowId}/execute`, {
       method: 'POST',
       body: params,
@@ -31,7 +34,35 @@ export class Workflow extends BaseResource {
   }
 
   /**
-   * Resumes a suspended workflow step
+   * Creates a new workflow run
+   * @returns Promise containing the generated run ID
+   */
+  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',
+    });
+  }
+
+  /**
+   * 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
@@ -45,24 +76,140 @@ export class Workflow extends BaseResource {
     stepId: string;
     runId: string;
     context: Record<string, any>;
-  }): Promise<Record<string, any>> {
-    return this.request(`/api/workflows/${this.workflowId}/resume`, {
+  }): Promise<{ message: string }> {
+    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: 'POST',
       body: {
         stepId,
-        runId,
         context,
       },
     });
   }
 
+  /**
+   * 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; triggerData: Record<string, any> }): Promise<WorkflowRunResult> {
+    const searchParams = new URLSearchParams();
+
+    if (!!params?.runId) {
+      searchParams.set('runId', params.runId);
+    }
+
+    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+      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}/resume-async?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)
+   *
+   * @param stream - The readable stream to process
+   * @returns An async generator that yields parsed records
+   */
+  private async *streamProcessor(stream: ReadableStream): AsyncGenerator<WorkflowRunResult, 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 (error) {
+          // 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 workflow transitions in real-time
-   * @returns Promise containing the workflow watch stream
+   * @param runId - Optional run ID to filter the watch stream
+   * @returns AsyncGenerator that yields parsed records from the workflow watch stream
    */
-  watch(): Promise<Response> {
-    return this.request(`/api/workflows/${this.workflowId}/watch`, {
+  async watch({ runId }: { runId?: string }, onRecord: (record: WorkflowRunResult) => void) {
+    const response: Response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
       stream: true,
     });
+
+    if (!response.ok) {
+      throw new Error(`Failed to watch 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/types.ts

@@ -7,10 +7,12 @@ import type {
   StepGraph,
   StorageThreadType,
   BaseLogMessage,
-  OutputType,
+  WorkflowRunResult as CoreWorkflowRunResult,
 } from '@mastra/core';
+
+import type { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
 import type { JSONSchema7 } from 'json-schema';
-import { ZodSchema } from 'zod';
+import type { ZodSchema } from 'zod';
 
 export interface ClientOptions {
   /** Base URL for API requests */
@@ -23,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 {
@@ -30,6 +33,7 @@ export interface RequestOptions {
   headers?: Record<string, string>;
   body?: any;
   stream?: boolean;
+  signal?: AbortSignal;
 }
 
 export interface GetAgentResponse {
@@ -37,21 +41,16 @@ export interface GetAgentResponse {
   instructions: string;
   tools: Record<string, GetToolResponse>;
   provider: string;
+  modelId: string;
 }
 
-export interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-  messages: string | string[] | CoreMessage[];
-  threadId?: string;
-  resourceid?: string;
-  output?: OutputType | T;
-}
+export type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+  messages: string | string[] | CoreMessage[] | AiMessageType[];
+} & Partial<AgentGenerateOptions<T>>;
 
-export interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-  messages: string | string[] | CoreMessage[];
-  threadId?: string;
-  resourceid?: string;
-  output?: OutputType | T;
-}
+export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+  messages: string | string[] | CoreMessage[] | AiMessageType[];
+} & Omit<AgentStreamOptions<T>, 'onFinish' | 'onStepFinish' | 'telemetry'>;
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
   evals: any[];
@@ -70,8 +69,15 @@ export interface GetWorkflowResponse {
   steps: Record<string, StepAction<any, any, any, any>>;
   stepGraph: StepGraph;
   stepSubscriberGraph: Record<string, StepGraph>;
+  workflowId?: string;
 }
 
+export type WorkflowRunResult = {
+  activePaths: Record<string, { status: string; suspendPayload?: any; stepPath: string[] }>;
+  results: CoreWorkflowRunResult<any, any, any>['results'];
+  timestamp: number;
+  runId: string;
+};
 export interface UpsertVectorParams {
   indexName: string;
   vectors: number[][];
@@ -150,8 +156,48 @@ export type GetLogsResponse = BaseLogMessage[];
 
 export type RequestFunction = (path: string, options?: RequestOptions) => Promise<any>;
 
+type SpanStatus = {
+  code: number;
+};
+
+type SpanOther = {
+  droppedAttributesCount: number;
+  droppedEventsCount: number;
+  droppedLinksCount: number;
+};
+
+type SpanEventAttributes = {
+  key: string;
+  value: { [key: string]: string | number | boolean | null };
+};
+
+type SpanEvent = {
+  attributes: SpanEventAttributes[];
+  name: string;
+  timeUnixNano: string;
+  droppedAttributesCount: number;
+};
+
+type Span = {
+  id: string;
+  parentSpanId: string | null;
+  traceId: string;
+  name: string;
+  scope: string;
+  kind: number;
+  status: SpanStatus;
+  events: SpanEvent[];
+  links: any[];
+  attributes: Record<string, string | number | boolean | null>;
+  startTime: number;
+  endTime: number;
+  duration: number;
+  other: SpanOther;
+  createdAt: string;
+};
+
 export interface GetTelemetryResponse {
-  traces: any[];
+  traces: Span[];
 }
 
 export interface GetTelemetryParams {
@@ -161,3 +207,18 @@ export interface GetTelemetryParams {
   perPage?: number;
   attribute?: Record<string, string>;
 }
+
+export interface GetNetworkResponse {
+  name: string;
+  instructions: string;
+  agents: Array<{
+    name: string;
+    provider: string;
+    modelId: string;
+  }>;
+  routingModel: {
+    provider: string;
+    modelId: string;
+  };
+  state?: Record<string, any>;
+}

package/.turbo/turbo-build.log

@@ -1,16 +0,0 @@
-
-
-> @mastra/client-js@0.1.4-alpha.0 build /Users/ward/projects/mastra/mastra/client-sdks/client-js
-> tsup-node src/index.ts --format esm --dts --clean --treeshake
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.3.6
-CLI Target: es2022
-CLI Cleaning output folder
-ESM Build start
-ESM dist/index.mjs 13.56 KB
-ESM ⚡️ Build success in 119ms
-DTS Build start
-DTS ⚡️ Build success in 2785ms
-DTS dist/index.d.mts 13.64 KB