@mastra/client-js 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/index.d.mts

@@ -1,18 +1,24 @@
-import { MessageType, OutputType, StorageThreadType, CoreMessage, AiMessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn, StreamReturn } from '@mastra/core';
+import { MessageType, OutputType, StorageThreadType, CoreMessage, AiMessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
-import { StorageThreadType as StorageThreadType$1 } from '@mastra/core/memory';
+import { ZodSchema } from 'zod';
 
 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>;
 }
 interface RequestOptions {
     method?: string;
     headers?: Record<string, string>;
     body?: any;
+    stream?: boolean;
 }
 interface GetAgentResponse {
     name: string;
@@ -20,13 +26,13 @@ interface GetAgentResponse {
     instructions: string;
     tools: Record<string, GetToolResponse>;
 }
-interface GenerateParams<T extends JSONSchema7 | undefined = undefined> {
+interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
     messages: MessageType[];
     threadId?: string;
     resourceid?: string;
     output?: OutputType | T;
 }
-interface StreamParams<T extends JSONSchema7 | undefined = undefined> {
+interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
     messages: MessageType[];
     threadId?: string;
     resourceid?: string;
@@ -108,10 +114,21 @@ interface GetLogParams {
 type GetLogsResponse = BaseLogMessage[];
 type RequestFunction = (path: string, options?: RequestOptions) => Promise<any>;
 
-declare class Agent {
-    private request;
+declare class BaseResource {
+    readonly options: ClientOptions;
+    constructor(options: ClientOptions);
+    /**
+     * 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
+     */
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+}
+
+declare class Agent extends BaseResource {
     private agentId;
-    constructor(request: RequestFunction, agentId: string);
+    constructor(options: ClientOptions, agentId: string);
     /**
      * Retrieves details about the agent
      * @returns Promise containing agent details including model and instructions
@@ -122,13 +139,13 @@ declare class Agent {
      * @param params - Generation parameters including prompt
      * @returns Promise containing the generated response
      */
-    generate<T extends JSONSchema7 | undefined = undefined>(params: GenerateParams<T>): Promise<GenerateReturn<T>>;
+    generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: GenerateParams<T>): Promise<GenerateReturn<T>>;
     /**
      * Streams a response from the agent
      * @param params - Stream parameters including prompt
      * @returns Promise containing the streamed response
      */
-    stream<T extends JSONSchema7 | undefined = undefined>(params: StreamParams<T>): Promise<StreamReturn<T>>;
+    stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response>;
     /**
      * Gets details about a specific tool available to the agent
      * @param toolId - ID of the tool to retrieve
@@ -147,21 +164,20 @@ declare class Agent {
     liveEvals(): Promise<GetEvalsByAgentIdResponse>;
 }
 
-declare class MemoryThread {
-    private request;
+declare class MemoryThread extends BaseResource {
     private threadId;
-    constructor(request: RequestFunction, threadId: string);
+    constructor(options: ClientOptions, threadId: string);
     /**
      * Retrieves the memory thread details
      * @returns Promise containing thread details including title and metadata
      */
-    get(): Promise<StorageThreadType$1>;
+    get(): Promise<StorageThreadType>;
     /**
      * Updates the memory thread properties
      * @param params - Update parameters including title and metadata
      * @returns Promise containing updated thread details
      */
-    update(params: UpdateMemoryThreadParams): Promise<StorageThreadType$1>;
+    update(params: UpdateMemoryThreadParams): Promise<StorageThreadType>;
     /**
      * Deletes the memory thread
      * @returns Promise containing deletion result
@@ -176,44 +192,9 @@ declare class MemoryThread {
     getMessages(): Promise<GetMemoryThreadMessagesResponse>;
 }
 
-declare class Tool {
-    private request;
-    private toolId;
-    constructor(request: RequestFunction, toolId: string);
-    /**
-     * Retrieves details about the tool
-     * @returns Promise containing tool details including description and schemas
-     */
-    details(): Promise<GetToolResponse>;
-    /**
-     * 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>>;
-}
-
-declare class Workflow {
-    private request;
-    private workflowId;
-    constructor(request: RequestFunction, workflowId: string);
-    /**
-     * Retrieves details about the workflow
-     * @returns Promise containing workflow details including steps and graphs
-     */
-    details(): Promise<GetWorkflowResponse>;
-    /**
-     * 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>>;
-}
-
-declare class Vector {
-    private request;
+declare class Vector extends BaseResource {
     private vectorName;
-    constructor(request: RequestFunction, vectorName: string);
+    constructor(options: ClientOptions, vectorName: string);
     /**
      * Retrieves details about a specific vector index
      * @param indexName - Name of the index to get details for
@@ -257,21 +238,40 @@ declare class Vector {
     query(params: QueryVectorParams): Promise<QueryVectorResponse>;
 }
 
-declare class MastraClient {
-    readonly baseUrl: string;
-    private readonly retries;
-    private readonly backoffMs;
-    private readonly maxBackoffMs;
-    private readonly headers;
-    constructor(options: ClientOptions);
+declare class Workflow extends BaseResource {
+    private workflowId;
+    constructor(options: ClientOptions, workflowId: string);
+    /**
+     * Retrieves details about the workflow
+     * @returns Promise containing workflow details including steps and graphs
+     */
+    details(): Promise<GetWorkflowResponse>;
+    /**
+     * 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>>;
+}
+
+declare class Tool extends BaseResource {
+    private toolId;
+    constructor(options: ClientOptions, toolId: string);
     /**
-     * Makes an HTTP request to the Mastra API
-     * @param path - API endpoint path
-     * @param options - Request options including method, headers, and body
-     * @returns Promise containing the API response
-     * @throws Error if the request fails after all retries
+     * Retrieves details about the tool
+     * @returns Promise containing tool details including description and schemas
      */
-    request(path: string, options?: RequestOptions): Promise<any>;
+    details(): Promise<GetToolResponse>;
+    /**
+     * 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>>;
+}
+
+declare class MastraClient extends BaseResource {
+    constructor(options: ClientOptions);
     /**
      * Retrieves all available agents
      * @returns Promise containing map of agent IDs to agent details

package/dist/index.mjs

@@ -1,7 +1,70 @@
+import { ZodSchema } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
 // src/resources/agent.ts
-var Agent = class {
-  constructor(request, agentId) {
-    this.request = request;
+
+// src/resources/base.ts
+var BaseResource = class {
+  options;
+  constructor(options) {
+    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
+   */
+  async request(path, options = {}) {
+    let lastError = null;
+    const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1e3, 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) : void 0
+        });
+        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;
+        }
+        const data = await response.json();
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (attempt === retries) {
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, maxBackoffMs);
+      }
+    }
+    throw lastError || new Error("Request failed");
+  }
+};
+
+// src/resources/agent.ts
+var Agent = class extends BaseResource {
+  constructor(options, agentId) {
+    super(options);
     this.agentId = agentId;
   }
   /**
@@ -17,9 +80,13 @@ var Agent = class {
    * @returns Promise containing the generated response
    */
   generate(params) {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output
+    };
     return this.request(`/api/agents/${this.agentId}/generate`, {
       method: "POST",
-      body: params
+      body: processedParams
     });
   }
   /**
@@ -28,9 +95,14 @@ var Agent = class {
    * @returns Promise containing the streamed response
    */
   stream(params) {
-    return this.request(`/api/agents/${this.agentId}/generate`, {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output
+    };
+    return this.request(`/api/agents/${this.agentId}/stream`, {
       method: "POST",
-      body: { ...params, stream: true }
+      body: processedParams,
+      stream: true
     });
   }
   /**
@@ -58,9 +130,9 @@ var Agent = class {
 };
 
 // src/resources/memory-thread.ts
-var MemoryThread = class {
-  constructor(request, threadId) {
-    this.request = request;
+var MemoryThread = class extends BaseResource {
+  constructor(options, threadId) {
+    super(options);
     this.threadId = threadId;
   }
   /**
@@ -99,62 +171,10 @@ var MemoryThread = class {
   }
 };
 
-// src/resources/tool.ts
-var Tool = class {
-  constructor(request, toolId) {
-    this.request = request;
-    this.toolId = toolId;
-  }
-  /**
-   * Retrieves details about the tool
-   * @returns Promise containing tool details including description and schemas
-   */
-  details() {
-    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) {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
-      method: "POST",
-      body: params
-    });
-  }
-};
-
-// src/resources/workflow.ts
-var Workflow = class {
-  constructor(request, workflowId) {
-    this.request = request;
-    this.workflowId = workflowId;
-  }
-  /**
-   * Retrieves details about the workflow
-   * @returns Promise containing workflow details including steps and graphs
-   */
-  details() {
-    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) {
-    return this.request(`/api/workflows/${this.workflowId}/execute`, {
-      method: "POST",
-      body: params
-    });
-  }
-};
-
 // src/resources/vector.ts
