@mastra/client-js 0.11.3-alpha.3 → 0.11.3-alpha.4

package/src/resources/memory-thread.ts

@@ -1,99 +0,0 @@
-import type { StorageThreadType } from '@mastra/core/memory';
-
-import type {
-  GetMemoryThreadMessagesResponse,
-  ClientOptions,
-  UpdateMemoryThreadParams,
-  GetMemoryThreadMessagesParams,
-  GetMemoryThreadMessagesPaginatedParams,
-  GetMemoryThreadMessagesPaginatedResponse,
-} from '../types';
-
-import { BaseResource } from './base';
-
-export class MemoryThread extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private threadId: string,
-    private agentId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves the memory thread details
-   * @returns Promise containing thread details including title and metadata
-   */
-  get(): Promise<StorageThreadType> {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`);
-  }
-
-  /**
-   * Updates the memory thread properties
-   * @param params - Update parameters including title and metadata
-   * @returns Promise containing updated thread details
-   */
-  update(params: UpdateMemoryThreadParams): Promise<StorageThreadType> {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`, {
-      method: 'PATCH',
-      body: params,
-    });
-  }
-
-  /**
-   * Deletes the memory thread
-   * @returns Promise containing deletion result
-   */
-  delete(): Promise<{ result: string }> {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`, {
-      method: 'DELETE',
-    });
-  }
-
-  /**
-   * Retrieves messages associated with the thread
-   * @param params - Optional parameters including limit for number of messages to retrieve
-   * @returns Promise containing thread messages and UI messages
-   */
-  getMessages(params?: GetMemoryThreadMessagesParams): Promise<GetMemoryThreadMessagesResponse> {
-    const query = new URLSearchParams({
-      agentId: this.agentId,
-      ...(params?.limit ? { limit: params.limit.toString() } : {}),
-    });
-    return this.request(`/api/memory/threads/${this.threadId}/messages?${query.toString()}`);
-  }
-
-  /**
-   * Retrieves paginated messages associated with the thread with advanced filtering and selection options
-   * @param params - Pagination parameters including selectBy criteria, page, perPage, date ranges, and message inclusion options
-   * @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
-   */
-  getMessagesPaginated({
-    selectBy,
-    ...rest
-  }: GetMemoryThreadMessagesPaginatedParams): Promise<GetMemoryThreadMessagesPaginatedResponse> {
-    const query = new URLSearchParams({
-      ...rest,
-      ...(selectBy ? { selectBy: JSON.stringify(selectBy) } : {}),
-    });
-    return this.request(`/api/memory/threads/${this.threadId}/messages/paginated?${query.toString()}`);
-  }
-
-  /**
-   * Deletes one or more messages from the thread
-   * @param messageIds - Can be a single message ID (string), array of message IDs,
-   *                     message object with id property, or array of message objects
-   * @returns Promise containing deletion result
-   */
-  deleteMessages(
-    messageIds: string | string[] | { id: string } | { id: string }[],
-  ): Promise<{ success: boolean; message: string }> {
-    const query = new URLSearchParams({
-      agentId: this.agentId,
-    });
-    return this.request(`/api/memory/messages/delete?${query.toString()}`, {
-      method: 'POST',
-      body: { messageIds },
-    });
-  }
-}

package/src/resources/network-memory-thread.test.ts

@@ -1,269 +0,0 @@
-import { describe, expect, beforeEach, it, vi } from 'vitest';
-import type { ClientOptions } from '../types';
-import { NetworkMemoryThread } from './network-memory-thread';
-
-// Mock fetch globally
-global.fetch = vi.fn();
-
-describe('NetworkMemoryThread', () => {
-  let thread: NetworkMemoryThread;
-  const clientOptions: ClientOptions = {
-    baseUrl: 'http://localhost:4111',
-    headers: {
-      Authorization: 'Bearer test-key',
-    },
-  };
-  const threadId = 'test-thread-id';
-  const networkId = 'test-network-id';
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    thread = new NetworkMemoryThread(clientOptions, threadId, networkId);
-  });
-
-  const mockFetchResponse = (data: any) => {
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: async () => data,
-      headers: new Headers({
-        'content-type': 'application/json',
-      }),
-    });
-  };
-
-  describe('get', () => {
-    it('should retrieve thread details', async () => {
-      const mockThread = {
-        id: threadId,
-        title: 'Test Thread',
-        metadata: { test: true },
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-      };
-
-      mockFetchResponse(mockThread);
-
-      const result = await thread.get();
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        }),
-      );
-      expect(result).toEqual(mockThread);
-    });
-  });
-
-  describe('update', () => {
-    it('should update thread properties', async () => {
-      const updateParams = {
-        title: 'Updated Title',
-        metadata: { updated: true },
-        resourceid: 'resource-1',
-      };
-
-      const mockUpdatedThread = {
-        id: threadId,
-        ...updateParams,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-      };
-
-      mockFetchResponse(mockUpdatedThread);
-
-      const result = await thread.update(updateParams);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
-        expect.objectContaining({
-          method: 'PATCH',
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify(updateParams),
-        }),
-      );
-      expect(result).toEqual(mockUpdatedThread);
-    });
-  });
-
-  describe('delete', () => {
-    it('should delete the thread', async () => {
-      const mockResponse = { result: 'Thread deleted' };
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.delete();
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
-        expect.objectContaining({
-          method: 'DELETE',
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-  });
-
-  describe('getMessages', () => {
-    it('should retrieve thread messages', async () => {
-      const mockMessages = {
-        messages: [
-          { id: 'msg-1', content: 'Hello', role: 'user' },
-          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
-        ],
-        uiMessages: [
-          { id: 'msg-1', content: 'Hello', role: 'user' },
-          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
-        ],
-      };
-
-      mockFetchResponse(mockMessages);
-
-      const result = await thread.getMessages();
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/threads/${threadId}/messages?networkId=${networkId}`,
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        }),
-      );
-      expect(result).toEqual(mockMessages);
-    });
-
-    it('should retrieve thread messages with limit', async () => {
-      const mockMessages = {
-        messages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
-        uiMessages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
-      };
-
-      mockFetchResponse(mockMessages);
-
-      const result = await thread.getMessages({ limit: 5 });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/threads/${threadId}/messages?networkId=${networkId}&limit=5`,
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        }),
-      );
-      expect(result).toEqual(mockMessages);
-    });
-  });
-
-  describe('deleteMessages', () => {
-    it('should delete a single message by string ID', async () => {
-      const messageId = 'test-message-id';
-      const mockResponse = { success: true, message: '1 message deleted successfully' };
-
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.deleteMessages(messageId);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'content-type': 'application/json',
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify({ messageIds: messageId }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should delete multiple messages by array of string IDs', async () => {
-      const messageIds = ['msg-1', 'msg-2', 'msg-3'];
-      const mockResponse = { success: true, message: '3 messages deleted successfully' };
-
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.deleteMessages(messageIds);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'content-type': 'application/json',
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify({ messageIds }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should delete a message by object with id property', async () => {
-      const messageObj = { id: 'test-message-id' };
-      const mockResponse = { success: true, message: '1 message deleted successfully' };
-
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.deleteMessages(messageObj);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'content-type': 'application/json',
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify({ messageIds: messageObj }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should delete messages by array of objects', async () => {
-      const messageObjs = [{ id: 'msg-1' }, { id: 'msg-2' }];
-      const mockResponse = { success: true, message: '2 messages deleted successfully' };
-
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.deleteMessages(messageObjs);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'content-type': 'application/json',
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify({ messageIds: messageObjs }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should handle delete messages errors', async () => {
-      const messageId = 'non-existent-id';
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: false,
-        status: 404,
-        statusText: 'Not Found',
-        json: async () => ({ error: 'Message not found' }),
-        headers: new Headers({
-          'content-type': 'application/json',
-        }),
-      });
-
-      await expect(thread.deleteMessages(messageId)).rejects.toThrow();
-    });
-  });
-});

package/src/resources/network-memory-thread.ts

@@ -1,81 +0,0 @@
-import type { StorageThreadType } from '@mastra/core/memory';
-
-import type {
-  GetMemoryThreadMessagesResponse,
-  ClientOptions,
-  UpdateMemoryThreadParams,
-  GetMemoryThreadMessagesParams,
-} from '../types';
-
-import { BaseResource } from './base';
-
-export class NetworkMemoryThread extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private threadId: string,
-    private networkId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves the memory thread details
-   * @returns Promise containing thread details including title and metadata
-   */
-  get(): Promise<StorageThreadType> {
-    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`);
-  }
-
-  /**
-   * Updates the memory thread properties
-   * @param params - Update parameters including title and metadata
-   * @returns Promise containing updated thread details
-   */
-  update(params: UpdateMemoryThreadParams): Promise<StorageThreadType> {
-    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`, {
-      method: 'PATCH',
-      body: params,
-    });
-  }
-
-  /**
-   * Deletes the memory thread
-   * @returns Promise containing deletion result
-   */
-  delete(): Promise<{ result: string }> {
-    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`, {
-      method: 'DELETE',
-    });
-  }
-
-  /**
-   * Retrieves messages associated with the thread
-   * @param params - Optional parameters including limit for number of messages to retrieve
-   * @returns Promise containing thread messages and UI messages
-   */
-  getMessages(params?: GetMemoryThreadMessagesParams): Promise<GetMemoryThreadMessagesResponse> {
-    const query = new URLSearchParams({
-      networkId: this.networkId,
-      ...(params?.limit ? { limit: params.limit.toString() } : {}),
-    });
-    return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
-  }
-
-  /**
-   * Deletes one or more messages from the thread
-   * @param messageIds - Can be a single message ID (string), array of message IDs,
-   *                     message object with id property, or array of message objects
-   * @returns Promise containing deletion result
-   */
-  deleteMessages(
-    messageIds: string | string[] | { id: string } | { id: string }[],
-  ): Promise<{ success: boolean; message: string }> {
-    const query = new URLSearchParams({
-      networkId: this.networkId,
-    });
-    return this.request(`/api/memory/network/messages/delete?${query.toString()}`, {
-      method: 'POST',
-      body: { messageIds },
-    });
-  }
-}

