@mastra/client-js 0.1.0-alpha.2 → 0.1.0-alpha.3

package/src/index.ts

@@ -1,200 +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,
-  AgentStreamResponse,
-  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 AgentStreamResponse as AgentStreamResponse,
-    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,94 @@
+import type {
+    GetAgentResponse,
+    GetEvalsByAgentIdResponse,
+    GetToolResponse,
+    RequestFunction,
+} from '../types';
+import type {
+    GenerateReturn,
+    StreamReturn,
+} from '@mastra/core';
+
+export class AgentTool {
+    constructor(
+        private request: RequestFunction,
+        private agentId: string,
+        private toolId: string
+    ) { }
+
+    /**
+     * 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 {
+    constructor(
+        private request: RequestFunction,
+        private agentId: string
+    ) { }
+
+    /**
+     * 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>(params: any): Promise<GenerateReturn<T>> {
+        return this.request(`/api/agents/${this.agentId}/generate`, {
+            method: 'POST',
+            body: params,
+        });
+    }
+
+    /**
+     * Streams a response from the agent
+     * @param params - Stream parameters including prompt
+     * @returns Promise containing the streamed response
+     */
+    stream<T>(params: any): Promise<StreamReturn<T>> {
+        return this.request(`/api/agents/${this.agentId}/generate`, {
+            method: 'POST',
+            body: { ...params, 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/index.ts

@@ -1,14 +1,5 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-export {
-  Agents,
-  type AgentStreamResponse,
-  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 './tool';
+export * from './workflow';
+export * from './vector';

package/src/resources/memory-thread.ts

@@ -0,0 +1,51 @@
+import type { StorageThreadType } from '@mastra/core/memory';
+import type {
+    GetMemoryThreadMessagesResponse,
+    UpdateMemoryThreadParams,
+    RequestFunction
+} from '../types';
+
+export class MemoryThread {
+    constructor(
+        private request: RequestFunction,
+        private threadId: string
+    ) { }
+
+    /**
+     * 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,28 @@
+import type { GetToolResponse, RequestFunction } from '../types';
+
+export class Tool {
+    constructor(
+        private request: RequestFunction,
+        private toolId: string
+    ) { }
+
+    /**
+     * 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,79 @@
+import type {
+    CreateIndexParams,
+    GetVectorIndexResponse,
+    QueryVectorParams,
+    QueryVectorResponse,
+    UpsertVectorParams,
+    RequestFunction
+} from '../types';
+
+export class Vector {
+    constructor(
+        private request: RequestFunction,
+        private vectorName: string
+    ) { }
+
+    /**
+     * 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,28 @@
+import type { GetWorkflowResponse, RequestFunction } from '../types';
+
+export class Workflow {
+    constructor(
+        private request: RequestFunction,
+        private workflowId: string
+    ) { }
+
+    /**
+     * 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,
+        });
+    }
+}

package/src/types.ts

@@ -0,0 +1,121 @@
+import type { MessageType, AiMessageType, CoreMessage, QueryResult, StepAction, StepGraph, StorageThreadType, BaseLogMessage } from "@mastra/core";
+
+
+export interface ClientOptions {
+    baseUrl: string;
+    retries?: number;
+    backoffMs?: number;
+    maxBackoffMs?: number;
+    headers?: Record<string, string>;
+}
+
+export interface RequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+}
+
+export interface GetAgentResponse {
+    name: string;
+    model: string;
+    instructions: string;
+    tools: Record<string, GetToolResponse>;
+}
+
+export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
+    evals: any[];
+}
+
+export interface GetToolResponse {
+    id: string;
+    description: string;
+    inputSchema: string;
+    outputSchema: string;
+}
+
+export interface GetWorkflowResponse {
+    name: string;
+    triggerSchema: string;
+    steps: Record<string, StepAction<any, any, any, any>>;
+    stepGraph: StepGraph
+    stepSubscriberGraph: Record<string, StepGraph>
+}
+
+export interface UpsertVectorParams {
+    indexName: string;
+    vectors: number[][];
+    metadata?: Record<string, any>[];
+    ids?: string[];
+}
+export interface CreateIndexParams {
+    indexName: string;
+    dimension: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+
+export interface QueryVectorParams {
+    indexName: string;
+    queryVector: number[];
+    topK?: number;
+    filter?: Record<string, any>;
+    includeVector?: boolean;
+}
+
+export interface QueryVectorResponse {
+    results: QueryResult[];
+}
+
+export interface GetVectorIndexResponse {
+    dimension: number;
+    metric: 'cosine' | 'euclidean' | 'dotproduct';
+    count: number;
+}
+
+export interface SaveMessageToMemoryParams {
+    messages: MessageType[];
+}
+
+export type SaveMessageToMemoryResponse = MessageType[]
+
+export interface CreateMemoryThreadParams {
+    title: string;
+    metadata: Record<string, any>;
+    resourceid: string;
+    threadId: string;
+}
+
+export type CreateMemoryThreadResponse = StorageThreadType
+
+export interface GetMemoryThreadParams {
+    resourceId: string;
+}
+
+export type GetMemoryThreadResponse = StorageThreadType[]
+
+export interface UpdateMemoryThreadParams {
+    title: string;
+    metadata: Record<string, any>;
+    resourceid: string;
+}
+
+
+export interface GetMemoryThreadMessagesResponse {
+    messages: CoreMessage[];
+    uiMessages: AiMessageType[];
+}
+
+export interface GetLogsParams {
+    transportId: string;
+}
+
+export interface GetLogParams {
+    runId: string;
+    transportId: string;
+}
+
+export type GetLogsResponse = BaseLogMessage[]
+
+export type RequestFunction = (
+    path: string,
+    options?: RequestOptions
+) => Promise<any>;

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+    "$schema": "https://json.schemastore.org/tsconfig",
+    "compilerOptions": {
+        /* Base Options: */
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "target": "es2022",
+        "allowJs": true,
+        "resolveJsonModule": true,
+        "moduleDetection": "force",
+        "isolatedModules": true,
+        "verbatimModuleSyntax": true,
+        /* Strictness */
+        "strict": true,
+        "noUncheckedIndexedAccess": true,
+        // "noImplicitOverride": true,
+        /* AND if you're building for a library in a monorepo: */
+        // "composite": true,
+        "declaration": true,
+        "declarationMap": true,
+        /* If NOT transpiling with TypeScript: */
+        "module": "Preserve",
+        "noEmit": true,
+        /* If your code doesn't run in the DOM: */
+        "lib": [
+            "es2022"
+        ]
+    }
+}

package/vitest.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+  },
+});