@mastra/client-js 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/index.ts

@@ -1,194 +1,2 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-import { type Agent } from './_shims/index';
-import * as Core from './core';
-import * as Errors from './error';
-import * as Uploads from './uploads';
-import * as API from './resources/index';
-import { Logs } from './resources/logs';
-import { SyncExecuteParams, Syncs } from './resources/syncs';
-import { System } from './resources/system';
-import { WorkflowExecuteParams, Workflows } from './resources/workflows';
-import { AgentGenerateParams, AgentStreamParams, Agents } from './resources/agents/agents';
-import { Memory, MemorySaveMessagesParams } from './resources/memory/memory';
-import { ToolExecuteParams, Tools } from './resources/tools/tools';
-
-export interface ClientOptions {
-  /**
-   * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
-   *
-   * Defaults to process.env['MASTRA_CLIENT_BASE_URL'].
-   */
-  baseURL?: string | null | undefined;
-
-  /**
-   * The maximum amount of time (in milliseconds) that the client should wait for a response
-   * from the server before timing out a single request.
-   *
-   * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
-   * much longer than this timeout before the promise succeeds or fails.
-   */
-  timeout?: number | undefined;
-
-  /**
-   * An HTTP agent used to manage HTTP(S) connections.
-   *
-   * If not provided, an agent will be constructed by default in the Node.js environment,
-   * otherwise no agent is used.
-   */
-  httpAgent?: Agent | undefined;
-
-  /**
-   * Specify a custom `fetch` function implementation.
-   *
-   * If not provided, we use `node-fetch` on Node.js and otherwise expect that `fetch` is
-   * defined globally.
-   */
-  fetch?: Core.Fetch | undefined;
-
-  /**
-   * The maximum number of times that the client will retry a request in case of a
-   * temporary failure, like a network error or a 5XX error from the server.
-   *
-   * @default 2
-   */
-  maxRetries?: number | undefined;
-
-  /**
-   * Default headers to include with every request to the API.
-   *
-   * These can be removed in individual requests by explicitly setting the
-   * header to `undefined` or `null` in request options.
-   */
-  defaultHeaders?: Core.Headers | undefined;
-
-  /**
-   * Default query parameters to include with every request to the API.
-   *
-   * These can be removed in individual requests by explicitly setting the
-   * param to `undefined` in request options.
-   */
-  defaultQuery?: Core.DefaultQuery | undefined;
-}
-
-/**
- * API Client for interfacing with the Mastra Client API.
- */
-export class MastraClient extends Core.APIClient {
-  private _options: ClientOptions;
-
-  /**
-   * API Client for interfacing with the Mastra Client API.
-   *
-   * @param {string} [opts.baseURL=process.env['MASTRA_CLIENT_BASE_URL'] ?? http://localhost:4111] - Override the default base URL for the API.
-   * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
-   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
-   * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
-   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
-   * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
-   * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
-   */
-  constructor({ baseURL = Core.readEnv('MASTRA_CLIENT_BASE_URL'), ...opts }: ClientOptions = {}) {
-    const options: ClientOptions = {
-      ...opts,
-      baseURL: baseURL || `http://localhost:4111`,
-    };
-
-    super({
-      baseURL: options.baseURL!,
-      timeout: options.timeout ?? 60000 /* 1 minute */,
-      httpAgent: options.httpAgent,
-      maxRetries: options.maxRetries,
-      fetch: options.fetch,
-    });
-
-    this._options = options;
-  }
-
-  system: API.System = new API.System(this);
-  agents: API.Agents = new API.Agents(this);
-  memory: API.Memory = new API.Memory(this);
-  workflows: API.Workflows = new API.Workflows(this);
-  syncs: API.Syncs = new API.Syncs(this);
-  logs: API.Logs = new API.Logs(this);
-  tools: API.Tools = new API.Tools(this);
-
-  protected override defaultQuery(): Core.DefaultQuery | undefined {
-    return this._options.defaultQuery;
-  }
-
-  protected override defaultHeaders(opts: Core.FinalRequestOptions): Core.Headers {
-    return {
-      ...super.defaultHeaders(opts),
-      ...this._options.defaultHeaders,
-    };
-  }
-
-  static MastraClient = this;
-  static DEFAULT_TIMEOUT = 60000; // 1 minute
-
-  static MastraClientError = Errors.MastraClientError;
-  static APIError = Errors.APIError;
-  static APIConnectionError = Errors.APIConnectionError;
-  static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
-  static APIUserAbortError = Errors.APIUserAbortError;
-  static NotFoundError = Errors.NotFoundError;
-  static ConflictError = Errors.ConflictError;
-  static RateLimitError = Errors.RateLimitError;
-  static BadRequestError = Errors.BadRequestError;
-  static AuthenticationError = Errors.AuthenticationError;
-  static InternalServerError = Errors.InternalServerError;
-  static PermissionDeniedError = Errors.PermissionDeniedError;
-  static UnprocessableEntityError = Errors.UnprocessableEntityError;
-
-  static toFile = Uploads.toFile;
-  static fileFromPath = Uploads.fileFromPath;
-}
-
-MastraClient.System = System;
-MastraClient.Agents = Agents;
-MastraClient.Memory = Memory;
-MastraClient.Workflows = Workflows;
-MastraClient.Syncs = Syncs;
-MastraClient.Logs = Logs;
-MastraClient.Tools = Tools;
-export declare namespace MastraClient {
-  export type RequestOptions = Core.RequestOptions;
-
-  export { System as System };
-
-  export {
-    Agents as Agents,
-    type AgentGenerateParams as AgentGenerateParams,
-    type AgentStreamParams as AgentStreamParams,
-  };
-
-  export { Memory as Memory, type MemorySaveMessagesParams as MemorySaveMessagesParams };
-
-  export { Workflows as Workflows, type WorkflowExecuteParams as WorkflowExecuteParams };
-
-  export { Syncs as Syncs, type SyncExecuteParams as SyncExecuteParams };
-
-  export { Logs as Logs };
-
-  export { Tools as Tools, type ToolExecuteParams as ToolExecuteParams };
-}
-
-export { toFile, fileFromPath } from './uploads';
-export {
-  MastraClientError,
-  APIError,
-  APIConnectionError,
-  APIConnectionTimeoutError,
-  APIUserAbortError,
-  NotFoundError,
-  ConflictError,
-  RateLimitError,
-  BadRequestError,
-  AuthenticationError,
-  InternalServerError,
-  PermissionDeniedError,
-  UnprocessableEntityError,
-} from './error';
-
-export default MastraClient;
+export * from './client';
+export * from './types';

