@mastra/client-js 0.1.0-alpha.1

package/src/error.ts

@@ -0,0 +1,130 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { castToError, Headers } from './core';
+
+export class MastraClientError extends Error {}
+
+export class APIError<
+  TStatus extends number | undefined = number | undefined,
+  THeaders extends Headers | undefined = Headers | undefined,
+  TError extends Object | undefined = Object | undefined,
+> extends MastraClientError {
+  /** HTTP status for the response that caused the error */
+  readonly status: TStatus;
+  /** HTTP headers for the response that caused the error */
+  readonly headers: THeaders;
+  /** JSON body of the response that caused the error */
+  readonly error: TError;
+
+  constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders) {
+    super(`${APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+
+  private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
+    const msg =
+      error?.message ?
+        typeof error.message === 'string' ?
+          error.message
+        : JSON.stringify(error.message)
+      : error ? JSON.stringify(error)
+      : message;
+
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return '(no status code or body)';
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ): APIError {
+    if (!status || !headers) {
+      return new APIConnectionError({ message, cause: castToError(errorResponse) });
+    }
+
+    const error = errorResponse as Record<string, any>;
+
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+
+    return new APIError(status, error, message, headers);
+  }
+}
+
+export class APIUserAbortError extends APIError<undefined, undefined, undefined> {
+  constructor({ message }: { message?: string } = {}) {
+    super(undefined, undefined, message || 'Request was aborted.', undefined);
+  }
+}
+
+export class APIConnectionError extends APIError<undefined, undefined, undefined> {
+  constructor({ message, cause }: { message?: string | undefined; cause?: Error | undefined }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    // in some environments the 'cause' property is already declared
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+
+export class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message }: { message?: string } = {}) {
+    super({ message: message ?? 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError<400, Headers> {}
+
+export class AuthenticationError extends APIError<401, Headers> {}
+
+export class PermissionDeniedError extends APIError<403, Headers> {}
+
+export class NotFoundError extends APIError<404, Headers> {}
+
+export class ConflictError extends APIError<409, Headers> {}
+
+export class UnprocessableEntityError extends APIError<422, Headers> {}
+
+export class RateLimitError extends APIError<429, Headers> {}
+
+export class InternalServerError extends APIError<number, Headers> {}

package/src/index.ts

@@ -0,0 +1,194 @@
+// 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;

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

package/src/resource.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { MastraClient } from './index';
+
+export class APIResource {
+  protected _client: MastraClient;
+
+  constructor(client: MastraClient) {
+    this._client = client;
+  }
+}

package/src/resources/agents/agents.ts

@@ -0,0 +1,77 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import * as ToolsAPI from './tools';
+import { ToolExecuteParams, Tools } from './tools';
+
+export class Agents extends APIResource {
+  tools: ToolsAPI.Tools = new ToolsAPI.Tools(this._client);
+
+  /**
+   * Get agent by ID
+   */
+  retrieve(agentId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get(`/api/agents/${agentId}`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Get all available agents
+   */
+  list(options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get('/api/agents', { ...options, headers: { Accept: '*/*', ...options?.headers } });
+  }
+
+  /**
+   * Generate a response from an agent
+   */
+  generate(agentId: string, body: AgentGenerateParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post(`/api/agents/${agentId}/generate`, {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Stream a response from an agent
+   */
+  stream(agentId: string, body: AgentStreamParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post(`/api/agents/${agentId}/stream`, {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}
+
+export interface AgentGenerateParams {
+  messages: Array<unknown>;
+
+  output?: unknown;
+
+  resourceid?: string;
+
+  threadId?: string;
+}
+
+export interface AgentStreamParams {
+  messages: Array<unknown>;
+
+  output?: unknown;
+
+  resourceid?: string;
+
+  threadId?: string;
+}
+
+Agents.Tools = Tools;
+
+export declare namespace Agents {
+  export { type AgentGenerateParams as AgentGenerateParams, type AgentStreamParams as AgentStreamParams };
+
+  export { Tools as Tools, type ToolExecuteParams as ToolExecuteParams };
+}

package/src/resources/agents/index.ts

@@ -0,0 +1,4 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Agents, type AgentGenerateParams, type AgentStreamParams } from './agents';
+export { Tools, type ToolExecuteParams } from './tools';

package/src/resources/agents/tools.ts

@@ -0,0 +1,34 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+
+export class Tools extends APIResource {
+  /**
+   * Execute a tool through an agent
+   */
+  execute(
+    agentId: string,
+    toolId: string,
+    body: ToolExecuteParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<void> {
+    return this._client.post(`/api/agents/${agentId}/tools/${toolId}/execute`, {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}
+
+export interface ToolExecuteParams {
+  args: unknown;
+
+  resourceid?: string;
+
+  threadId?: string;
+}
+
+export declare namespace Tools {
+  export { type ToolExecuteParams as ToolExecuteParams };
+}

package/src/resources/index.ts

@@ -0,0 +1,9 @@
+// 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';

package/src/resources/logs.ts

@@ -0,0 +1,23 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+
+export class Logs extends APIResource {
+  /**
+   * Get logs by run ID
+   */
+  retrieve(runId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get(`/api/logs/${runId}`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Get all logs
+   */
+  list(options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get('/api/logs', { ...options, headers: { Accept: '*/*', ...options?.headers } });
+  }
+}

package/src/resources/memory/index.ts

@@ -0,0 +1,5 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Memory, type MemorySaveMessagesParams } from './memory';
+export { Status } from './status';
+export { Threads, type ThreadUpdateParams, type ThreadToolResultParams } from './threads/index';

package/src/resources/memory/memory.ts

@@ -0,0 +1,43 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import * as StatusAPI from './status';
+import { Status } from './status';
+import * as ThreadsAPI from './threads/threads';
+import { ThreadToolResultParams, ThreadUpdateParams, Threads } from './threads/threads';
+
+export class Memory extends APIResource {
+  status: StatusAPI.Status = new StatusAPI.Status(this._client);
+  threads: ThreadsAPI.Threads = new ThreadsAPI.Threads(this._client);
+
+  /**
+   * Save messages
+   */
+  saveMessages(body: MemorySaveMessagesParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/api/memory/save-messages', {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}
+
+export interface MemorySaveMessagesParams {
+  messages: Array<unknown>;
+}
+
+Memory.Status = Status;
+Memory.Threads = Threads;
+
+export declare namespace Memory {
+  export { type MemorySaveMessagesParams as MemorySaveMessagesParams };
+
+  export { Status as Status };
+
+  export {
+    Threads as Threads,
+    type ThreadUpdateParams as ThreadUpdateParams,
+    type ThreadToolResultParams as ThreadToolResultParams,
+  };
+}

package/src/resources/memory/status.ts

@@ -0,0 +1,16 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+
+export class Status extends APIResource {
+  /**
+   * Get memory status
+   */
+  retrieve(options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get('/api/memory/status', {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}

package/src/resources/memory/threads/index.ts

@@ -0,0 +1,4 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Messages } from './messages';
+export { Threads, type ThreadUpdateParams, type ThreadToolResultParams } from './threads';

package/src/resources/memory/threads/messages.ts

@@ -0,0 +1,16 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as Core from '../../../core';
+
+export class Messages extends APIResource {
+  /**
+   * Get messages for a thread
+   */
+  list(threadId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get(`/api/memory/threads/${threadId}/messages`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}

package/src/resources/memory/threads/threads.ts

@@ -0,0 +1,105 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as Core from '../../../core';
+import * as MessagesAPI from './messages';
+import { Messages } from './messages';
+
+export class Threads extends APIResource {
+  messages: MessagesAPI.Messages = new MessagesAPI.Messages(this._client);
+
+  /**
+   * Create a new thread
+   */
+  create(options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.post('/api/memory/threads', {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Get thread by ID
+   */
+  retrieve(threadId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get(`/api/memory/threads/${threadId}`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Update a thread
+   */
+  update(threadId: string, body: ThreadUpdateParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.patch(`/api/memory/threads/${threadId}`, {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Get all threads
+   */
+  list(options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get('/api/memory/threads', {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Delete a thread
+   */
+  delete(threadId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.delete(`/api/memory/threads/${threadId}`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Get context window for a thread
+   */
+  contextWindow(threadId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+    return this._client.get(`/api/memory/threads/${threadId}/context-window`, {
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+
+  /**
+   * Get tool execution result for a thread
+   */
+  toolResult(
+    threadId: string,
+    body: ThreadToolResultParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<void> {
+    return this._client.post(`/api/memory/threads/${threadId}/tool-result`, {
+      body,
+      ...options,
+      headers: { Accept: '*/*', ...options?.headers },
+    });
+  }
+}
+
+export type ThreadUpdateParams = unknown;
+
+export interface ThreadToolResultParams {
+  resultId: string;
+
+  toolId: string;
+}
+
+Threads.Messages = Messages;
+
+export declare namespace Threads {
+  export {
+    type ThreadUpdateParams as ThreadUpdateParams,
+    type ThreadToolResultParams as ThreadToolResultParams,
+  };
+
+  export { Messages as Messages };
+}