@mastra/client-js 0.0.0-tool-call-parts-20250630193309 → 0.0.0-transpile-packages-20250724123433

package/src/resources/base.ts

@@ -24,12 +24,15 @@ export class BaseResource {
         const response = await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, {
           ...options,
           headers: {
-            ...(options.method === 'POST' || options.method === 'PUT' ? { 'content-type': 'application/json' } : {}),
+            ...(options.body && (options.method === 'POST' || options.method === 'PUT')
+              ? { 'content-type': 'application/json' }
+              : {}),
             ...headers,
             ...options.headers,
             // TODO: Bring this back once we figure out what we/users need to do to make this work with cross-origin requests
             // 'x-mastra-client-type': 'js',
           },
+          signal: this.options.abortSignal,
           body:
             options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : undefined,
         });

package/src/resources/memory-thread.ts

@@ -5,6 +5,8 @@ import type {
   ClientOptions,
   UpdateMemoryThreadParams,
   GetMemoryThreadMessagesParams,
+  GetMemoryThreadMessagesPaginatedParams,
+  GetMemoryThreadMessagesPaginatedResponse,
 } from '../types';
 
 import { BaseResource } from './base';
@@ -60,4 +62,20 @@ export class MemoryThread extends BaseResource {
     });
     return this.request(`/api/memory/threads/${this.threadId}/messages?${query.toString()}`);
   }
+
+  /**
+   * Retrieves paginated messages associated with the thread with advanced filtering and selection options
+   * @param params - Pagination parameters including selectBy criteria, page, perPage, date ranges, and message inclusion options
+   * @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
+   */
+  getMessagesPaginated({
+    selectBy,
+    ...rest
+  }: GetMemoryThreadMessagesPaginatedParams): Promise<GetMemoryThreadMessagesPaginatedResponse> {
+    const query = new URLSearchParams({
+      ...rest,
+      ...(selectBy ? { selectBy: JSON.stringify(selectBy) } : {}),
+    });
+    return this.request(`/api/memory/threads/${this.threadId}/messages/paginated?${query.toString()}`);
+  }
 }

package/src/resources/vNextNetwork.ts

@@ -10,6 +10,8 @@ import type {
 } from '../types';
 
 import { BaseResource } from './base';
+import { parseClientRuntimeContext } from '../utils';
+import type { RuntimeContext } from '@mastra/core/runtime-context';
 
 const RECORD_SEPARATOR = '\x1E';
 
@@ -37,7 +39,10 @@ export class VNextNetwork extends BaseResource {
   generate(params: GenerateOrStreamVNextNetworkParams): Promise<GenerateVNextNetworkResponse> {
     return this.request(`/api/networks/v-next/${this.networkId}/generate`, {
       method: 'POST',
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      },
     });
   }
 