-var Vector = class {
-  constructor(request, vectorName) {
-    this.request = request;
+var Vector = class extends BaseResource {
+  constructor(options, vectorName) {
+    super(options);
     this.vectorName = vectorName;
   }
   /**
@@ -217,56 +237,62 @@ var Vector = class {
   }
 };
 
-// src/client.ts
-var MastraClient = class {
-  baseUrl;
-  retries;
-  backoffMs;
-  maxBackoffMs;
-  headers;
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.retries = options.retries ?? 3;
-    this.backoffMs = options.backoffMs ?? 300;
-    this.maxBackoffMs = options.maxBackoffMs ?? 5e3;
-    this.headers = {
-      "Content-Type": "application/json",
-      ...options.headers
-    };
+// src/resources/workflow.ts
+var Workflow = class extends BaseResource {
+  constructor(options, workflowId) {
+    super(options);
+    this.workflowId = workflowId;
   }
   /**
-   * Makes an HTTP request to the Mastra API
-   * @param path - API endpoint path
-   * @param options - Request options including method, headers, and body
-   * @returns Promise containing the API response
-   * @throws Error if the request fails after all retries
+   * Retrieves details about the workflow
+   * @returns Promise containing workflow details including steps and graphs
    */
-  async request(path, options = {}) {
-    const url = `${this.baseUrl}${path}`;
-    let lastError = null;
-    let currentBackoff = this.backoffMs;
-    for (let attempt = 0; attempt <= this.retries; attempt++) {
-      try {
-        const response = await fetch(url, {
-          method: options.method ?? "GET",
-          headers: {
-            ...this.headers,
-            ...options.headers
-          },
-          body: options.body ? JSON.stringify(options.body) : void 0
-        });
-        if (!response.ok) {
-          throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        return await response.json();
-      } catch (error) {
-        lastError = error;
-        if (attempt === this.retries) break;
-        await new Promise((resolve) => setTimeout(resolve, currentBackoff));
-        currentBackoff = Math.min(currentBackoff * 2, this.maxBackoffMs);
-      }
-    }
-    throw lastError;
+  details() {
+    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) {
+    return this.request(`/api/workflows/${this.workflowId}/execute`, {
+      method: "POST",
+      body: params
+    });
+  }
+};
+
+// src/resources/tool.ts
+var Tool = class extends BaseResource {
+  constructor(options, toolId) {
+    super(options);
+    this.toolId = toolId;
+  }
+  /**
+   * Retrieves details about the tool
+   * @returns Promise containing tool details including description and schemas
+   */
+  details() {
+    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) {
+    return this.request(`/api/tools/${this.toolId}/execute`, {
+      method: "POST",
+      body: params
+    });
+  }
+};
+
+// src/client.ts
+var MastraClient = class extends BaseResource {
+  constructor(options) {
+    super(options);
   }
   /**
    * Retrieves all available agents
@@ -281,10 +307,7 @@ var MastraClient = class {
    * @returns Agent instance
    */
   getAgent(agentId) {
-    return new Agent(
-      (path, options) => this.request(path, options),
-      agentId
-    );
+    return new Agent(this.options, agentId);
   }
   /**
    * Retrieves memory threads for a resource
@@ -308,10 +331,7 @@ var MastraClient = class {
    * @returns MemoryThread instance
    */
   getMemoryThread(threadId) {
-    return new MemoryThread(
-      (path, options) => this.request(path, options),
-      threadId
-    );
+    return new MemoryThread(this.options, threadId);
   }
   /**
    * Saves messages to memory
@@ -344,10 +364,7 @@ var MastraClient = class {
    * @returns Tool instance
    */
   getTool(toolId) {
-    return new Tool(
-      (path, options) => this.request(path, options),
-      toolId
-    );
+    return new Tool(this.options, toolId);
   }
   /**
    * Retrieves all available workflows
@@ -362,10 +379,7 @@ var MastraClient = class {
    * @returns Workflow instance
    */
   getWorkflow(workflowId) {
-    return new Workflow(
-      (path, options) => this.request(path, options),
-      workflowId
-    );
+    return new Workflow(this.options, workflowId);
   }
   /**
    * Gets a vector instance by name
@@ -373,10 +387,7 @@ var MastraClient = class {
    * @returns Vector instance
    */
   getVector(vectorName) {
-    return new Vector(
-      (path, options) => this.request(path, options),
-      vectorName
-    );
+    return new Vector(this.options, vectorName);
   }
   /**
    * Retrieves logs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.8",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "types": "dist/index.d.mts",

package/src/client.ts

@@ -1,63 +1,12 @@
 import type { ClientOptions, CreateMemoryThreadParams, CreateMemoryThreadResponse, GetAgentResponse, GetLogParams, GetLogsParams, GetLogsResponse, GetMemoryThreadParams, GetMemoryThreadResponse, GetToolResponse, GetWorkflowResponse, RequestOptions, SaveMessageToMemoryParams, SaveMessageToMemoryResponse } from './types';
-import { Agent, MemoryThread, Tool, Workflow, Vector } from './resources';
+import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource } from './resources';
 
-export class MastraClient {
-    readonly baseUrl: string;
-    private readonly retries: number;
-    private readonly backoffMs: number;
-    private readonly maxBackoffMs: number;
-    private readonly headers: Record<string, string>;
+export class MastraClient extends BaseResource {
 
     constructor(options: ClientOptions) {
-        this.baseUrl = options.baseUrl.replace(/\/$/, '');
-        this.retries = options.retries ?? 3;
-        this.backoffMs = options.backoffMs ?? 300;
-        this.maxBackoffMs = options.maxBackoffMs ?? 5000;
-        this.headers = {
-            'Content-Type': 'application/json',
-            ...options.headers,
-        };
+        super(options);
     }
 
-    /**
-     * Makes an HTTP request to the Mastra API
-     * @param path - API endpoint path
-     * @param options - Request options including method, headers, and body
-     * @returns Promise containing the API response
-     * @throws Error if the request fails after all retries
-     */
-    async request(path: string, options: RequestOptions = {}): Promise<any> {
-        const url = `${this.baseUrl}${path}`;
-        let lastError: Error | null = null;
-        let currentBackoff = this.backoffMs;
-
-        for (let attempt = 0; attempt <= this.retries; attempt++) {
-            try {
-                const response = await fetch(url, {
-                    method: options.method ?? 'GET',
-                    headers: {
-                        ...this.headers,
-                        ...options.headers,
-                    },
-                    body: options.body ? JSON.stringify(options.body) : undefined,
-                });
-
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`);
-                }
-
-                return await response.json();
-            } catch (error) {
-                lastError = error as Error;
-                if (attempt === this.retries) break;
-
-                await new Promise(resolve => setTimeout(resolve, currentBackoff));
-                currentBackoff = Math.min(currentBackoff * 2, this.maxBackoffMs);
-            }
-        }
-
-        throw lastError;
-    }
 
     /**
      * Retrieves all available agents
@@ -73,10 +22,7 @@ export class MastraClient {
      * @returns Agent instance
      */
     public getAgent(agentId: string) {
-        return new Agent(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            agentId
-        );
+        return new Agent(this.options, agentId);
     }
 
     /**
@@ -103,10 +49,7 @@ export class MastraClient {
      * @returns MemoryThread instance
      */
     public getMemoryThread(threadId: string) {
-        return new MemoryThread(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            threadId
-        );
+        return new MemoryThread(this.options, threadId);
     }
 
     /**
@@ -143,10 +86,7 @@ export class MastraClient {
      * @returns Tool instance
      */
     public getTool(toolId: string) {
-        return new Tool(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            toolId
-        );
+        return new Tool(this.options, toolId);
     }
 
     /**
@@ -163,10 +103,7 @@ export class MastraClient {
      * @returns Workflow instance
      */
     public getWorkflow(workflowId: string) {
-        return new Workflow(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            workflowId
-        );
+        return new Workflow(this.options, workflowId);
     }
 
     /**
@@ -175,10 +112,7 @@ export class MastraClient {
      * @returns Vector instance
      */
     public getVector(vectorName: string) {
-        return new Vector(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            vectorName
-        );
+        return new Vector(this.options, vectorName);
     }
 
     /**