@mastra/client-js 0.0.0-custom-instrumentation-20250626084921 → 0.0.0-declaration-maps-20250729202623

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

@@ -0,0 +1,269 @@
+import { describe, expect, beforeEach, it, vi } from 'vitest';
+import { NetworkMemoryThread } from './network-memory-thread';
+import type { ClientOptions } from '../types';
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+describe('NetworkMemoryThread', () => {
+  let thread: NetworkMemoryThread;
+  const clientOptions: ClientOptions = {
+    baseUrl: 'http://localhost:4111',
+    headers: {
+      Authorization: 'Bearer test-key',
+    },
+  };
+  const threadId = 'test-thread-id';
+  const networkId = 'test-network-id';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    thread = new NetworkMemoryThread(clientOptions, threadId, networkId);
+  });
+
+  const mockFetchResponse = (data: any) => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => data,
+      headers: new Headers({
+        'content-type': 'application/json',
+      }),
+    });
+  };
+
+  describe('get', () => {
+    it('should retrieve thread details', async () => {
+      const mockThread = {
+        id: threadId,
+        title: 'Test Thread',
+        metadata: { test: true },
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+
+      mockFetchResponse(mockThread);
+
+      const result = await thread.get();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockThread);
+    });
+  });
+
+  describe('update', () => {
+    it('should update thread properties', async () => {
+      const updateParams = {
+        title: 'Updated Title',
+        metadata: { updated: true },
+        resourceid: 'resource-1',
+      };
+
+      const mockUpdatedThread = {
+        id: threadId,
+        ...updateParams,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+
+      mockFetchResponse(mockUpdatedThread);
+
+      const result = await thread.update(updateParams);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'PATCH',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify(updateParams),
+        }),
+      );
+      expect(result).toEqual(mockUpdatedThread);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete the thread', async () => {
+      const mockResponse = { result: 'Thread deleted' };
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.delete();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'DELETE',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getMessages', () => {
+    it('should retrieve thread messages', async () => {
+      const mockMessages = {
+        messages: [
+          { id: 'msg-1', content: 'Hello', role: 'user' },
+          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
+        ],
+        uiMessages: [
+          { id: 'msg-1', content: 'Hello', role: 'user' },
+          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
+        ],
+      };
+
+      mockFetchResponse(mockMessages);
+
+      const result = await thread.getMessages();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}/messages?networkId=${networkId}`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockMessages);
+    });
+
+    it('should retrieve thread messages with limit', async () => {
+      const mockMessages = {
+        messages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
+        uiMessages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
+      };
+
+      mockFetchResponse(mockMessages);
+
+      const result = await thread.getMessages({ limit: 5 });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}/messages?networkId=${networkId}&limit=5`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockMessages);
+    });
+  });
+
+  describe('deleteMessages', () => {
+    it('should delete a single message by string ID', async () => {
+      const messageId = 'test-message-id';
+      const mockResponse = { success: true, message: '1 message deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageId);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageId }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete multiple messages by array of string IDs', async () => {
+      const messageIds = ['msg-1', 'msg-2', 'msg-3'];
+      const mockResponse = { success: true, message: '3 messages deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageIds);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete a message by object with id property', async () => {
+      const messageObj = { id: 'test-message-id' };
+      const mockResponse = { success: true, message: '1 message deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageObj);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageObj }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete messages by array of objects', async () => {
+      const messageObjs = [{ id: 'msg-1' }, { id: 'msg-2' }];
+      const mockResponse = { success: true, message: '2 messages deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageObjs);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageObjs }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle delete messages errors', async () => {
+      const messageId = 'non-existent-id';
+
+      (global.fetch as any).mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        json: async () => ({ error: 'Message not found' }),
+        headers: new Headers({
+          'content-type': 'application/json',
+        }),
+      });
+
+      await expect(thread.deleteMessages(messageId)).rejects.toThrow();
+    });
+  });
+});

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

@@ -60,4 +60,22 @@ export class NetworkMemoryThread extends BaseResource {
     });
     return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
   }
+
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(
+    messageIds: string | string[] | { id: string } | { id: string }[],
+  ): Promise<{ success: boolean; message: string }> {
+    const query = new URLSearchParams({
+      networkId: this.networkId,
+    });
+    return this.request(`/api/memory/network/messages/delete?${query.toString()}`, {
+      method: 'POST',
+      body: { messageIds },
+    });
+  }
 }

package/src/resources/network.ts

@@ -28,9 +28,10 @@ export class Network extends BaseResource {
    * @param params - Generation parameters including prompt
    * @returns Promise containing the generated response
    */
-  generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T>,
-  ): Promise<GenerateReturn<T>> {
+  generate<
+    Output extends JSONSchema7 | ZodSchema | undefined = undefined,
+    StructuredOutput extends JSONSchema7 | ZodSchema | undefined = undefined,
+  >(params: GenerateParams<Output>): Promise<GenerateReturn<any, Output, StructuredOutput>> {
     const processedParams = {
       ...params,
       output: zodToJsonSchema(params.output),

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,8 +298,11 @@ 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, WorkflowWatchResult>({
+    const transformStream = new TransformStream<ArrayBuffer, { type: string; payload: any }>({
       start() {},
       async transform(chunk, controller) {
         try {
@@ -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,12 +7,16 @@ import type {
   WorkflowRuns,
   WorkflowRun,
   LegacyWorkflowRuns,
+  StorageGetMessagesArg,
+  PaginationInfo,
+  MastraMessageV2,
 } from '@mastra/core';
-import type { AgentGenerateOptions, AgentStreamOptions, ToolsInput } from '@mastra/core/agent';
+import type { AgentGenerateOptions, AgentStreamOptions, ToolsInput, UIMessageWithMetadata } from '@mastra/core/agent';
 import type { BaseLogMessage, LogLevel } from '@mastra/core/logger';
 
 import type { MCPToolType, ServerInfo } from '@mastra/core/mcp';
 import type { RuntimeContext } from '@mastra/core/runtime-context';
+import type { MastraScorer, MastraScorerEntry, ScoreRowData } from '@mastra/core/scores';
 import type { Workflow, WatchEvent, WorkflowResult } from '@mastra/core/workflows';
 import type {
   StepAction,
@@ -34,6 +38,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 +46,6 @@ export interface RequestOptions {
   headers?: Record<string, string>;
   body?: any;
   stream?: boolean;
-  signal?: AbortSignal;
 }
 
 type WithoutMethods<T> = {
@@ -66,20 +70,24 @@ export interface GetAgentResponse {
 }
 
 export type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-  messages: string | string[] | CoreMessage[] | AiMessageType[];
+  messages: string | string[] | CoreMessage[] | AiMessageType[] | UIMessageWithMetadata[];
   output?: T;
   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[];
+  messages: string | string[] | CoreMessage[] | AiMessageType[] | UIMessageWithMetadata[];
   output?: T;
   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 +148,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;
@@ -179,16 +198,16 @@ export interface GetVectorIndexResponse {
 }
 
 export interface SaveMessageToMemoryParams {
-  messages: MastraMessageV1[];
+  messages: (MastraMessageV1 | MastraMessageV2)[];
   agentId: string;
 }
 
 export interface SaveNetworkMessageToMemoryParams {
-  messages: MastraMessageV1[];
+  messages: (MastraMessageV1 | MastraMessageV2)[];
   networkId: string;
 }
 
-export type SaveMessageToMemoryResponse = MastraMessageV1[];
+export type SaveMessageToMemoryResponse = (MastraMessageV1 | MastraMessageV2)[];
 
 export interface CreateMemoryThreadParams {
   title?: string;
@@ -233,11 +252,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;
@@ -358,6 +383,10 @@ export interface GetVNextNetworkResponse {
     inputSchema: string | undefined;
     outputSchema: string | undefined;
   }>;
+  tools: Array<{
+    id: string;
+    description: string;
+  }>;
 }
 
 export interface GenerateVNextNetworkResponse {
@@ -371,6 +400,7 @@ export interface GenerateOrStreamVNextNetworkParams {
   message: string;
   threadId?: string;
   resourceId?: string;
+  runtimeContext?: RuntimeContext | Record<string, any>;
 }
 
 export interface LoopStreamVNextNetworkParams {
@@ -378,12 +408,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'];
 }
@@ -405,3 +446,57 @@ export interface McpToolInfo {
 export interface McpServerToolListResponse {
   tools: McpToolInfo[];
 }
+
+export type ClientScoreRowData = Omit<ScoreRowData, 'createdAt' | 'updatedAt'> & {
+  createdAt: string;
+  updatedAt: string;
+};
+
+// Scores-related types
+export interface GetScoresByRunIdParams {
+  runId: string;
+  page?: number;
+  perPage?: number;
+}
+
+export interface GetScoresByScorerIdParams {
+  scorerId: string;
+  entityId?: string;
+  entityType?: string;
+  page?: number;
+  perPage?: number;
+}
+
+export interface GetScoresByEntityIdParams {
+  entityId: string;
+  entityType: string;
+  page?: number;
+  perPage?: number;
+}
+
+export interface SaveScoreParams {
+  score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>;
+}
+
+export interface GetScoresResponse {
+  pagination: {
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+  };
+  scores: ClientScoreRowData[];
+}
+
+export interface SaveScoreResponse {
+  score: ClientScoreRowData;
+}
+
+export type GetScorerResponse = MastraScorerEntry & {
+  agentIds: string[];
+  workflowIds: string[];
+};
+
+export interface GetScorersResponse {
+  scorers: Array<GetScorerResponse>;
+}

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

@@ -1,4 +1,4 @@
-import { isVercelTool } from '@mastra/core/tools';
+import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
 import { zodToJsonSchema } from './zod-to-json-schema';
 import type { ToolsInput } from '@mastra/core/agent';