@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-vnext-inngest-20250506121901

package/package.json

@@ -1,41 +1,52 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.0.0-storage-20250225005900",
+  "version": "0.0.0-vnext-inngest-20250506121901",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
-  "types": "dist/index.d.mts",
-  "main": "dist/index.mjs",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     },
     "./package.json": "./package.json"
   },
   "repository": "github:mastra-ai/client-js",
-  "license": "ISC",
+  "license": "Elastic-2.0",
   "dependencies": {
+    "@ag-ui/client": "^0.0.27",
+    "@ai-sdk/ui-utils": "^1.1.19",
     "json-schema": "^0.4.0",
-    "zod": "^3.24.1",
-    "zod-to-json-schema": "^3.24.1",
-    "@mastra/core": "^0.0.0-storage-20250225005900"
+    "rxjs": "7.8.1",
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.3",
+    "@mastra/core": "0.0.0-vnext-inngest-20250506121901"
+  },
+  "peerDependencies": {
+    "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.26.0",
-    "@babel/preset-typescript": "^7.26.0",
-    "@tsconfig/recommended": "^1.0.7",
+    "@babel/preset-env": "^7.26.9",
+    "@babel/preset-typescript": "^7.27.0",
+    "@tsconfig/recommended": "^1.0.8",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^22.9.0",
-    "tsup": "^8.0.1",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.4",
-    "@internal/lint": "0.0.0"
+    "@types/node": "^20.17.27",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2",
+    "vitest": "^3.1.2",
+    "@internal/lint": "0.0.0-vnext-inngest-20250506121901"
   },
   "scripts": {
-    "build": "tsup-node src/index.ts --format esm --dts --clean --treeshake",
-    "dev": "tsup-node src/index.ts --format esm --dts --clean --treeshake --watch",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting",
+    "dev": "pnpm build --watch",
     "test": "vitest run"
   }
 }

package/src/adapters/agui.test.ts

