@mastra/client-js 0.0.0-ai-v5-20250718021026 → 0.0.0-ai-v5-20250729181825

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 { 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,
@@ -194,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;
@@ -252,11 +256,17 @@ export interface GetMemoryThreadMessagesParams {
   format?: 'aiv4' | 'aiv5';
 }
 
+export type GetMemoryThreadMessagesPaginatedParams = Omit<StorageGetMessagesArg, 'threadConfig' | 'threadId'>;
+
 export interface GetMemoryThreadMessagesResponse {
   messages: CoreMessage[];
   uiMessages: UIMessage[];
 }
 
+export type GetMemoryThreadMessagesPaginatedResponse = PaginationInfo & {
+  messages: MastraMessageV1[] | MastraMessageV2[];
+};
+
 export interface GetLogsParams {
   transportId: string;
   fromDate?: Date;
@@ -408,7 +418,17 @@ export interface LoopStreamVNextNetworkParams {
 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'];
 }
@@ -430,3 +450,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';
 

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/.turbo/turbo-build.log

@@ -1,19 +0,0 @@
-
-> @mastra/client-js@0.10.15-alpha.1 build /home/runner/work/mastra/mastra/client-sdks/client-js
-> tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.0
-CLI Target: es2022
-CLI Cleaning output folder
-ESM Build start
-CJS Build start
-DTS Build start
-ESM dist/index.js 71.36 KB
-ESM ⚡️ Build success in 2104ms
-CJS dist/index.cjs 71.66 KB
-CJS ⚡️ Build success in 2109ms
-DTS ⚡️ Build success in 18106ms
-DTS dist/index.d.ts  42.03 KB
-DTS dist/index.d.cts 42.03 KB