@mastra/client-js 0.1.0-alpha.5 → 0.1.0-alpha.7

package/src/resources/base.ts

@@ -0,0 +1,79 @@
+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 {
+                        // Try to parse as JSON for structured error messages
+                        const errorJson = JSON.parse(errorBody);
+                        errorMessage += ` - ${JSON.stringify(errorJson)}`;
+                    } catch {
+                        // If not JSON, include the raw error body if present
+                        if (errorBody) {
+                            errorMessage += ` - ${errorBody}`;
+                        }
+                    }
+                    throw new Error(errorMessage);
+                }
+
+                // For streaming responses, return the stream directly
+                if (response.headers.get('Content-Type')?.includes('text/event-stream')) {
+                    return response.body as T;
+                }
+
+                // For unknown responses, return the response as is
+                if (response.headers.get('Content-Type')?.includes('text/x-unknown')) {
+                    return response as T;
+                }
+
+                const data = await response.json();
+                return data as T;
+            } catch (error) {
+                lastError = error as Error;
+
+                if (attempt === retries) {
+                    break;
+                }
+
+                // Wait with exponential backoff
+                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,5 +1,6 @@
 export * from './agent';
 export * from './memory-thread';
-export * from './tool';
+export * from './vector';
 export * from './workflow';
-export * from './vector';
+export * from './tool';
+export * from './base';

package/src/resources/memory-thread.ts

@@ -1,15 +1,21 @@
-import type { StorageThreadType } from '@mastra/core/memory';
+import type { StorageThreadType } from '@mastra/core';
 import type {
+    CreateMemoryThreadParams,
     GetMemoryThreadMessagesResponse,
+    GetMemoryThreadResponse,
+    ClientOptions,
+    SaveMessageToMemoryParams,
     UpdateMemoryThreadParams,
-    RequestFunction
 } from '../types';
+import { BaseResource } from './base';
 
-export class MemoryThread {
+export class MemoryThread extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private threadId: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves the memory thread details

package/src/resources/tool.ts

@@ -1,10 +1,13 @@
-import type { GetToolResponse, RequestFunction } from '../types';
+import type { GetToolResponse, ClientOptions } from '../types';
+import { BaseResource } from './base';
 
-export class Tool {
+export class Tool extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private toolId: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves details about the tool

package/src/resources/vector.ts

@@ -3,15 +3,18 @@ import type {
     GetVectorIndexResponse,
     QueryVectorParams,
     QueryVectorResponse,
+    ClientOptions,
     UpsertVectorParams,
-    RequestFunction
 } from '../types';
+import { BaseResource } from './base';
 
-export class Vector {
+export class Vector extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private vectorName: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves details about a specific vector index

package/src/resources/workflow.ts

@@ -1,10 +1,13 @@
-import type { GetWorkflowResponse, RequestFunction } from '../types';
+import type { GetWorkflowResponse, ClientOptions } from '../types';
+import { BaseResource } from './base';
 
-export class Workflow {
+export class Workflow extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private workflowId: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves details about the workflow

package/src/types.ts

@@ -1,11 +1,17 @@
 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>;
 }
 
@@ -22,14 +28,14 @@ export interface GetAgentResponse {
     tools: Record<string, GetToolResponse>;
 }
 
-export interface GenerateParams<T extends JSONSchema7 | undefined = undefined> {
+export interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
     messages: MessageType[];
     threadId?: string;
     resourceid?: string;
     output?: OutputType | T
 }
 
-export interface StreamParams<T extends JSONSchema7 | undefined = undefined> {
+export interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
     messages: MessageType[];
     threadId?: string;
     resourceid?: string;