package/src/resources/agent.ts

@@ -0,0 +1,115 @@
+import type {
+    GenerateParams,
+    GetAgentResponse,
+    GetEvalsByAgentIdResponse,
+    GetToolResponse,
+    ClientOptions,
+    StreamParams,
+} from '../types';
+import type {
+    GenerateReturn,
+    StreamReturn,
+} from '@mastra/core';
+import type { JSONSchema7 } from 'json-schema';
+import { ZodSchema } from "zod";
+import { zodToJsonSchema } from 'zod-to-json-schema';
+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
+     */
+    execute(params: Record<string, any>): Promise<Record<string, 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);
+    }
+
+    /**
+     * 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
+        };
+
+        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,
+        };
+
+        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}`);
+    }
+
+    /**
+     * Retrieves evaluation results for the agent
+     * @returns Promise containing agent evaluations
+     */
+    evals(): Promise<GetEvalsByAgentIdResponse> {
+        return this.request(`/api/agents/${this.agentId}/evals`);
+    }
+
+    /**
+     * 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

@@ -0,0 +1,68 @@
+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: {
+                        'Content-Type': 'application/json',
+                        ...headers,
+                        ...options.headers,
+                    },
+                    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,9 +1,6 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-export { Agents, type AgentGenerateParams, type AgentStreamParams } from './agents/agents';
-export { Logs } from './logs';
-export { Memory, type MemorySaveMessagesParams } from './memory/memory';
-export { Syncs, type SyncExecuteParams } from './syncs';
-export { System } from './system';
-export { Tools, type ToolExecuteParams } from './tools/tools';
-export { Workflows, type WorkflowExecuteParams } from './workflows';
+export * from './agent';
+export * from './memory-thread';
+export * from './vector';
+export * from './workflow';
+export * from './tool';
+export * from './base';

package/src/resources/memory-thread.ts

@@ -0,0 +1,57 @@
+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
+    ) {
+        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}`);
+    }
+
+    /**
+     * 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,
+        });
+    }
+
+    /**
+     * Deletes the memory thread
+     * @returns Promise containing deletion result
+     */
+    delete(): Promise<{ result: string }> {
+        return this.request(`/api/memory/threads/${this.threadId}`, {
+            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`);
+    }
+} 

package/src/resources/tool.ts

@@ -0,0 +1,31 @@
+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: Record<string, any>): Promise<Record<string, any>> {
+        return this.request(`/api/tools/${this.toolId}/execute`, {
+            method: 'POST',
+            body: params,
+        });
+    }
+}

package/src/resources/vector.ts

@@ -0,0 +1,82 @@
+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
+        });
+    }
+} 

package/src/resources/workflow.ts

@@ -0,0 +1,31 @@
+import type { GetWorkflowResponse, ClientOptions } from '../types';
+import { BaseResource } from './base';
+
+export class Workflow extends BaseResource {
+    constructor(
+        options: ClientOptions,
+        private workflowId: string
+    ) {
+        super(options);
+    }
+
+    /**
+     * Retrieves details about the workflow
+     * @returns Promise containing workflow details including steps and graphs
+     */
+    details(): Promise<GetWorkflowResponse> {
+        return this.request(`/api/workflows/${this.workflowId}`);
+    }
+
+    /**
+     * Executes the workflow with the provided parameters
+     * @param params - Parameters required for workflow execution
+     * @returns Promise containing the workflow execution results
+     */
+    execute(params: Record<string, any>): Promise<Record<string, any>> {
+        return this.request(`/api/workflows/${this.workflowId}/execute`, {
+            method: 'POST',
+            body: params,
+        });
+    }
+}