package/src/resources/network.ts

@@ -1,86 +0,0 @@
-import { processDataStream } from '@ai-sdk/ui-utils';
-import type { GenerateReturn } from '@mastra/core/llm';
-import type { JSONSchema7 } from 'json-schema';
-import type { ZodSchema } from 'zod';
-import type { GenerateParams, ClientOptions, StreamParams, GetNetworkResponse } from '../types';
-import { zodToJsonSchema } from '../utils/zod-to-json-schema';
-
-import { BaseResource } from './base';
-
-export class Network extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private networkId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves details about the network
-   * @returns Promise containing network details
-   */
-  details(): Promise<GetNetworkResponse> {
-    return this.request(`/api/networks/${this.networkId}`);
-  }
-
-  /**
-   * Generates a response from the agent
-   * @param params - Generation parameters including prompt
-   * @returns Promise containing the generated response
-   */
-  generate<
-    Output extends JSONSchema7 | ZodSchema | undefined = undefined,
-    StructuredOutput extends JSONSchema7 | ZodSchema | undefined = undefined,
-  >(params: GenerateParams<Output>): Promise<GenerateReturn<any, Output, StructuredOutput>> {
-    const processedParams = {
-      ...params,
-      output: zodToJsonSchema(params.output),
-      experimental_output: zodToJsonSchema(params.experimental_output),
-    };
-
-    return this.request(`/api/networks/${this.networkId}/generate`, {
-      method: 'POST',
-      body: processedParams,
-    });
-  }
-
-  /**
-   * Streams a response from the agent
-   * @param params - Stream parameters including prompt
-   * @returns Promise containing the enhanced Response object with processDataStream method
-   */
-  async stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: StreamParams<T>,
-  ): Promise<
-    Response & {
-      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
-    }
-  > {
-    const processedParams = {
-      ...params,
-      output: zodToJsonSchema(params.output),
-      experimental_output: zodToJsonSchema(params.experimental_output),
-    };
-
-    const response: Response & {
-      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
-    } = await this.request(`/api/networks/${this.networkId}/stream`, {
-      method: 'POST',
-      body: processedParams,
-      stream: true,
-    });
-
-    if (!response.body) {
-      throw new Error('No response body');
-    }
-
-    response.processDataStream = async (options = {}) => {
-      await processDataStream({
-        stream: response.body as ReadableStream<Uint8Array>,
-        ...options,
-      });
-    };
-
-    return response;
-  }
-}

