@mastra/client-js 0.0.0-pg-pool-options-20250428183821 → 0.0.0-redis-cloud-transporter-20250508191651

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,3 +1,5 @@
+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,
@@ -32,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
@@ -180,7 +201,7 @@ 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 searchParams = new URLSearchParams();
@@ -205,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}`);

package/src/index.test.ts

@@ -1,4 +1,3 @@
-import type { MessageType } from '@mastra/core';
 import { describe, expect, beforeEach, it, vi } from 'vitest';
 
 import { MastraClient } from './client';
@@ -489,7 +488,7 @@ describe('MastraClient Resources', () => {
       const result = await memoryThread.update({
         title: 'Updated Thread',
         metadata: { updated: true },
-        resourceid: 'test-resource',
+        resourceId: 'test-resource',
       });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
@@ -536,6 +535,7 @@ describe('MastraClient Resources', () => {
           content: 'test',
           role: 'user' as const,
           threadId: 'test-thread',
+          resourceId: 'test-resource',
           createdAt: new Date('2025-03-26T10:40:55.116Z'),
         },
       ];
@@ -584,10 +584,10 @@ describe('MastraClient Resources', () => {
     it('should execute tool', async () => {
       const mockResponse = { data: 'test' };
       mockFetchResponse(mockResponse);
-      const result = await tool.execute({ data: '' });
+      const result = await tool.execute({ data: '', runId: 'test-run-id' });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
-        `${clientOptions.baseUrl}/api/tools/test-tool/execute`,
+        `${clientOptions.baseUrl}/api/tools/test-tool/execute?runId=test-run-id`,
         expect.objectContaining({
           method: 'POST',
           headers: expect.objectContaining({

package/src/resources/agent.ts

@@ -1,8 +1,8 @@
+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 'zod-to-json-schema';
-import { processDataStream } from '@ai-sdk/ui-utils';
 
 import type {
   GenerateParams,
@@ -29,7 +29,6 @@ export class AgentTool extends BaseResource {
    * @param params - Parameters required for tool execution
    * @returns Promise containing tool execution results
    */
-  /** @deprecated use CreateRun/startRun */
   execute(params: { data: any }): Promise<any> {
     return this.request(`/api/agents/${this.agentId}/tools/${this.toolId}/execute`, {
       method: 'POST',
@@ -127,6 +126,7 @@ export class Agent extends BaseResource {
         params.experimental_output instanceof ZodSchema
           ? zodToJsonSchema(params.experimental_output)
           : params.experimental_output,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
     };
 
     return this.request(`/api/agents/${this.agentId}/generate`, {
@@ -154,6 +154,7 @@ export class Agent extends BaseResource {
         params.experimental_output instanceof ZodSchema
           ? zodToJsonSchema(params.experimental_output)
           : params.experimental_output,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
     };
 
     const response: Response & {

package/src/resources/base.ts

@@ -1,4 +1,4 @@
-import type { RequestFunction, RequestOptions, ClientOptions } from '../types';
+import type { RequestOptions, ClientOptions } from '../types';
 
 export class BaseResource {
   readonly options: ClientOptions;

package/src/resources/network.ts

@@ -1,3 +1,4 @@
+import { processDataStream } from '@ai-sdk/ui-utils';
 import type { GenerateReturn } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
@@ -6,7 +7,6 @@ import { zodToJsonSchema } from 'zod-to-json-schema';
 import type { GenerateParams, ClientOptions, StreamParams, GetNetworkResponse } from '../types';
 
 import { BaseResource } from './base';
-import { processDataStream } from '@ai-sdk/ui-utils';
 
 export class Network extends BaseResource {
   constructor(

package/src/resources/tool.ts

@@ -23,10 +23,16 @@ export class Tool extends BaseResource {
    * @param params - Parameters required for tool execution
    * @returns Promise containing the tool execution results
    */
-  execute(params: { data: any }): Promise<any> {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
+  execute(params: { data: any; runId?: string }): Promise<any> {
+    const url = new URLSearchParams();
+
+    if (params.runId) {
+      url.set('runId', params.runId);
+    }
+
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: 'POST',
-      body: params,
+      body: params.data,
     });
   }
 }

package/src/resources/vnext-workflow.ts

@@ -2,6 +2,8 @@ import type { RuntimeContext } from '@mastra/core/runtime-context';
 import type {
   ClientOptions,
   GetVNextWorkflowResponse,
+  GetWorkflowRunsParams,
+  GetWorkflowRunsResponse,
   VNextWorkflowRunResult,
   VNextWorkflowWatchResult,
 } from '../types';
@@ -67,7 +69,7 @@ export class VNextWorkflow extends BaseResource {
               }
             }
           }
-        } catch (error) {
+        } catch {
           // Silently ignore parsing errors to maintain stream processing
           // This allows the stream to continue even if one record is malformed
         }
@@ -97,6 +99,36 @@ export class VNextWorkflow extends BaseResource {
     return this.request(`/api/workflows/v-next/${this.workflowId}`);
   }
 
+  /**
+   * Retrieves all runs for a vNext workflow
+   * @param params - Parameters for filtering runs
+   * @returns Promise containing vNext workflow runs array
+   */
+  runs(params?: GetWorkflowRunsParams): Promise<GetWorkflowRunsResponse> {
+    const searchParams = new URLSearchParams();
+    if (params?.fromDate) {
+      searchParams.set('fromDate', params.fromDate.toISOString());
+    }
+    if (params?.toDate) {
+      searchParams.set('toDate', params.toDate.toISOString());
+    }
+    if (params?.limit) {
+      searchParams.set('limit', String(params.limit));
+    }
+    if (params?.offset) {
+      searchParams.set('offset', String(params.offset));
+    }
+    if (params?.resourceId) {
+      searchParams.set('resourceId', params.resourceId);
+    }
+
+    if (searchParams.size) {
+      return this.request(`/api/workflows/v-next/${this.workflowId}/runs?${searchParams}`);
+    } else {
+      return this.request(`/api/workflows/v-next/${this.workflowId}/runs`);
+    }
+  }
+
   /**
    * Creates a new vNext workflow run
    * @param params - Optional object containing the optional runId

package/src/resources/workflow.ts

@@ -1,4 +1,10 @@
-import type { GetWorkflowResponse, ClientOptions, WorkflowRunResult } from '../types';
+import type {
+  GetWorkflowResponse,
+  ClientOptions,
+  WorkflowRunResult,
+  GetWorkflowRunsResponse,
+  GetWorkflowRunsParams,
+} from '../types';
 
 import { BaseResource } from './base';
 
@@ -20,6 +26,36 @@ export class Workflow extends BaseResource {
     return this.request(`/api/workflows/${this.workflowId}`);
   }
 
+  /**
+   * Retrieves all runs for a workflow
+   * @param params - Parameters for filtering runs
+   * @returns Promise containing workflow runs array
+   */
+  runs(params?: GetWorkflowRunsParams): Promise<GetWorkflowRunsResponse> {
+    const searchParams = new URLSearchParams();
+    if (params?.fromDate) {
+      searchParams.set('fromDate', params.fromDate.toISOString());
+    }
+    if (params?.toDate) {
+      searchParams.set('toDate', params.toDate.toISOString());
+    }
+    if (params?.limit) {
+      searchParams.set('limit', String(params.limit));
+    }
+    if (params?.offset) {
+      searchParams.set('offset', String(params.offset));
+    }
+    if (params?.resourceId) {
+      searchParams.set('resourceId', params.resourceId);
+    }
+
+    if (searchParams.size) {
+      return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
+    } else {
+      return this.request(`/api/workflows/${this.workflowId}/runs`);
+    }
+  }
+
   /**
    * @deprecated Use `startAsync` instead
    * Executes the workflow with the provided parameters
@@ -168,7 +204,7 @@ export class Workflow extends BaseResource {
               }
             }
           }
-        } catch (error) {
+        } catch {
           // Silently ignore parsing errors to maintain stream processing
           // This allows the stream to continue even if one record is malformed
         }

package/src/types.ts

@@ -8,6 +8,7 @@ import type {
   StorageThreadType,
   BaseLogMessage,
   WorkflowRunResult as CoreWorkflowRunResult,
+  WorkflowRuns,
 } from '@mastra/core';
 
 import type { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
@@ -55,6 +56,9 @@ export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefin
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
   evals: any[];
+  instructions: string;
+  name: string;
+  id: string;
 }
 
 export interface GetToolResponse {
@@ -73,6 +77,16 @@ export interface GetWorkflowResponse {
   workflowId?: string;
 }
 
+export interface GetWorkflowRunsParams {
+  fromDate?: Date;
+  toDate?: Date;
+  limit?: number;
+  offset?: number;
+  resourceId?: string;
+}
+
+export type GetWorkflowRunsResponse = WorkflowRuns;
+
 export type WorkflowRunResult = {
   activePaths: Record<string, { status: string; suspendPayload?: any; stepPath: string[] }>;
   results: CoreWorkflowRunResult<any, any, any>['results'];
@@ -82,8 +96,17 @@ export type WorkflowRunResult = {
 
 export interface GetVNextWorkflowResponse {
   name: string;
-  steps: NewWorkflow['steps'];
-  stepGraph: NewWorkflow['stepGraph'];
+  steps: {
+    [key: string]: {
+      id: string;
+      description: string;
+      inputSchema: string;
+      outputSchema: string;
+      resumeSchema: string;
+      suspendSchema: string;
+    };
+  };
+  stepGraph: NewWorkflow['serializedStepGraph'];
   inputSchema: string;
   outputSchema: string;
 }
@@ -219,6 +242,8 @@ export interface GetTelemetryParams {
   page?: number;
   perPage?: number;
   attribute?: Record<string, string>;
+  fromDate?: Date;
+  toDate?: Date;
 }
 
 export interface GetNetworkResponse {