@mastra/client-js 0.0.0-remove-tiktoken-20250415231938 → 0.0.0-remove-unused-import-20250909212718

package/src/resources/agent.ts

@@ -1,205 +0,0 @@
-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,
-  GetAgentResponse,
-  GetEvalsByAgentIdResponse,
-  GetToolResponse,
-  ClientOptions,
-  StreamParams,
-} from '../types';
-
-import { BaseResource } from './base';
-
-export class AgentTool extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private agentId: string,
-    private toolId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Executes a specific tool for an agent
-   * @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',
-      body: params,
-    });
-  }
-}
-
-export class AgentVoice extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private agentId: string,
-  ) {
-    super(options);
-    this.agentId = agentId;
-  }
-
-  /**
-   * Convert text to speech using the agent's voice provider
-   * @param text - Text to convert to speech
-   * @param options - Optional provider-specific options for speech generation
-   * @returns Promise containing the audio data
-   */
-  async speak(text: string, options?: { speaker?: string; [key: string]: any }): Promise<Response> {
-    return this.request<Response>(`/api/agents/${this.agentId}/voice/speak`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: { input: text, options },
-      stream: true,
-    });
-  }
-
-  /**
-   * Convert speech to text using the agent's voice provider
-   * @param audio - Audio data to transcribe
-   * @param options - Optional provider-specific options
-   * @returns Promise containing the transcribed text
-   */
-  listen(audio: Blob, options?: Record<string, any>): Promise<Response> {
-    const formData = new FormData();
-    formData.append('audio', audio);
-
-    if (options) {
-      formData.append('options', JSON.stringify(options));
-    }
-
-    return this.request(`/api/agents/${this.agentId}/voice/listen`, {
-      method: 'POST',
-      body: formData,
-    });
-  }
-
-  /**
-   * Get available speakers for the agent's voice provider
-   * @returns Promise containing list of available speakers
-   */
-  getSpeakers(): Promise<Array<{ voiceId: string; [key: string]: any }>> {
-    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
-  }
-}
-
-export class Agent extends BaseResource {
-  public readonly voice: AgentVoice;
-
-  constructor(
-    options: ClientOptions,
-    private agentId: string,
-  ) {
-    super(options);
-    this.voice = new AgentVoice(options, this.agentId);
-  }
-
-  /**
-   * Retrieves details about the agent
-   * @returns Promise containing agent details including model and instructions
-   */
-  details(): Promise<GetAgentResponse> {
-    return this.request(`/api/agents/${this.agentId}`);
-  }
-
-  /**
-   * Generates a response from the agent
-   * @param params - Generation parameters including prompt
-   * @returns Promise containing the generated response
-   */
-  generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T>,
-  ): Promise<GenerateReturn<T>> {
-    const processedParams = {
-      ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output:
-        params.experimental_output instanceof ZodSchema
-          ? zodToJsonSchema(params.experimental_output)
-          : params.experimental_output,
-    };
-
-    return this.request(`/api/agents/${this.agentId}/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: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output:
-        params.experimental_output instanceof ZodSchema
-          ? zodToJsonSchema(params.experimental_output)
-          : params.experimental_output,
-    };
-
-    const response: Response & {
-      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
-    } = await this.request(`/api/agents/${this.agentId}/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;
-  }
-
-  /**
-   * Gets details about a specific tool available to the agent
-   * @param toolId - ID of the tool to retrieve
-   * @returns Promise containing tool details
-   */
-  getTool(toolId: string): Promise<GetToolResponse> {
-    return this.request(`/api/agents/${this.agentId}/tools/${toolId}`);
-  }
-
-  /**
-   * Retrieves evaluation results for the agent
-   * @returns Promise containing agent evaluations
-   */
-  evals(): Promise<GetEvalsByAgentIdResponse> {
-    return this.request(`/api/agents/${this.agentId}/evals/ci`);
-  }
-
-  /**
-   * Retrieves live evaluation results for the agent
-   * @returns Promise containing live agent evaluations
-   */
-  liveEvals(): Promise<GetEvalsByAgentIdResponse> {
-    return this.request(`/api/agents/${this.agentId}/evals/live`);
-  }
-}

package/src/resources/base.ts

