@mastra/client-js 0.1.0-alpha.8 → 0.1.0

package/src/index.ts

@@ -1,2 +1,2 @@
 export * from './client';
-export * from './types';
+export * from './types';

package/src/resources/agent.ts

@@ -1,115 +1,116 @@
-import type {
-    GenerateParams,
-    GetAgentResponse,
-    GetEvalsByAgentIdResponse,
-    GetToolResponse,
-    ClientOptions,
-    StreamParams,
-} from '../types';
-import type {
-    GenerateReturn,
-    StreamReturn,
-} from '@mastra/core';
+import type { GenerateReturn, StreamReturn } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
-import { ZodSchema } from "zod";
+import { ZodSchema } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
+
+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);
-    }
+  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
-     */
-    execute(params: Record<string, any>): Promise<Record<string, any>> {
-        return this.request(`/api/agents/${this.agentId}/tools/${this.toolId}/execute`, {
-            method: 'POST',
-            body: params,
-        });
-    }
+  /**
+   * Executes a specific tool for an agent
+   * @param params - Parameters required for tool execution
+   * @returns Promise containing tool execution results
+   */
+  execute(params: { data: any }): Promise<any> {
+    return this.request(`/api/agents/${this.agentId}/tools/${this.toolId}/execute`, {
+      method: 'POST',
+      body: params,
+    });
+  }
 }
 
 export class Agent extends BaseResource {
-    constructor(
-        options: ClientOptions,
-        private agentId: string
-    ) {
-        super(options);
-    }
+  constructor(
+    options: ClientOptions,
+    private agentId: string,
+  ) {
+    super(options);
+  }
 
-    /**
-     * Retrieves details about the agent
-     * @returns Promise containing agent details including model and instructions
-     */
-    details(): Promise<GetAgentResponse> {
-        return this.request(`/api/agents/${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
-        };
+  /**
+   * 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,
+    };
 
-        return this.request(`/api/agents/${this.agentId}/generate`, {
-            method: 'POST',
-            body: processedParams,
-        });
-    }
+    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 streamed response
-     */
-    stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response> {
-        const processedParams = {
-            ...params,
-            output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-        };
+  /**
+   * Streams a response from the agent
+   * @param params - Stream parameters including prompt
+   * @returns Promise containing the streamed response
+   */
+  stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response> {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+    };
 
-        return this.request(`/api/agents/${this.agentId}/stream`, {
-            method: 'POST',
-            body: processedParams,
-            stream: true
-        })
-    }
+    return this.request(`/api/agents/${this.agentId}/stream`, {
+      method: 'POST',
+      body: processedParams,
+      stream: true,
+    });
+  }
 
-    /**
-     * 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}`);
-    }
+  /**
+   * 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`);
-    }
+  /**
+   * 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`);
-    }
-} 
+  /**
+   * 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,68 +1,68 @@
 import type { RequestFunction, RequestOptions, ClientOptions } from '../types';
 
 export class BaseResource {
-    readonly options: ClientOptions
+  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;
+  constructor(options: ClientOptions) {
+    this.options = options;
+  }
 
-        let delay = backoffMs;
+  /**
+   * 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;
 
-        for (let attempt = 0; attempt <= retries; attempt++) {
-            try {
-                const response = await fetch(`${baseUrl}${path}`, {
-                    ...options,
-                    headers: {
-                        'Content-Type': 'application/json',
-                        ...headers,
-                        ...options.headers,
-                    },
-                    body: options.body ? JSON.stringify(options.body) : undefined,
-                });
+    let delay = backoffMs;
 
-                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);
-                }
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const response = await fetch(`${baseUrl}${path}`, {
+          ...options,
+          headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+            ...options.headers,
+          },
+          body: options.body ? JSON.stringify(options.body) : undefined,
+        });
 
-                if (options.stream) {
-                    return response as unknown as T;
-                }
+        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);
+        }
 
-                const data = await response.json();
-                return data as T;
-            } catch (error) {
-                lastError = error as Error;
+        if (options.stream) {
+          return response as unknown as T;
+        }
 
-                if (attempt === retries) {
-                    break;
-                }
+        const data = await response.json();
+        return data as T;
+      } catch (error) {
+        lastError = error as Error;
 
-                await new Promise(resolve => setTimeout(resolve, delay));
-                delay = Math.min(delay * 2, maxBackoffMs);
-            }
+        if (attempt === retries) {
+          break;
         }
 
-        throw lastError || new Error('Request failed');
+        await new Promise(resolve => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, maxBackoffMs);
+      }
     }
-} 
+
+    throw lastError || new Error('Request failed');
+  }
+}

package/src/resources/index.ts

@@ -3,4 +3,4 @@ export * from './memory-thread';
 export * from './vector';
 export * from './workflow';
 export * from './tool';
-export * from './base';
+export * from './base';

package/src/resources/memory-thread.ts

@@ -1,57 +1,60 @@
 import type { StorageThreadType } from '@mastra/core';
+
 import type {
-    CreateMemoryThreadParams,
-    GetMemoryThreadMessagesResponse,
-    GetMemoryThreadResponse,
-    ClientOptions,
-    SaveMessageToMemoryParams,
-    UpdateMemoryThreadParams,
+  CreateMemoryThreadParams,
+  GetMemoryThreadMessagesResponse,
+  GetMemoryThreadResponse,
+  ClientOptions,
+  SaveMessageToMemoryParams,
+  UpdateMemoryThreadParams,
 } from '../types';
+
 import { BaseResource } from './base';
 
 export class MemoryThread extends BaseResource {
-    constructor(
-        options: ClientOptions,
-        private threadId: string
-    ) {
-        super(options);
-    }
+  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}`);
-    }
+  /**
+   * 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}`, {
-            method: 'PATCH',
-            body: params,
-        });
-    }
+  /**
+   * 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}`, {
-            method: 'DELETE',
-        });
-    }
+  /**
+   * 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`);
-    }
-} 
+  /**
+   * 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/tool.ts

@@ -1,31 +1,32 @@
 import type { GetToolResponse, ClientOptions } from '../types';
+
 import { BaseResource } from './base';
 
 export class Tool extends BaseResource {
-    constructor(
-        options: ClientOptions,
-        private toolId: string
-    ) {
-        super(options);
-    }
+  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}`);
-    }
+  /**
+   * 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: Record<string, any>): Promise<Record<string, any>> {
-        return this.request(`/api/tools/${this.toolId}/execute`, {
-            method: 'POST',
-            body: params,
-        });
-    }
+  /**
+   * 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,
+    });
+  }
 }