@mastra/client-js 0.0.0-mcp-server-deploy-20250507160341 → 0.0.0-memory-system-message-error-20250813233316

package/src/types.ts

@@ -1,18 +1,28 @@
 import type {
-  MessageType,
+  MastraMessageV1,
   AiMessageType,
   CoreMessage,
   QueryResult,
-  StepAction,
-  StepGraph,
   StorageThreadType,
-  BaseLogMessage,
-  WorkflowRunResult as CoreWorkflowRunResult,
   WorkflowRuns,
+  WorkflowRun,
+  LegacyWorkflowRuns,
+  StorageGetMessagesArg,
+  PaginationInfo,
+  MastraMessageV2,
 } from '@mastra/core';
+import type { AgentGenerateOptions, AgentStreamOptions, ToolsInput, UIMessageWithMetadata } from '@mastra/core/agent';
+import type { BaseLogMessage, LogLevel } from '@mastra/core/logger';
 
-import type { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
-import type { NewWorkflow, WatchEvent, WorkflowResult as VNextWorkflowResult } from '@mastra/core/workflows/vNext';
+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,
+  StepGraph,
+  LegacyWorkflowRunResult as CoreLegacyWorkflowRunResult,
+} from '@mastra/core/workflows/legacy';
 import type { JSONSchema7 } from 'json-schema';
 import type { ZodSchema } from 'zod';
 
@@ -28,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 {
@@ -35,24 +46,48 @@ export interface RequestOptions {
   headers?: Record<string, string>;
   body?: any;
   stream?: boolean;
-  signal?: AbortSignal;
 }
 
+type WithoutMethods<T> = {
+  [K in keyof T as T[K] extends (...args: any[]) => any
+    ? never
+    : T[K] extends { (): any }
+      ? never
+      : T[K] extends undefined | ((...args: any[]) => any)
+        ? never
+        : K]: T[K];
+};
+
 export interface GetAgentResponse {
   name: string;
   instructions: string;
   tools: Record<string, GetToolResponse>;
+  workflows: Record<string, GetWorkflowResponse>;
   provider: string;
   modelId: string;
+  defaultGenerateOptions: WithoutMethods<AgentGenerateOptions>;
+  defaultStreamOptions: WithoutMethods<AgentStreamOptions>;
 }
 
 export type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-  messages: string | string[] | CoreMessage[] | AiMessageType[];
-} & Partial<AgentGenerateOptions<T>>;
+  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' | 'abortSignal'>
+>;
 
 export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-  messages: string | string[] | CoreMessage[] | AiMessageType[];
-} & Omit<AgentStreamOptions<T>, 'onFinish' | 'onStepFinish' | 'telemetry'>;
+  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' | 'abortSignal'>
+>;
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
   evals: any[];
@@ -68,7 +103,7 @@ export interface GetToolResponse {
   outputSchema: string;
 }
 
