@mastra/client-js 0.0.0-vnext-inngest-20250508122351 → 0.0.0-vnext-20251104230439

package/eslint.config.js

@@ -1,6 +0,0 @@
-import { createConfig } from '@internal/lint/eslint';
-
-const config = await createConfig();
-
-/** @type {import("eslint").Linter.Config[]} */
-export default [...config];

package/src/adapters/agui.test.ts

@@ -1,167 +0,0 @@
-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

@@ -1,219 +0,0 @@
-// 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,259 +0,0 @@
-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,
-  CreateMemoryThreadResponse,
-  GetAgentResponse,
-  GetLogParams,
-  GetLogsParams,
-  GetLogsResponse,
-  GetMemoryThreadParams,
-  GetMemoryThreadResponse,
-  GetNetworkResponse,
-  GetTelemetryParams,
-  GetTelemetryResponse,
-  GetToolResponse,
-  GetVNextWorkflowResponse,
-  GetWorkflowResponse,
-  SaveMessageToMemoryParams,
-  SaveMessageToMemoryResponse,
-} from './types';
-
-export class MastraClient extends BaseResource {
-  constructor(options: ClientOptions) {
-    super(options);
-  }
-
-  /**
-   * Retrieves all available agents
-   * @returns Promise containing map of agent IDs to agent details
-   */
-  public getAgents(): Promise<Record<string, GetAgentResponse>> {
-    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
-   * @returns Agent instance
-   */
-  public getAgent(agentId: string) {
-    return new Agent(this.options, agentId);
-  }
-
-  /**
-   * Retrieves memory threads for a resource
-   * @param params - Parameters containing the resource ID
-   * @returns Promise containing array of memory threads
-   */
-  public getMemoryThreads(params: GetMemoryThreadParams): Promise<GetMemoryThreadResponse> {
-    return this.request(`/api/memory/threads?resourceid=${params.resourceId}&agentId=${params.agentId}`);
-  }
-
-  /**
-   * Creates a new memory thread
-   * @param params - Parameters for creating the memory thread
-   * @returns Promise containing the created memory thread
-   */
-  public createMemoryThread(params: CreateMemoryThreadParams): Promise<CreateMemoryThreadResponse> {
-    return this.request(`/api/memory/threads?agentId=${params.agentId}`, { method: 'POST', body: params });
-  }
-
-  /**
-   * Gets a memory thread instance by ID
-   * @param threadId - ID of the memory thread to retrieve
-   * @returns MemoryThread instance
-   */
-  public getMemoryThread(threadId: string, agentId: string) {
-    return new MemoryThread(this.options, threadId, agentId);
-  }
-
-  /**
-   * Saves messages to memory
-   * @param params - Parameters containing messages to save
-   * @returns Promise containing the saved messages
-   */
-  public saveMessageToMemory(params: SaveMessageToMemoryParams): Promise<SaveMessageToMemoryResponse> {
-    return this.request(`/api/memory/save-messages?agentId=${params.agentId}`, {
-      method: 'POST',
-      body: params,
-    });
-  }
-
-  /**
-   * Gets the status of the memory system
-   * @returns Promise containing memory system status
-   */
-  public getMemoryStatus(agentId: string): Promise<{ result: boolean }> {
-    return this.request(`/api/memory/status?agentId=${agentId}`);
-  }
-
-  /**
-   * Retrieves all available tools
-   * @returns Promise containing map of tool IDs to tool details
-   */
-  public getTools(): Promise<Record<string, GetToolResponse>> {
-    return this.request('/api/tools');
-  }
-
-  /**
-   * Gets a tool instance by ID
-   * @param toolId - ID of the tool to retrieve
-   * @returns Tool instance
-   */
-  public getTool(toolId: string) {
-    return new Tool(this.options, toolId);
-  }
-
-  /**
-   * Retrieves all available workflows
-   * @returns Promise containing map of workflow IDs to workflow details
-   */
-  public getWorkflows(): Promise<Record<string, GetWorkflowResponse>> {
-    return this.request('/api/workflows');
-  }
-
-  /**
-   * Gets a workflow instance by ID
-   * @param workflowId - ID of the workflow to retrieve
-   * @returns Workflow instance
-   */
-  public getWorkflow(workflowId: string) {
-    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
-   * @returns Vector instance
-   */
-  public getVector(vectorName: string) {
-    return new Vector(this.options, vectorName);
-  }
-
-  /**
-   * Retrieves logs
-   * @param params - Parameters for filtering logs
-   * @returns Promise containing array of log messages
-   */
-  public getLogs(params: GetLogsParams): Promise<GetLogsResponse> {
-    return this.request(`/api/logs?transportId=${params.transportId}`);
-  }
-
-  /**
-   * Gets logs for a specific run
-   * @param params - Parameters containing run ID to retrieve
-   * @returns Promise containing array of log messages
-   */
-  public getLogForRun(params: GetLogParams): Promise<GetLogsResponse> {
-    return this.request(`/api/logs/${params.runId}?transportId=${params.transportId}`);
-  }
-
-  /**
-   * List of all log transports
-   * @returns Promise containing list of log transports
-   */
-  public getLogTransports(): Promise<{ transports: string[] }> {
-    return this.request('/api/logs/transports');
-  }
-
-  /**
-   * List of all traces (paged)
-   * @param params - Parameters for filtering traces
-   * @returns Promise containing telemetry data
-   */
-  public getTelemetry(params?: GetTelemetryParams): Promise<GetTelemetryResponse> {
-    const { name, scope, page, perPage, attribute, fromDate, toDate } = params || {};
-    const _attribute = attribute ? Object.entries(attribute).map(([key, value]) => `${key}:${value}`) : [];
-
-    const searchParams = new URLSearchParams();
-    if (name) {
-      searchParams.set('name', name);
-    }
-    if (scope) {
-      searchParams.set('scope', scope);
-    }
-    if (page) {
-      searchParams.set('page', String(page));
-    }
-    if (perPage) {
-      searchParams.set('perPage', String(perPage));
-    }
-    if (_attribute) {
-      if (Array.isArray(_attribute)) {
-        for (const attr of _attribute) {
-          searchParams.append('attribute', attr);
-        }
-      } else {
-        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}`);
-    } else {
-      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);
-  }
-}