@@ -0,0 +1,167 @@
+import type { Message } from '@ag-ui/client';
+import { describe, it, expect } from 'vitest';
+import { generateUUID, convertMessagesToMastraMessages } from './agui';
+
+describe('generateUUID', () => {
+  it('should generate a valid UUID v4 string', () => {
+    const uuid = generateUUID();
+    // Check UUID format (8-4-4-4-12 hex digits)
+    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+  });
+
+  it('should generate unique UUIDs', () => {
+    const uuids = new Set();
+    for (let i = 0; i < 100; i++) {
+      uuids.add(generateUUID());
+    }
+    // All UUIDs should be unique
+    expect(uuids.size).toBe(100);
+  });
+});
+
+describe('convertMessagesToMastraMessages', () => {
+  it('should convert user messages correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'user',
+        content: 'Hello, world!',
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toEqual([
+      {
+        role: 'user',
+        content: 'Hello, world!',
+      },
+    ]);
+  });
+
+  it('should convert assistant messages correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'assistant',
+        content: 'Hello, I am an assistant',
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toEqual([
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello, I am an assistant' }],
+      },
+    ]);
+  });
+
+  it('should convert assistant messages with tool calls correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'assistant',
+        content: undefined,
+        toolCalls: [
+          {
+            id: 'tool-call-1',
+            type: 'function',
+            function: {
+              name: 'getWeather',
+              arguments: '{"location":"San Francisco"}',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toEqual([
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            toolCallId: 'tool-call-1',
+            toolName: 'getWeather',
+            args: { location: 'San Francisco' },
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('should convert tool messages correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'tool',
+        toolCallId: 'tool-call-1',
+        content: '{"temperature":72,"unit":"F"}',
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toEqual([
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-1',
+            toolName: 'unknown',
+            result: '{"temperature":72,"unit":"F"}',
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('should convert a complex conversation correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'user',
+        content: "What's the weather in San Francisco?",
+      },
+      {
+        id: '2',
+        role: 'assistant',
+        content: undefined,
+        toolCalls: [
+          {
+            id: 'tool-call-1',
+            type: 'function',
+            function: {
+              name: 'getWeather',
+              arguments: '{"location":"San Francisco"}',
+            },
+          },
+        ],
+      },
+      {
+        id: '3',
+        role: 'tool',
+        toolCallId: 'tool-call-1',
+        content: '{"temperature":72,"unit":"F"}',
+      },
+      {
+        id: '4',
+        role: 'assistant',
+        content: 'The weather in San Francisco is 72°F.',
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toHaveLength(4);
+    expect(result[0].role).toBe('user');
+    expect(result[1].role).toBe('assistant');
+    expect(result[2].role).toBe('tool');
+    expect(result[3].role).toBe('assistant');
+  });
+});

package/src/adapters/agui.ts

@@ -0,0 +1,219 @@
+// Cross-platform UUID generation function
+import { AbstractAgent, EventType } from '@ag-ui/client';
+import type {
+  BaseEvent,
+  RunAgentInput,
+  AgentConfig,
+  RunStartedEvent,
+  RunFinishedEvent,
+  TextMessageStartEvent,
+  TextMessageContentEvent,
+  TextMessageEndEvent,
+  Message,
+  ToolCallStartEvent,
+  ToolCallArgsEvent,
+  ToolCallEndEvent,
+} from '@ag-ui/client';
+import type { CoreMessage } from '@mastra/core';
+import { Observable } from 'rxjs';
+import type { Agent } from '../resources/agent';
+
+interface MastraAgentConfig extends AgentConfig {
+  agent: Agent;
+  agentId: string;
+  resourceId?: string;
+}
+
+export class AGUIAdapter extends AbstractAgent {
+  agent: Agent;
+  resourceId?: string;
+  constructor({ agent, agentId, resourceId, ...rest }: MastraAgentConfig) {
+    super({
+      agentId,
+      ...rest,
+    });
+    this.agent = agent;
+    this.resourceId = resourceId;
+  }
+
+  protected run(input: RunAgentInput): Observable<BaseEvent> {
+    return new Observable<BaseEvent>(subscriber => {
+      const convertedMessages = convertMessagesToMastraMessages(input.messages);
+
+      subscriber.next({
+        type: EventType.RUN_STARTED,
+        threadId: input.threadId,
+        runId: input.runId,
+      } as RunStartedEvent);
+
+      this.agent
+        .stream({
+          threadId: input.threadId,
+          resourceId: this.resourceId ?? '',
+          runId: input.runId,
+          messages: convertedMessages,
+          clientTools: input.tools.reduce(
+            (acc, tool) => {
+              acc[tool.name as string] = {
+                id: tool.name,
+                description: tool.description,
+                inputSchema: tool.parameters,
+              };
+              return acc;
+            },
+            {} as Record<string, any>,
+          ),
+        })
+        .then(response => {
+          let currentMessageId: string | undefined = undefined;
+          return response.processDataStream({
+            onTextPart: text => {
+              if (currentMessageId === undefined) {
+                currentMessageId = generateUUID();
+
+                const message: TextMessageStartEvent = {
+                  type: EventType.TEXT_MESSAGE_START,
+                  messageId: currentMessageId,
+                  role: 'assistant',
+                };
+                subscriber.next(message);
+              }
+
+              const message: TextMessageContentEvent = {
+                type: EventType.TEXT_MESSAGE_CONTENT,
+                messageId: currentMessageId,
+                delta: text,
+              };
+              subscriber.next(message);
+            },
+            onFinishMessagePart: message => {
+              console.log('onFinishMessagePart', message);
+              if (currentMessageId !== undefined) {
+                const message: TextMessageEndEvent = {
+                  type: EventType.TEXT_MESSAGE_END,
+                  messageId: currentMessageId,
+                };
+                subscriber.next(message);
+              }
+              // Emit run finished event
+              subscriber.next({
+                type: EventType.RUN_FINISHED,
+                threadId: input.threadId,
+                runId: input.runId,
+              } as RunFinishedEvent);
+
+              // Complete the observable
+              subscriber.complete();
+            },
+            onToolCallPart(streamPart) {
+              const parentMessageId = currentMessageId || generateUUID();
+              subscriber.next({
+                type: EventType.TOOL_CALL_START,
+                toolCallId: streamPart.toolCallId,
+                toolCallName: streamPart.toolName,
+                parentMessageId,
+              } as ToolCallStartEvent);
+
+              subscriber.next({
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: streamPart.toolCallId,
+                delta: JSON.stringify(streamPart.args),
+                parentMessageId,
+              } as ToolCallArgsEvent);
+
+              subscriber.next({
+                type: EventType.TOOL_CALL_END,
+                toolCallId: streamPart.toolCallId,
+                parentMessageId,
+              } as ToolCallEndEvent);
+            },
+          });
+        })
+        .catch(error => {
+          console.log('error', error);
+          // Handle error
+          subscriber.error(error);
+        });
+
+      return () => {};
+    });
+  }
+}
+
+/**
+ * Generates a UUID v4 that works in both browser and Node.js environments
+ */
+export function generateUUID(): string {
+  // Use crypto.randomUUID() if available (Node.js environment or modern browsers)
+  if (typeof crypto !== 'undefined') {
+    // Browser crypto API or Node.js crypto global
+    if (typeof crypto.randomUUID === 'function') {
+      return crypto.randomUUID();
+    }
+    // Fallback for older browsers
+    if (typeof crypto.getRandomValues === 'function') {
+      const buffer = new Uint8Array(16);
+      crypto.getRandomValues(buffer);
+      // Set version (4) and variant (8, 9, A, or B)
+      buffer[6] = (buffer[6]! & 0x0f) | 0x40; // version 4
+      buffer[8] = (buffer[8]! & 0x3f) | 0x80; // variant
+
+      // Convert to hex string in UUID format
+      let hex = '';
+      for (let i = 0; i < 16; i++) {
+        hex += buffer[i]!.toString(16).padStart(2, '0');
+        // Add hyphens at standard positions
+        if (i === 3 || i === 5 || i === 7 || i === 9) hex += '-';
+      }
+      return hex;
+    }
+  }
+
+  // Last resort fallback (less secure but works everywhere)
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+export function convertMessagesToMastraMessages(messages: Message[]): CoreMessage[] {
+  const result: CoreMessage[] = [];
+
+  for (const message of messages) {
+    if (message.role === 'assistant') {
+      const parts: any[] = message.content ? [{ type: 'text', text: message.content }] : [];
+      for (const toolCall of message.toolCalls ?? []) {
+        parts.push({
+          type: 'tool-call',
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          args: JSON.parse(toolCall.function.arguments),
+        });
+      }
+      result.push({
+        role: 'assistant',
+        content: parts,
+      });
+    } else if (message.role === 'user') {
+      result.push({
+        role: 'user',
+        content: message.content || '',
+      });
+    } else if (message.role === 'tool') {
+      result.push({
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: message.toolCallId,
+            toolName: 'unknown',
+            result: message.content,
+          },
+        ],
+      });
+    }
+  }
+
+  return result;
+}

package/src/client.ts

@@ -1,4 +1,6 @@
-import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource } from './resources';
+import type { AbstractAgent } from '@ag-ui/client';
+import { AGUIAdapter } from './adapters/agui';
+import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource, Network, VNextWorkflow } from './resources';
 import type {
   ClientOptions,
   CreateMemoryThreadParams,
@@ -9,11 +11,12 @@ import type {
   GetLogsResponse,
   GetMemoryThreadParams,
   GetMemoryThreadResponse,
+  GetNetworkResponse,
   GetTelemetryParams,
   GetTelemetryResponse,
   GetToolResponse,
+  GetVNextWorkflowResponse,
   GetWorkflowResponse,
-  RequestOptions,
   SaveMessageToMemoryParams,
   SaveMessageToMemoryResponse,
 } from './types';
@@ -31,6 +34,25 @@ export class MastraClient extends BaseResource {
     return this.request('/api/agents');
   }
 
+  public async getAGUI({ resourceId }: { resourceId: string }): Promise<Record<string, AbstractAgent>> {
+    const agents = await this.getAgents();
+
+    return Object.entries(agents).reduce(
+      (acc, [agentId]) => {
+        const agent = this.getAgent(agentId);
+
+        acc[agentId] = new AGUIAdapter({
+          agentId,
+          agent,
+          resourceId,
+        });
+
+        return acc;
+      },
+      {} as Record<string, AbstractAgent>,
+    );
+  }
+
   /**
    * Gets an agent instance by ID
    * @param agentId - ID of the agent to retrieve
@@ -121,6 +143,23 @@ export class MastraClient extends BaseResource {
     return new Workflow(this.options, workflowId);
   }
 
+  /**
+   * Retrieves all available vNext workflows
+   * @returns Promise containing map of vNext workflow IDs to vNext workflow details
+   */
+  public getVNextWorkflows(): Promise<Record<string, GetVNextWorkflowResponse>> {
+    return this.request('/api/workflows/v-next');
+  }
+
+  /**
+   * Gets a vNext workflow instance by ID
+   * @param workflowId - ID of the vNext workflow to retrieve
+   * @returns vNext Workflow instance
+   */
+  public getVNextWorkflow(workflowId: string) {
+    return new VNextWorkflow(this.options, workflowId);
+  }
+
   /**
    * Gets a vector instance by name
    * @param vectorName - Name of the vector to retrieve
@@ -162,17 +201,9 @@ export class MastraClient extends BaseResource {
    * @returns Promise containing telemetry data
    */
   public getTelemetry(params?: GetTelemetryParams): Promise<GetTelemetryResponse> {
-    const { name, scope, page, perPage, attribute } = params || {};
+    const { name, scope, page, perPage, attribute, fromDate, toDate } = params || {};
     const _attribute = attribute ? Object.entries(attribute).map(([key, value]) => `${key}:${value}`) : [];
 
-    const queryObj = {
-      ...(name ? { name } : {}),
-      ...(scope ? { scope } : {}),
-      ...(page ? { page: String(page) } : {}),
-      ...(perPage ? { perPage: String(perPage) } : {}),
-      ...(_attribute?.length ? { attribute: _attribute } : {}),
-    } as const;
-
     const searchParams = new URLSearchParams();
     if (name) {
       searchParams.set('name', name);
@@ -195,6 +226,12 @@ export class MastraClient extends BaseResource {
         searchParams.set('attribute', _attribute);
       }
     }
+    if (fromDate) {
+      searchParams.set('fromDate', fromDate.toISOString());
+    }
+    if (toDate) {
+      searchParams.set('toDate', toDate.toISOString());
+    }
 
     if (searchParams.size) {
       return this.request(`/api/telemetry?${searchParams}`);
@@ -202,4 +239,21 @@ export class MastraClient extends BaseResource {
       return this.request(`/api/telemetry`);
     }
   }
+
+  /**
+   * Retrieves all available networks
+   * @returns Promise containing map of network IDs to network details
+   */
+  public getNetworks(): Promise<Record<string, GetNetworkResponse>> {
+    return this.request('/api/networks');
+  }
+
+  /**
+   * Gets a network instance by ID
+   * @param networkId - ID of the network to retrieve
+   * @returns Network instance
+   */
+  public getNetwork(networkId: string) {
+    return new Network(this.options, networkId);
+  }
 }

package/src/example.ts

@@ -1,43 +1,65 @@
-import { MastraClient } from './client';
-
-(async () => {
-  const client = new MastraClient({
-    baseUrl: 'http://localhost:4111',
-  });
-
-  try {
-    const agent = client.getAgent('weatherAgent');
-    const response = await agent.stream({
-      messages: [
-        {
-          role: 'user',
-          content: 'Hello, world!',
-        },
-      ],
-    });
-
-    const reader = response?.body?.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-
-    while (true) {
-      if (!reader) break;
-      const { value, done } = await reader.read();
-      if (done) break;
-
-      const chunk = decoder.decode(value);
-      buffer += chunk;
-
-      console.log(buffer);
-
-      const matches = buffer.matchAll(/0:"([^"]*)"/g);
-
-      for (const match of matches) {
-        const content = match[1];
-        process.stdout.write(`${content}\n`);
-      }
-    }
-  } catch (error) {
-    console.error(error);
-  }
-})();
+// import { MastraClient } from './client';
+// import type { WorkflowRunResult } from './types';
+
+// Agent
+
+// (async () => {
+//   const client = new MastraClient({
+//     baseUrl: 'http://localhost:4111',
+//   });
+
+//   console.log('Starting agent...');
+
+//   try {
+//     const agent = client.getAgent('weatherAgent');
+//     const response = await agent.stream({
+//       messages: 'what is the weather in new york?',
+//     })
+
+//     response.processDataStream({
+//       onTextPart: (text) => {
+//         process.stdout.write(text);
+//       },
+//       onFilePart: (file) => {
+//         console.log(file);
+//       },
+//       onDataPart: (data) => {
+//         console.log(data);
+//       },
+//       onErrorPart: (error) => {
+//         console.error(error);
+//       },
+//     });
+
+//   } catch (error) {
+//     console.error(error);
+//   }
+// })();
+
+// Workflow
+// (async () => {
+//   const client = new MastraClient({
+//     baseUrl: 'http://localhost:4111',
+//   });
+
+//   try {
+//     const workflowId = 'myWorkflow';
+//     const workflow = client.getWorkflow(workflowId);
+
+//     const { runId } = await workflow.createRun();
+
+//     workflow.watch({ runId }, record => {
+//       console.log(new Date().toTimeString(), record);
+//     });
+
+//     await workflow.start({
+//       runId,
+//       triggerData: {
+//         city: 'New York',
+//       },
+//     });
+
+//   } catch (e) {
+//     console.error('Workflow error:', e);
+//   }
+// })();