package/src/resources/observability.ts

@@ -1,53 +0,0 @@
-import type { AITraceRecord, AITracesPaginatedArg } from '@mastra/core/storage';
-import type { ClientOptions, GetAITracesResponse } from '../types';
-import { BaseResource } from './base';
-
-export class Observability extends BaseResource {
-  constructor(options: ClientOptions) {
-    super(options);
-  }
-
-  /**
-   * Retrieves a specific AI trace by ID
-   * @param traceId - ID of the trace to retrieve
-   * @returns Promise containing the AI trace with all its spans
-   */
-  getTrace(traceId: string): Promise<AITraceRecord> {
-    return this.request(`/api/observability/traces/${traceId}`);
-  }
-
-  /**
-   * Retrieves paginated list of AI traces with optional filtering
-   * @param params - Parameters for pagination and filtering
-   * @returns Promise containing paginated traces and pagination info
-   */
-  getTraces(params: AITracesPaginatedArg): Promise<GetAITracesResponse> {
-    const { pagination, filters } = params;
-    const { page, perPage, dateRange } = pagination || {};
-    const { name, spanType } = filters || {};
-    const searchParams = new URLSearchParams();
-
-    if (page !== undefined) {
-      searchParams.set('page', String(page));
-    }
-    if (perPage !== undefined) {
-      searchParams.set('perPage', String(perPage));
-    }
-    if (name) {
-      searchParams.set('name', name);
-    }
-    if (spanType !== undefined) {
-      searchParams.set('spanType', String(spanType));
-    }
-    if (dateRange) {
-      const dateRangeStr = JSON.stringify({
-        start: dateRange.start instanceof Date ? dateRange.start.toISOString() : dateRange.start,
-        end: dateRange.end instanceof Date ? dateRange.end.toISOString() : dateRange.end,
-      });
-      searchParams.set('dateRange', dateRangeStr);
-    }
-
-    const queryString = searchParams.toString();
-    return this.request(`/api/observability/traces${queryString ? `?${queryString}` : ''}`);
-  }
-}

package/src/resources/tool.ts

@@ -1,45 +0,0 @@
-import type { RuntimeContext } from '@mastra/core/runtime-context';
-import type { GetToolResponse, ClientOptions } from '../types';
-
-import { parseClientRuntimeContext } from '../utils';
-import { BaseResource } from './base';
-
-export class Tool extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private toolId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves details about the tool
-   * @returns Promise containing tool details including description and schemas
-   */
-  details(): Promise<GetToolResponse> {
-    return this.request(`/api/tools/${this.toolId}`);
-  }
-
-  /**
-   * Executes the tool with the provided parameters
-   * @param params - Parameters required for tool execution
-   * @returns Promise containing the tool execution results
-   */
-  execute(params: { data: any; runId?: string; runtimeContext?: RuntimeContext | Record<string, any> }): Promise<any> {
-    const url = new URLSearchParams();
-
-    if (params.runId) {
-      url.set('runId', params.runId);
-    }
-
-    const body = {
-      data: params.data,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
-    };
-
-    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
-      method: 'POST',
-      body,
-    });
-  }
-}