@@ -1,70 +0,0 @@
-import type { RequestFunction, RequestOptions, ClientOptions } from '../types';
-
-export class BaseResource {
-  readonly options: ClientOptions;
-
-  constructor(options: ClientOptions) {
-    this.options = options;
-  }
-
-  /**
-   * Makes an HTTP request to the API with retries and exponential backoff
-   * @param path - The API endpoint path
-   * @param options - Optional request configuration
-   * @returns Promise containing the response data
-   */
-  public async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
-    let lastError: Error | null = null;
-    const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1000, headers = {} } = this.options;
-
-    let delay = backoffMs;
-
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      try {
-        const response = await fetch(`${baseUrl}${path}`, {
-          ...options,
-          headers: {
-            ...headers,
-            ...options.headers,
-            // TODO: Bring this back once we figure out what we/users need to do to make this work with cross-origin requests
-            // 'x-mastra-client-type': 'js',
-          },
-          body:
-            options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : undefined,
-        });
-
-        if (!response.ok) {
-          const errorBody = await response.text();
-          let errorMessage = `HTTP error! status: ${response.status}`;
-          try {
-            const errorJson = JSON.parse(errorBody);
-            errorMessage += ` - ${JSON.stringify(errorJson)}`;
-          } catch {
-            if (errorBody) {
-              errorMessage += ` - ${errorBody}`;
-            }
-          }
-          throw new Error(errorMessage);
-        }
-
-        if (options.stream) {
-          return response as unknown as T;
-        }
-
-        const data = await response.json();
-        return data as T;
-      } catch (error) {
-        lastError = error as Error;
-
-        if (attempt === retries) {
-          break;
-        }
-
-        await new Promise(resolve => setTimeout(resolve, delay));
-        delay = Math.min(delay * 2, maxBackoffMs);
-      }
-    }
-
-    throw lastError || new Error('Request failed');
-  }
-}

package/src/resources/index.ts

@@ -1,7 +0,0 @@
-export * from './agent';
-export * from './network';
-export * from './memory-thread';
-export * from './vector';
-export * from './workflow';
-export * from './tool';
-export * from './base';

package/src/resources/memory-thread.ts

@@ -1,60 +0,0 @@
-import type { StorageThreadType } from '@mastra/core';
-
-import type {
-  CreateMemoryThreadParams,
-  GetMemoryThreadMessagesResponse,
-  GetMemoryThreadResponse,
-  ClientOptions,
-  SaveMessageToMemoryParams,
-  UpdateMemoryThreadParams,
-} 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
-   * @returns Promise containing thread messages and UI messages
-   */
-  getMessages(): Promise<GetMemoryThreadMessagesResponse> {
-    return this.request(`/api/memory/threads/${this.threadId}/messages?agentId=${this.agentId}`);
-  }
-}

package/src/resources/network.ts

@@ -1,92 +0,0 @@
-import type { GenerateReturn } from '@mastra/core';
-import type { JSONSchema7 } from 'json-schema';
-import { ZodSchema } from 'zod';
-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(
-    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<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T>,
-  ): Promise<GenerateReturn<T>> {
-    const processedParams = {
-      ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output:
-        params.experimental_output instanceof ZodSchema
-          ? zodToJsonSchema(params.experimental_output)
-          : 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: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output:
-        params.experimental_output instanceof ZodSchema
-          ? zodToJsonSchema(params.experimental_output)
-          : 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/tool.ts

@@ -1,32 +0,0 @@
-import type { GetToolResponse, ClientOptions } from '../types';
-
-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 }): Promise<any> {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
-      method: 'POST',
-      body: params,
-    });
-  }
-}

package/src/resources/vector.ts

@@ -1,83 +0,0 @@
-import type {
-  CreateIndexParams,
-  GetVectorIndexResponse,
-  QueryVectorParams,
-  QueryVectorResponse,
-  ClientOptions,
-  UpsertVectorParams,
-} from '../types';
-
-import { BaseResource } from './base';
-
-export class Vector extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private vectorName: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves details about a specific vector index
-   * @param indexName - Name of the index to get details for
-   * @returns Promise containing vector index details
-   */
-  details(indexName: string): Promise<GetVectorIndexResponse> {
-    return this.request(`/api/vector/${this.vectorName}/indexes/${indexName}`);
-  }
-
-  /**
-   * Deletes a vector index
-   * @param indexName - Name of the index to delete
-   * @returns Promise indicating deletion success
-   */
-  delete(indexName: string): Promise<{ success: boolean }> {
-    return this.request(`/api/vector/${this.vectorName}/indexes/${indexName}`, {
-      method: 'DELETE',
-    });
-  }
-
-  /**
-   * Retrieves a list of all available indexes
-   * @returns Promise containing array of index names
-   */
-  getIndexes(): Promise<{ indexes: string[] }> {
-    return this.request(`/api/vector/${this.vectorName}/indexes`);
-  }
-
-  /**
-   * Creates a new vector index
-   * @param params - Parameters for index creation including dimension and metric
-   * @returns Promise indicating creation success
-   */
-  createIndex(params: CreateIndexParams): Promise<{ success: boolean }> {
-    return this.request(`/api/vector/${this.vectorName}/create-index`, {
-      method: 'POST',
-      body: params,
-    });
-  }
-
-  /**
-   * Upserts vectors into an index
-   * @param params - Parameters containing vectors, metadata, and optional IDs
-   * @returns Promise containing array of vector IDs
-   */
-  upsert(params: UpsertVectorParams): Promise<string[]> {
-    return this.request(`/api/vector/${this.vectorName}/upsert`, {
-      method: 'POST',
-      body: params,
-    });
-  }
-
-  /**
-   * Queries vectors in an index
-   * @param params - Query parameters including query vector and search options
-   * @returns Promise containing query results
-   */
-  query(params: QueryVectorParams): Promise<QueryVectorResponse> {
-    return this.request(`/api/vector/${this.vectorName}/query`, {
-      method: 'POST',
-      body: params,
-    });
-  }
-}