@mastra/client-js 0.0.0-storage-20250225005900

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

@@ -0,0 +1,6 @@
+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,60 @@
+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/tool.ts

@@ -0,0 +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);
+  }
+
+  /**
+   * 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

@@ -0,0 +1,83 @@
+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,68 @@
+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,
+    });
+  }
+
+  /**
+   * Resumes a suspended workflow step
+   * @param stepId - ID of the step to resume
+   * @param runId - ID of the workflow run
+   * @param context - Context to resume the workflow with
+   * @returns Promise containing the workflow resume results
+   */
+  resume({
+    stepId,
+    runId,
+    context,
+  }: {
+    stepId: string;
+    runId: string;
+    context: Record<string, any>;
+  }): Promise<Record<string, any>> {
+    return this.request(`/api/workflows/${this.workflowId}/resume`, {
+      method: 'POST',
+      body: {
+        stepId,
+        runId,
+        context,
+      },
+    });
+  }
+
+  /**
+   * Watches workflow transitions in real-time
+   * @returns Promise containing the workflow watch stream
+   */
+  watch(): Promise<Response> {
+    return this.request(`/api/workflows/${this.workflowId}/watch`, {
+      stream: true,
+    });
+  }
+}

package/src/types.ts

@@ -0,0 +1,163 @@
+import type {
+  MessageType,
+  AiMessageType,
+  CoreMessage,
+  QueryResult,
+  StepAction,
+  StepGraph,
+  StorageThreadType,
+  BaseLogMessage,
+  OutputType,
+} from '@mastra/core';
+import type { JSONSchema7 } from 'json-schema';
+import { ZodSchema } from 'zod';
+
+export interface ClientOptions {
+  /** Base URL for API requests */
+  baseUrl: string;
+  /** Number of retry attempts for failed requests */
+  retries?: number;
+  /** Initial backoff time in milliseconds between retries */
+  backoffMs?: number;
+  /** Maximum backoff time in milliseconds between retries */
+  maxBackoffMs?: number;
+  /** Custom headers to include with requests */
+  headers?: Record<string, string>;
+}
+
+export interface RequestOptions {
+  method?: string;
+  headers?: Record<string, string>;
+  body?: any;
+  stream?: boolean;
+}
+
+export interface GetAgentResponse {
+  name: string;
+  instructions: string;
+  tools: Record<string, GetToolResponse>;
+  provider: string;
+}
+
+export interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
+  messages: string | string[] | CoreMessage[];
+  threadId?: string;
+  resourceid?: string;
+  output?: OutputType | T;
+}
+
+export interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
+  messages: string | string[] | CoreMessage[];
+  threadId?: string;
+  resourceid?: string;
+  output?: OutputType | T;
+}
+
+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[];
+  agentId: string;
+}
+
+export type SaveMessageToMemoryResponse = MessageType[];
+
+export interface CreateMemoryThreadParams {
+  title: string;
+  metadata: Record<string, any>;
+  resourceid: string;
+  threadId: string;
+  agentId: string;
+}
+
+export type CreateMemoryThreadResponse = StorageThreadType;
+
+export interface GetMemoryThreadParams {
+  resourceId: string;
+  agentId: 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>;
+
+export interface GetTelemetryResponse {
+  traces: any[];
+}
+
+export interface GetTelemetryParams {
+  name?: string;
+  scope?: string;
+  page?: number;
+  perPage?: number;
+  attribute?: Record<string, string>;
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.node.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}

package/vitest.config.js

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