@@ -46,10 +51,16 @@ export class VNextNetwork extends BaseResource {
    * @param params - Generation parameters including message
    * @returns Promise containing the generated response
    */
-  loop(params: { message: string }): Promise<LoopVNextNetworkResponse> {
+  loop(params: {
+    message: string;
+    runtimeContext?: RuntimeContext | Record<string, any>;
+  }): Promise<LoopVNextNetworkResponse> {
     return this.request(`/api/networks/v-next/${this.networkId}/loop`, {
       method: 'POST',
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      },
     });
   }
 
@@ -125,7 +136,10 @@ export class VNextNetwork extends BaseResource {
   async stream(params: GenerateOrStreamVNextNetworkParams, onRecord: (record: WatchEvent) => void) {
     const response: Response = await this.request(`/api/networks/v-next/${this.networkId}/stream`, {
       method: 'POST',
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      },
       stream: true,
     });
 
@@ -154,7 +168,10 @@ export class VNextNetwork extends BaseResource {
   async loopStream(params: LoopStreamVNextNetworkParams, onRecord: (record: WatchEvent) => void) {
     const response: Response = await this.request(`/api/networks/v-next/${this.networkId}/loop-stream`, {
       method: 'POST',
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      },
       stream: true,
     });
 

package/src/resources/workflow.ts

@@ -115,10 +115,10 @@ export class Workflow extends BaseResource {
     if (params?.toDate) {
       searchParams.set('toDate', params.toDate.toISOString());
     }
-    if (params?.limit) {
+    if (params?.limit !== null && params?.limit !== undefined && !isNaN(Number(params?.limit))) {
       searchParams.set('limit', String(params.limit));
     }
-    if (params?.offset) {
+    if (params?.offset !== null && params?.offset !== undefined && !isNaN(Number(params?.offset))) {
       searchParams.set('offset', String(params.offset));
     }
     if (params?.resourceId) {
@@ -150,6 +150,29 @@ export class Workflow extends BaseResource {
     return this.request(`/api/workflows/${this.workflowId}/runs/${runId}/execution-result`);
   }
 
+  /**
+   * Cancels a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to cancel
+   * @returns Promise containing a success message
+   */
+  cancelRun(runId: string): Promise<{ message: string }> {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}/cancel`, {
+      method: 'POST',
+    });
+  }
+
+  /**
+   * Sends an event to a specific workflow run by its ID
+   * @param params - Object containing the runId, event and data
+   * @returns Promise containing a success message
+   */
+  sendRunEvent(params: { runId: string; event: string; data: unknown }): Promise<{ message: string }> {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${params.runId}/send-event`, {
+      method: 'POST',
+      body: { event: params.event, data: params.data },
+    });
+  }
+
   /**
    * Creates a new workflow run
    * @param params - Optional object containing the optional runId
@@ -167,6 +190,15 @@ export class Workflow extends BaseResource {
     });
   }
 
+  /**
+   * Creates a new workflow run (alias for createRun)
+   * @param params - Optional object containing the optional runId
+   * @returns Promise containing the runId of the created run
+   */
+  createRunAsync(params?: { runId?: string }): Promise<{ runId: string }> {
+    return this.createRun(params);
+  }
+
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
    * @param params - Object containing the runId, inputData and runtimeContext
@@ -266,6 +298,9 @@ export class Workflow extends BaseResource {
       throw new Error('Response body is null');
     }
 
+    //using undefined instead of empty string to avoid parsing errors
+    let failedChunk: string | undefined = undefined;
+
     // Create a transform stream that processes the response body
     const transformStream = new TransformStream<ArrayBuffer, { type: string; payload: any }>({
       start() {},
@@ -280,11 +315,13 @@ export class Workflow extends BaseResource {
           // Process each chunk
           for (const chunk of chunks) {
             if (chunk) {
+              const newChunk: string = failedChunk ? failedChunk + chunk : chunk;
               try {
-                const parsedChunk = JSON.parse(chunk);
+                const parsedChunk = JSON.parse(newChunk);
                 controller.enqueue(parsedChunk);
-              } catch {
-                // Silently ignore parsing errors
+                failedChunk = undefined;
+              } catch (error) {
+                failedChunk = newChunk;
               }
             }
           }

package/src/types.ts

@@ -7,6 +7,9 @@ import type {
   WorkflowRuns,
   WorkflowRun,
   LegacyWorkflowRuns,
+  StorageGetMessagesArg,
+  PaginationInfo,
+  MastraMessageV2,
 } from '@mastra/core';
 import type { AgentGenerateOptions, AgentStreamOptions, ToolsInput } from '@mastra/core/agent';
 import type { BaseLogMessage, LogLevel } from '@mastra/core/logger';
@@ -34,6 +37,7 @@ export interface ClientOptions {
   /** Custom headers to include with requests */
   headers?: Record<string, string>;
   /** Abort signal for request */
+  abortSignal?: AbortSignal;
 }
 
 export interface RequestOptions {
@@ -41,7 +45,6 @@ export interface RequestOptions {
   headers?: Record<string, string>;
   body?: any;
   stream?: boolean;
-  signal?: AbortSignal;
 }
 
 type WithoutMethods<T> = {
@@ -71,7 +74,9 @@ export type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undef
   experimental_output?: T;
   runtimeContext?: RuntimeContext | Record<string, any>;
   clientTools?: ToolsInput;
-} & WithoutMethods<Omit<AgentGenerateOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools'>>;
+} & WithoutMethods<
+  Omit<AgentGenerateOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools' | 'abortSignal'>
+>;
 
 export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
   messages: string | string[] | CoreMessage[] | AiMessageType[];
@@ -79,7 +84,9 @@ export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefin
   experimental_output?: T;
   runtimeContext?: RuntimeContext | Record<string, any>;
   clientTools?: ToolsInput;
-} & WithoutMethods<Omit<AgentStreamOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools'>>;
+} & WithoutMethods<
+  Omit<AgentStreamOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools' | 'abortSignal'>
+>;
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
   evals: any[];
@@ -140,6 +147,17 @@ export interface GetWorkflowResponse {
       suspendSchema: string;
     };
   };
+  allSteps: {
+    [key: string]: {
+      id: string;
+      description: string;
+      inputSchema: string;
+      outputSchema: string;
+      resumeSchema: string;
+      suspendSchema: string;
+      isWorkflow: boolean;
+    };
+  };
   stepGraph: Workflow['serializedStepGraph'];
   inputSchema: string;
   outputSchema: string;
@@ -233,11 +251,17 @@ export interface GetMemoryThreadMessagesParams {
   limit?: number;
 }
 
+export type GetMemoryThreadMessagesPaginatedParams = Omit<StorageGetMessagesArg, 'threadConfig' | 'threadId'>;
+
 export interface GetMemoryThreadMessagesResponse {
   messages: CoreMessage[];
   uiMessages: AiMessageType[];
 }
 
+export type GetMemoryThreadMessagesPaginatedResponse = PaginationInfo & {
+  messages: MastraMessageV1[] | MastraMessageV2[];
+};
+
 export interface GetLogsParams {
   transportId: string;
   fromDate?: Date;
@@ -375,6 +399,7 @@ export interface GenerateOrStreamVNextNetworkParams {
   message: string;
   threadId?: string;
   resourceId?: string;
+  runtimeContext?: RuntimeContext | Record<string, any>;
 }
 
 export interface LoopStreamVNextNetworkParams {
@@ -382,12 +407,23 @@ export interface LoopStreamVNextNetworkParams {
   threadId?: string;
   resourceId?: string;
   maxIterations?: number;
+  runtimeContext?: RuntimeContext | Record<string, any>;
 }
 
 export interface LoopVNextNetworkResponse {
   status: 'success';
   result: {
-    text: string;
+    task: string;
+    resourceId: string;
+    resourceType: 'agent' | 'workflow' | 'none' | 'tool';
+    result: string;
+    iteration: number;
+    isOneOff: boolean;
+    prompt: string;
+    threadId?: string | undefined;
+    threadResourceId?: string | undefined;
+    isComplete?: boolean | undefined;
+    completionReason?: string | undefined;
   };
   steps: WorkflowResult<any, any>['steps'];
 }