-export interface GetWorkflowResponse {
+export interface GetLegacyWorkflowResponse {
   name: string;
   triggerSchema: string;
   steps: Record<string, StepAction<any, any, any, any>>;
@@ -85,17 +120,24 @@ export interface GetWorkflowRunsParams {
   resourceId?: string;
 }
 
+export type GetLegacyWorkflowRunsResponse = LegacyWorkflowRuns;
+
 export type GetWorkflowRunsResponse = WorkflowRuns;
 
-export type WorkflowRunResult = {
+export type GetWorkflowRunByIdResponse = WorkflowRun;
+
+export type GetWorkflowRunExecutionResultResponse = WatchEvent['payload']['workflowState'];
+
+export type LegacyWorkflowRunResult = {
   activePaths: Record<string, { status: string; suspendPayload?: any; stepPath: string[] }>;
-  results: CoreWorkflowRunResult<any, any, any>['results'];
+  results: CoreLegacyWorkflowRunResult<any, any, any>['results'];
   timestamp: number;
   runId: string;
 };
 
-export interface GetVNextWorkflowResponse {
+export interface GetWorkflowResponse {
   name: string;
+  description?: string;
   steps: {
     [key: string]: {
       id: string;
@@ -106,14 +148,25 @@ export interface GetVNextWorkflowResponse {
       suspendSchema: string;
     };
   };
-  stepGraph: NewWorkflow['serializedStepGraph'];
+  allSteps: {
+    [key: string]: {
+      id: string;
+      description: string;
+      inputSchema: string;
+      outputSchema: string;
+      resumeSchema: string;
+      suspendSchema: string;
+      isWorkflow: boolean;
+    };
+  };
+  stepGraph: Workflow['serializedStepGraph'];
   inputSchema: string;
   outputSchema: string;
 }
 
-export type VNextWorkflowWatchResult = WatchEvent & { runId: string };
+export type WorkflowWatchResult = WatchEvent & { runId: string };
 
-export type VNextWorkflowRunResult = VNextWorkflowResult<any, any>;
+export type WorkflowRunResult = WorkflowResult<any, any>;
 export interface UpsertVectorParams {
   indexName: string;
   vectors: number[][];
@@ -145,20 +198,33 @@ export interface GetVectorIndexResponse {
 }
 
 export interface SaveMessageToMemoryParams {
-  messages: MessageType[];
+  messages: (MastraMessageV1 | MastraMessageV2)[];
   agentId: string;
 }
 
-export type SaveMessageToMemoryResponse = MessageType[];
+export interface SaveNetworkMessageToMemoryParams {
+  messages: (MastraMessageV1 | MastraMessageV2)[];
+  networkId: string;
+}
+
+export type SaveMessageToMemoryResponse = (MastraMessageV1 | MastraMessageV2)[];
 
 export interface CreateMemoryThreadParams {
-  title: string;
-  metadata: Record<string, any>;
+  title?: string;
+  metadata?: Record<string, any>;
   resourceId: string;
-  threadId: string;
+  threadId?: string;
   agentId: string;
 }
 
+export interface CreateNetworkMemoryThreadParams {
+  title?: string;
+  metadata?: Record<string, any>;
+  resourceId: string;
+  threadId?: string;
+  networkId: string;
+}
+
 export type CreateMemoryThreadResponse = StorageThreadType;
 
 export interface GetMemoryThreadParams {
@@ -166,6 +232,11 @@ export interface GetMemoryThreadParams {
   agentId: string;
 }
 
+export interface GetNetworkMemoryThreadParams {
+  resourceId: string;
+  networkId: string;
+}
+
 export type GetMemoryThreadResponse = StorageThreadType[];
 
 export interface UpdateMemoryThreadParams {
@@ -174,21 +245,52 @@ export interface UpdateMemoryThreadParams {
   resourceId: string;
 }
 
+export interface GetMemoryThreadMessagesParams {
+  /**
+   * Limit the number of messages to retrieve (default: 40)
+   */
+  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;
+  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>;
 
@@ -247,6 +349,7 @@ export interface GetTelemetryParams {
 }
 
 export interface GetNetworkResponse {
+  id: string;
   name: string;
   instructions: string;
   agents: Array<{
@@ -261,13 +364,139 @@ export interface GetNetworkResponse {
   state?: Record<string, any>;
 }
 
-export interface GetMCPServerResponse {
+export interface GetVNextNetworkResponse {
   id: string;
   name: string;
-  description?: string;
-  tools: Array<{
+  instructions: string;
+  agents: Array<{
+    name: string;
+    provider: string;
+    modelId: string;
+  }>;
+  routingModel: {
+    provider: string;
+    modelId: string;
+  };
+  workflows: Array<{
     name: string;
     description: string;
-    parameters: Record<string, any>;
+    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;
+  runtimeContext?: RuntimeContext | Record<string, any>;
+}
+
+export interface LoopStreamVNextNetworkParams {
+  message: string;
+  threadId?: string;
+  resourceId?: string;
+  maxIterations?: number;
+  runtimeContext?: RuntimeContext | Record<string, any>;
+}
+
+export interface LoopVNextNetworkResponse {
+  status: 'success';
+  result: {
+    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'];
+}
+
+export interface McpServerListResponse {
+  servers: ServerInfo[];
+  next: string | null;
+  total_count: number;
+}
+
+export interface McpToolInfo {
+  id: string;
+  name: string;
+  description?: string;
+  inputSchema: string;
+  toolType?: MCPToolType;
+}
+
+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/index.ts

@@ -0,0 +1,11 @@
+import { RuntimeContext } from '@mastra/core/runtime-context';
+
+export function parseClientRuntimeContext(runtimeContext?: RuntimeContext | Record<string, any>) {
+  if (runtimeContext) {
+    if (runtimeContext instanceof RuntimeContext) {
+      return Object.fromEntries(runtimeContext.entries());
+    }
+    return runtimeContext;
+  }
+  return undefined;
+}

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

@@ -0,0 +1,32 @@
+import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
+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,
+          },
+        ];
+      }
+    }),
+  );
+}

package/src/utils/zod-to-json-schema.ts

@@ -0,0 +1,10 @@
+import { ZodSchema } from 'zod';
+import originalZodToJsonSchema from 'zod-to-json-schema';
+
+export function zodToJsonSchema<T extends ZodSchema | any>(zodSchema: T) {
+  if (!(zodSchema instanceof ZodSchema)) {
+    return zodSchema;
+  }
+
+  return originalZodToJsonSchema(zodSchema, { $refStrategy: 'none' });
+}

package/src/v2-messages.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { MastraMessageV1, MastraMessageV2 } from '@mastra/core';
+import { MastraClient } from './client';
+
+describe('V2 Message Format Support', () => {
+  let client: MastraClient;
+  const agentId = 'test-agent';
+
+  beforeEach(() => {
+    global.fetch = vi.fn();
+    client = new MastraClient({
+      baseUrl: 'http://localhost:3000',
+    });
+  });
+
+  it('should send v1 messages successfully', async () => {
+    const v1Messages: MastraMessageV1[] = [
+      {
+        id: 'msg-v1-1',
+        role: 'user',
+        content: 'Hello from v1!',
+        type: 'text',
+        createdAt: new Date(),
+        threadId: 'thread-123',
+        resourceId: 'resource-123',
+      },
+    ];
+
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: async () => v1Messages,
+    });
+
+    const result = await client.saveMessageToMemory({
+      agentId,
+      messages: v1Messages,
+    });
+
+    expect(result).toEqual(v1Messages);
+    expect(global.fetch).toHaveBeenCalledWith(
+      expect.stringContaining('/api/memory/save-messages'),
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({ agentId, messages: v1Messages }),
+      }),
+    );
+  });
+
+  it('should send v2 messages successfully', async () => {
+    const v2Messages: MastraMessageV2[] = [
+      {
+        id: 'msg-v2-1',
+        role: 'assistant',
+        createdAt: new Date(),
+        threadId: 'thread-123',
+        resourceId: 'resource-123',
+        content: {
+          format: 2,
+          parts: [{ type: 'text', text: 'Hello from v2!' }],
+          content: 'Hello from v2!',
+        },
+      },
+    ];
+
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: async () => v2Messages,
+    });
+
+    const result = await client.saveMessageToMemory({
+      agentId,
+      messages: v2Messages,
+    });
+
+    expect(result).toEqual(v2Messages);
+    expect(global.fetch).toHaveBeenCalledWith(
+      expect.stringContaining('/api/memory/save-messages'),
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({ agentId, messages: v2Messages }),
+      }),
+    );
+  });
+
+  it('should send mixed v1 and v2 messages successfully', async () => {
+    const mixedMessages: (MastraMessageV1 | MastraMessageV2)[] = [
+      {
+        id: 'msg-v1-1',
+        role: 'user',
+        content: 'Question in v1 format',
+        type: 'text',
+        createdAt: new Date(),
+        threadId: 'thread-123',
+        resourceId: 'resource-123',
+      },
+      {
+        id: 'msg-v2-1',
+        role: 'assistant',
+        createdAt: new Date(),
+        threadId: 'thread-123',
+        resourceId: 'resource-123',
+        content: {
+          format: 2,
+          parts: [
+            { type: 'text', text: 'Answer in v2 format' },
+            {
+              type: 'tool-invocation',
+              toolInvocation: {
+                state: 'result' as const,
+                toolCallId: 'call-123',
+                toolName: 'calculator',
+                args: { a: 1, b: 2 },
+                result: '3',
+              },
+            },
+          ],
+          toolInvocations: [
+            {
+              state: 'result' as const,
+              toolCallId: 'call-123',
+              toolName: 'calculator',
+              args: { a: 1, b: 2 },
+              result: '3',
+            },
+          ],
+        },
+      },
+    ];
+
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: async () => mixedMessages,
+    });
+
+    const result = await client.saveMessageToMemory({
+      agentId,
+      messages: mixedMessages,
+    });
+
+    expect(result).toEqual(mixedMessages);
+    expect(global.fetch).toHaveBeenCalledWith(
+      expect.stringContaining('/api/memory/save-messages'),
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({ agentId, messages: mixedMessages }),
+      }),
+    );
+  });
+
+  it('should handle v2 messages with attachments', async () => {
+    const v2MessageWithAttachments: MastraMessageV2 = {
+      id: 'msg-v2-att',
+      role: 'user',
+      createdAt: new Date(),
+      threadId: 'thread-123',
+      resourceId: 'resource-123',
+      content: {
+        format: 2,
+        parts: [
+          { type: 'text', text: 'Check out this image:' },
+          { type: 'file', data: 'data:image/png;base64,iVBORw0...', mimeType: 'image/png' },
+        ],
+        experimental_attachments: [{ url: 'data:image/png;base64,iVBORw0...', contentType: 'image/png' }],
+      },
+    };
+
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: async () => [v2MessageWithAttachments],
+    });
+
+    const result = await client.saveMessageToMemory({
+      agentId,
+      messages: [v2MessageWithAttachments],
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(v2MessageWithAttachments);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": ["./tsconfig.json", "../../tsconfig.build.json"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts", "src/**/*.mock.ts"]
+}

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
   "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "tsup.config.ts"],
   "exclude": ["node_modules", "**/*.test.ts"]
 }

package/tsup.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'tsup';
+import { generateTypes } from '@internal/types-builder';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  clean: true,
+  dts: false,
+  splitting: true,
+  treeshake: {
+    preset: 'smallest',
+  },
+  sourcemap: true,
+  onSuccess: async () => {
+    await generateTypes(process.cwd());
+  },
+});