@mastra/client-js 0.0.0-course-20250527170450 → 0.0.0-custom-instrumentation-20250708222033

package/src/resources/network-memory-thread.ts

@@ -0,0 +1,63 @@
+import type { StorageThreadType } from '@mastra/core';
+
+import type {
+  GetMemoryThreadMessagesResponse,
+  ClientOptions,
+  UpdateMemoryThreadParams,
+  GetMemoryThreadMessagesParams,
+} from '../types';
+
+import { BaseResource } from './base';
+
+export class NetworkMemoryThread extends BaseResource {
+  constructor(
+    options: ClientOptions,
+    private threadId: string,
+    private networkId: string,
+  ) {
+    super(options);
+  }
+
+  /**
+   * Retrieves the memory thread details
+   * @returns Promise containing thread details including title and metadata
+   */
+  get(): Promise<StorageThreadType> {
+    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`);
+  }
+
+  /**
+   * Updates the memory thread properties
+   * @param params - Update parameters including title and metadata
+   * @returns Promise containing updated thread details
+   */
+  update(params: UpdateMemoryThreadParams): Promise<StorageThreadType> {
+    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`, {
+      method: 'PATCH',
+      body: params,
+    });
+  }
+
+  /**
+   * Deletes the memory thread
+   * @returns Promise containing deletion result
+   */
+  delete(): Promise<{ result: string }> {
+    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`, {
+      method: 'DELETE',
+    });
+  }
+
+  /**
+   * Retrieves messages associated with the thread
+   * @param params - Optional parameters including limit for number of messages to retrieve
+   * @returns Promise containing thread messages and UI messages
+   */
+  getMessages(params?: GetMemoryThreadMessagesParams): Promise<GetMemoryThreadMessagesResponse> {
+    const query = new URLSearchParams({
+      networkId: this.networkId,
+      ...(params?.limit ? { limit: params.limit.toString() } : {}),
+    });
+    return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
+  }
+}

package/src/resources/network.ts

@@ -1,10 +1,9 @@
 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 '../utils/zod-to-json-schema';
-
+import type { ZodSchema } from 'zod';
 import type { GenerateParams, ClientOptions, StreamParams, GetNetworkResponse } from '../types';
+import { zodToJsonSchema } from '../utils/zod-to-json-schema';
 
 import { BaseResource } from './base';
 

package/src/resources/vNextNetwork.ts

@@ -0,0 +1,177 @@
+import type { WatchEvent } from '@mastra/core/workflows';
+
+import type {
+  ClientOptions,
+  GetVNextNetworkResponse,
+  GenerateVNextNetworkResponse,
+  LoopVNextNetworkResponse,
+  GenerateOrStreamVNextNetworkParams,
+  LoopStreamVNextNetworkParams,
+} from '../types';
+
+import { BaseResource } from './base';
+
+const RECORD_SEPARATOR = '\x1E';
+
+export class VNextNetwork extends BaseResource {
+  constructor(
+    options: ClientOptions,
+    private networkId: string,
+  ) {
+    super(options);
+  }
+
+  /**
+   * Retrieves details about the network
+   * @returns Promise containing vNext network details
+   */
+  details(): Promise<GetVNextNetworkResponse> {
+    return this.request(`/api/networks/v-next/${this.networkId}`);
+  }
+
+  /**
+   * Generates a response from the v-next network
+   * @param params - Generation parameters including message
+   * @returns Promise containing the generated response
+   */
+  generate(params: GenerateOrStreamVNextNetworkParams): Promise<GenerateVNextNetworkResponse> {
+    return this.request(`/api/networks/v-next/${this.networkId}/generate`, {
+      method: 'POST',
+      body: params,
+    });
+  }
+
+  /**
+   * Generates a response from the v-next network using multiple primitives
+   * @param params - Generation parameters including message
+   * @returns Promise containing the generated response
+   */
+  loop(params: { message: string }): Promise<LoopVNextNetworkResponse> {
+    return this.request(`/api/networks/v-next/${this.networkId}/loop`, {
+      method: 'POST',
+      body: params,
+    });
+  }
+
+  private async *streamProcessor(stream: ReadableStream): AsyncGenerator<WatchEvent, 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
+      });
+    }
+  }
+
+  /**
+   * Streams a response from the v-next network
+   * @param params - Stream parameters including message
+   * @returns Promise containing the results
+   */
+  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,
+      stream: true,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to stream vNext network: ${response.statusText}`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+
+    for await (const record of this.streamProcessor(response.body)) {
+      if (typeof record === 'string') {
+        onRecord(JSON.parse(record));
+      } else {
+        onRecord(record);
+      }
+    }
+  }
+
+  /**
+   * Streams a response from the v-next network loop
+   * @param params - Stream parameters including message
+   * @returns Promise containing the results
+   */
+  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,
+      stream: true,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to stream vNext network loop: ${response.statusText}`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+
+    for await (const record of this.streamProcessor(response.body)) {
+      if (typeof record === 'string') {
+        onRecord(JSON.parse(record));
+      } else {
+        onRecord(record);
+      }
+    }
+  }
+}

package/src/resources/workflow.ts

@@ -6,6 +6,8 @@ import type {
   GetWorkflowRunsParams,
   WorkflowRunResult,
   WorkflowWatchResult,
+  GetWorkflowRunByIdResponse,
+  GetWorkflowRunExecutionResultResponse,
 } from '../types';
 
 import { parseClientRuntimeContext } from '../utils';
@@ -113,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) {
@@ -130,6 +132,47 @@ export class Workflow extends BaseResource {
     }
   }
 
+  /**
+   * Retrieves a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to retrieve
+   * @returns Promise containing the workflow run details
+   */
+  runById(runId: string): Promise<GetWorkflowRunByIdResponse> {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}`);
+  }
+
+  /**
+   * Retrieves the execution result for a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to retrieve the execution result for
+   * @returns Promise containing the workflow run execution result
+   */
+  runExecutionResult(runId: string): Promise<GetWorkflowRunExecutionResultResponse> {
+    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
@@ -217,9 +260,9 @@ export class Workflow extends BaseResource {
   }
 
   /**
-   * Starts a vNext workflow run and returns a stream
+   * Starts a workflow run and returns a stream
    * @param params - Object containing the optional runId, inputData and runtimeContext
-   * @returns Promise containing the vNext workflow execution results
+   * @returns Promise containing the workflow execution results
    */
   async stream(params: { runId?: string; inputData: Record<string, any>; runtimeContext?: RuntimeContext }) {
     const searchParams = new URLSearchParams();
@@ -228,7 +271,7 @@ export class Workflow extends BaseResource {
       searchParams.set('runId', params.runId);
     }
 
-    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined;
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
     const response: Response = await this.request(
       `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
       {
@@ -247,7 +290,7 @@ export class Workflow extends BaseResource {
     }
 
     // Create a transform stream that processes the response body
-    const transformStream = new TransformStream<ArrayBuffer, WorkflowWatchResult>({
+    const transformStream = new TransformStream<ArrayBuffer, { type: string; payload: any }>({
       start() {},
       async transform(chunk, controller) {
         try {
@@ -319,7 +362,11 @@ export class Workflow extends BaseResource {
     }
 
     for await (const record of this.streamProcessor(response.body)) {
-      onRecord(record);
+      if (typeof record === 'string') {
+        onRecord(JSON.parse(record));
+      } else {
+        onRecord(record);
+      }
     }
   }
 

package/src/types.ts

@@ -1,16 +1,17 @@
 import type {
-  MessageType,
+  MastraMessageV1,
   AiMessageType,
   CoreMessage,
   QueryResult,
   StorageThreadType,
   WorkflowRuns,
+  WorkflowRun,
   LegacyWorkflowRuns,
 } from '@mastra/core';
-import type { BaseLogMessage } from '@mastra/core/logger';
+import type { AgentGenerateOptions, AgentStreamOptions, ToolsInput } from '@mastra/core/agent';
+import type { BaseLogMessage, LogLevel } from '@mastra/core/logger';
 
-import type { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
-import type { ServerInfo } from '@mastra/core/mcp';
+import type { MCPToolType, ServerInfo } from '@mastra/core/mcp';
 import type { RuntimeContext } from '@mastra/core/runtime-context';
 import type { Workflow, WatchEvent, WorkflowResult } from '@mastra/core/workflows';
 import type {
@@ -33,6 +34,7 @@ export interface ClientOptions {
   /** Custom headers to include with requests */
   headers?: Record<string, string>;
   /** Abort signal for request */
+  abortSignal?: AbortSignal;
 }
 
 export interface RequestOptions {
@@ -40,7 +42,6 @@ export interface RequestOptions {
   headers?: Record<string, string>;
   body?: any;
   stream?: boolean;
-  signal?: AbortSignal;
 }
 
 type WithoutMethods<T> = {
@@ -69,14 +70,20 @@ export type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undef
   output?: T;
   experimental_output?: T;
   runtimeContext?: RuntimeContext | Record<string, any>;
-} & WithoutMethods<Omit<AgentGenerateOptions<T>, 'output' | 'experimental_output' | 'runtimeContext'>>;
+  clientTools?: ToolsInput;
+} & WithoutMethods<
+  Omit<AgentGenerateOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools' | 'abortSignal'>
+>;
 
 export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
   messages: string | string[] | CoreMessage[] | AiMessageType[];
   output?: T;
   experimental_output?: T;
   runtimeContext?: RuntimeContext | Record<string, any>;
-} & WithoutMethods<Omit<AgentStreamOptions<T>, 'output' | 'experimental_output' | 'runtimeContext'>>;
+  clientTools?: ToolsInput;
+} & WithoutMethods<
+  Omit<AgentStreamOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools' | 'abortSignal'>
+>;
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
   evals: any[];
@@ -113,6 +120,10 @@ export type GetLegacyWorkflowRunsResponse = LegacyWorkflowRuns;
 
 export type GetWorkflowRunsResponse = WorkflowRuns;
 
+export type GetWorkflowRunByIdResponse = WorkflowRun;
+
+export type GetWorkflowRunExecutionResultResponse = WatchEvent['payload']['workflowState'];
+
 export type LegacyWorkflowRunResult = {
   activePaths: Record<string, { status: string; suspendPayload?: any; stepPath: string[] }>;
   results: CoreLegacyWorkflowRunResult<any, any, any>['results'];
@@ -133,6 +144,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;
@@ -172,11 +194,16 @@ export interface GetVectorIndexResponse {
 }
 
 export interface SaveMessageToMemoryParams {
-  messages: MessageType[];
+  messages: MastraMessageV1[];
   agentId: string;
 }
 
-export type SaveMessageToMemoryResponse = MessageType[];
+export interface SaveNetworkMessageToMemoryParams {
+  messages: MastraMessageV1[];
+  networkId: string;
+}
+
+export type SaveMessageToMemoryResponse = MastraMessageV1[];
 
 export interface CreateMemoryThreadParams {
   title?: string;
@@ -186,6 +213,14 @@ export interface CreateMemoryThreadParams {
   agentId: string;
 }
 
+export interface CreateNetworkMemoryThreadParams {
+  title?: string;
+  metadata?: Record<string, any>;
+  resourceId: string;
+  threadId?: string;
+  networkId: string;
+}
+
 export type CreateMemoryThreadResponse = StorageThreadType;
 
 export interface GetMemoryThreadParams {
@@ -193,6 +228,11 @@ export interface GetMemoryThreadParams {
   agentId: string;
 }
 
+export interface GetNetworkMemoryThreadParams {
+  resourceId: string;
+  networkId: string;
+}
+
 export type GetMemoryThreadResponse = StorageThreadType[];
 
 export interface UpdateMemoryThreadParams {
@@ -215,14 +255,32 @@ export interface GetMemoryThreadMessagesResponse {
 
 export interface GetLogsParams {
   transportId: string;
+  fromDate?: Date;
+  toDate?: Date;
+  logLevel?: LogLevel;
+  filters?: Record<string, string>;
+  page?: number;
+  perPage?: number;
 }
 
 export interface GetLogParams {
   runId: string;
   transportId: string;
+  fromDate?: Date;
+  toDate?: Date;
+  logLevel?: LogLevel;
+  filters?: Record<string, string>;
+  page?: number;
+  perPage?: number;
 }
 
-export type GetLogsResponse = BaseLogMessage[];
+export type GetLogsResponse = {
+  logs: BaseLogMessage[];
+  total: number;
+  page: number;
+  perPage: number;
+  hasMore: boolean;
+};
 
 export type RequestFunction = (path: string, options?: RequestOptions) => Promise<any>;
 
@@ -281,6 +339,7 @@ export interface GetTelemetryParams {
 }
 
 export interface GetNetworkResponse {
+  id: string;
   name: string;
   instructions: string;
   agents: Array<{
@@ -295,6 +354,59 @@ export interface GetNetworkResponse {
   state?: Record<string, any>;
 }
 
+export interface GetVNextNetworkResponse {
+  id: string;
+  name: string;
+  instructions: string;
+  agents: Array<{
+    name: string;
+    provider: string;
+    modelId: string;
+  }>;
+  routingModel: {
+    provider: string;
+    modelId: string;
+  };
+  workflows: Array<{
+    name: string;
+    description: string;
+    inputSchema: string | undefined;
+    outputSchema: string | undefined;
+  }>;
+  tools: Array<{
+    id: string;
+    description: string;
+  }>;
+}
+
+export interface GenerateVNextNetworkResponse {
+  task: string;
+  result: string;
+  resourceId: string;
+  resourceType: 'none' | 'tool' | 'agent' | 'workflow';
+}
+
+export interface GenerateOrStreamVNextNetworkParams {
+  message: string;
+  threadId?: string;
+  resourceId?: string;
+}
+
+export interface LoopStreamVNextNetworkParams {
+  message: string;
+  threadId?: string;
+  resourceId?: string;
+  maxIterations?: number;
+}
+
+export interface LoopVNextNetworkResponse {
+  status: 'success';
+  result: {
+    text: string;
+  };
+  steps: WorkflowResult<any, any>['steps'];
+}
+
 export interface McpServerListResponse {
   servers: ServerInfo[];
   next: string | null;
@@ -306,6 +418,7 @@ export interface McpToolInfo {
   name: string;
   description?: string;
   inputSchema: string;
+  toolType?: MCPToolType;
 }
 
 export interface McpServerToolListResponse {

package/src/utils/process-client-tools.ts

@@ -0,0 +1,32 @@
+import { isVercelTool } from '@mastra/core/tools';
+import { zodToJsonSchema } from './zod-to-json-schema';
+import type { ToolsInput } from '@mastra/core/agent';
+
+export function processClientTools(clientTools: ToolsInput | undefined): ToolsInput | undefined {
+  if (!clientTools) {
+    return undefined;
+  }
+
+  return Object.fromEntries(
+    Object.entries(clientTools).map(([key, value]) => {
+      if (isVercelTool(value)) {
+        return [
+          key,
+          {
+            ...value,
+            parameters: value.parameters ? zodToJsonSchema(value.parameters) : undefined,
+          },
+        ];
+      } else {
+        return [
+          key,
+          {
+            ...value,
+            inputSchema: value.inputSchema ? zodToJsonSchema(value.inputSchema) : undefined,
+            outputSchema: value.outputSchema ? zodToJsonSchema(value.outputSchema) : undefined,
+          },
+        ];
+      }
+    }),
+  );
+}