@mastra/client-js 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,410 @@
+import { ZodSchema } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+// src/resources/agent.ts
+
+// 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;
+  }
+  /**
+   * Retrieves details about the agent
+   * @returns Promise containing agent details including model and instructions
+   */
+  details() {
+    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(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: processedParams
+    });
+  }
+  /**
+   * Streams a response from the agent
+   * @param params - Stream parameters including prompt
+   * @returns Promise containing the streamed response
+   */
+  stream(params) {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output
+    };
+    return this.request(`/api/agents/${this.agentId}/stream`, {
+      method: "POST",
+      body: processedParams,
+      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) {
+    return this.request(`/api/agents/${this.agentId}/tools/${toolId}`);
+  }
+  /**
+   * Retrieves evaluation results for the agent
+   * @returns Promise containing agent evaluations
+   */
+  evals() {
+    return this.request(`/api/agents/${this.agentId}/evals`);
+  }
+  /**
+   * Retrieves live evaluation results for the agent
+   * @returns Promise containing live agent evaluations
+   */
+  liveEvals() {
+    return this.request(`/api/agents/${this.agentId}/evals/live`);
+  }
+};
+
+// src/resources/memory-thread.ts
+var MemoryThread = class extends BaseResource {
+  constructor(options, threadId) {
+    super(options);
+    this.threadId = threadId;
+  }
+  /**
+   * Retrieves the memory thread details
+   * @returns Promise containing thread details including title and metadata
+   */
+  get() {
+    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) {
+    return this.request(`/api/memory/threads/${this.threadId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  /**
+   * Deletes the memory thread
+   * @returns Promise containing deletion result
+   */
+  delete() {
+    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() {
+    return this.request(`/api/memory/threads/${this.threadId}/messages`);
+  }
+};
+
+// src/resources/vector.ts
+var Vector = class extends BaseResource {
+  constructor(options, vectorName) {
+    super(options);
+    this.vectorName = vectorName;
+  }
+  /**
+   * 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) {
+    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) {
+    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() {
+    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) {
+    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) {
+    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) {
+    return this.request(`/api/vector/${this.vectorName}/query`, {
+      method: "POST",
+      body: params
+    });
+  }
+};
+
+// src/resources/workflow.ts
+var Workflow = class extends BaseResource {
+  constructor(options, workflowId) {
+    super(options);
+    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/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
+   * @returns Promise containing map of agent IDs to agent details
+   */
+  getAgents() {
+    return this.request("/api/agents");
+  }
+  /**
+   * Gets an agent instance by ID
+   * @param agentId - ID of the agent to retrieve
+   * @returns Agent instance
+   */
+  getAgent(agentId) {
+    return new Agent(this.options, agentId);
+  }
+  /**
+   * Retrieves memory threads for a resource
+   * @param params - Parameters containing the resource ID
+   * @returns Promise containing array of memory threads
+   */
+  getMemoryThreads(params) {
+    return this.request(`/api/memory/threads?resourceid=${params.resourceId}`);
+  }
+  /**
+   * Creates a new memory thread
+   * @param params - Parameters for creating the memory thread
+   * @returns Promise containing the created memory thread
+   */
+  createMemoryThread(params) {
+    return this.request("/api/memory/threads", { method: "POST", body: params });
+  }
+  /**
+   * Gets a memory thread instance by ID
+   * @param threadId - ID of the memory thread to retrieve
+   * @returns MemoryThread instance
+   */
+  getMemoryThread(threadId) {
+    return new MemoryThread(this.options, threadId);
+  }
+  /**
+   * Saves messages to memory
+   * @param params - Parameters containing messages to save
+   * @returns Promise containing the saved messages
+   */
+  saveMessageToMemory(params) {
+    return this.request("/api/memory/save-messages", {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Gets the status of the memory system
+   * @returns Promise containing memory system status
+   */
+  getMemoryStatus() {
+    return this.request("/api/memory/status");
+  }
+  /**
+   * Retrieves all available tools
+   * @returns Promise containing map of tool IDs to tool details
+   */
+  getTools() {
+    return this.request("/api/tools");
+  }
+  /**
+   * Gets a tool instance by ID
+   * @param toolId - ID of the tool to retrieve
+   * @returns Tool instance
+   */
+  getTool(toolId) {
+    return new Tool(this.options, toolId);
+  }
+  /**
+   * Retrieves all available workflows
+   * @returns Promise containing map of workflow IDs to workflow details
+   */
+  getWorkflows() {
+    return this.request("/api/workflows");
+  }
+  /**
+   * Gets a workflow instance by ID
+   * @param workflowId - ID of the workflow to retrieve
+   * @returns Workflow instance
+   */
+  getWorkflow(workflowId) {
+    return new Workflow(this.options, workflowId);
+  }
+  /**
+   * Gets a vector instance by name
+   * @param vectorName - Name of the vector to retrieve
+   * @returns Vector instance
+   */
+  getVector(vectorName) {
+    return new Vector(this.options, vectorName);
+  }
+  /**
+   * Retrieves logs
+   * @param params - Parameters for filtering logs
+   * @returns Promise containing array of log messages
+   */
+  getLogs(params) {
+    return this.request(`/api/logs?transportId=${params.transportId}`);
+  }
+  /**
+   * Gets logs for a specific run
+   * @param params - Parameters containing run ID to retrieve
+   * @returns Promise containing array of log messages
+   */
+  getLogForRun(params) {
+    return this.request(`/api/logs/${params.runId}?transportId=${params.transportId}`);
+  }
+};
+
+export { MastraClient };

package/package.json

@@ -1,103 +1,40 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.10",
   "description": "The official TypeScript library for the Mastra Client API",
-  "author": "Mastra Client <dev-feedback@mastra.com>",
-  "types": "./index.d.ts",
-  "main": "./index.js",
-  "type": "commonjs",
-  "repository": "github:mastra-ai/client-js",
-  "license": "Apache-2.0",
-  "packageManager": "yarn@1.22.22",
-  "files": [
-    "**/*"
-  ],
-  "private": false,
-  "scripts": {
-    "test": "./scripts/test",
-    "build": "./scripts/build",
-    "format": "prettier --write --cache --cache-strategy metadata . !dist",
-    "tsn": "ts-node -r tsconfig-paths/register",
-    "lint": "./scripts/lint",
-    "fix": "./scripts/format"
+  "author": "",
+  "types": "dist/index.d.mts",
+  "main": "dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./package.json": "./package.json"
   },
+  "repository": "github:mastra-ai/client-js",
+  "license": "ISC",
   "dependencies": {
-    "@types/node": "^18.11.18",
-    "@types/node-fetch": "^2.6.4",
-    "abort-controller": "^3.0.0",
-    "agentkeepalive": "^4.2.1",
-    "form-data-encoder": "1.7.2",
-    "formdata-node": "^4.3.2",
-    "node-fetch": "^2.6.7"
+    "@mastra/core": "^0.2.0-alpha.83",
+    "json-schema": "^0.4.0",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.24.1"
   },
-  "sideEffects": [
-    "./_shims/index.js",
-    "./_shims/index.mjs",
-    "./shims/node.js",
-    "./shims/node.mjs",
-    "./shims/web.js",
-    "./shims/web.mjs"
-  ],
-  "imports": {
-    "@mastra/client-js": ".",
-    "@mastra/client-js/*": "./src/*"
+  "devDependencies": {
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@tsconfig/recommended": "^1.0.7",
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^22.9.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.4"
   },
-  "exports": {
-    "./_shims/auto/*": {
-      "deno": {
-        "types": "./_shims/auto/*.d.ts",
-        "require": "./_shims/auto/*.js",
-        "default": "./_shims/auto/*.mjs"
-      },
-      "bun": {
-        "types": "./_shims/auto/*.d.ts",
-        "require": "./_shims/auto/*-bun.js",
-        "default": "./_shims/auto/*-bun.mjs"
-      },
-      "browser": {
-        "types": "./_shims/auto/*.d.ts",
-        "require": "./_shims/auto/*.js",
-        "default": "./_shims/auto/*.mjs"
-      },
-      "worker": {
-        "types": "./_shims/auto/*.d.ts",
-        "require": "./_shims/auto/*.js",
-        "default": "./_shims/auto/*.mjs"
-      },
-      "workerd": {
-        "types": "./_shims/auto/*.d.ts",
-        "require": "./_shims/auto/*.js",
-        "default": "./_shims/auto/*.mjs"
-      },
-      "node": {
-        "types": "./_shims/auto/*-node.d.ts",
-        "require": "./_shims/auto/*-node.js",
-        "default": "./_shims/auto/*-node.mjs"
-      },
-      "types": "./_shims/auto/*.d.ts",
-      "require": "./_shims/auto/*.js",
-      "default": "./_shims/auto/*.mjs"
-    },
-    ".": {
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "types": "./index.d.mts",
-      "default": "./index.mjs"
-    },
-    "./*.mjs": {
-      "types": "./*.d.ts",
-      "default": "./*.mjs"
-    },
-    "./*.js": {
-      "types": "./*.d.ts",
-      "default": "./*.js"
-    },
-    "./*": {
-      "types": "./*.d.ts",
-      "require": "./*.js",
-      "default": "./*.mjs"
-    }
+  "scripts": {
+    "build": "tsup-node src/index.ts --format esm --dts --clean --treeshake",
+    "dev": "tsup-node src/index.ts --format esm --dts --clean --treeshake --watch",
+    "test": "vitest run"
   }
-}
+}

package/src/client.ts

@@ -0,0 +1,135 @@
+import type { ClientOptions, CreateMemoryThreadParams, CreateMemoryThreadResponse, GetAgentResponse, GetLogParams, GetLogsParams, GetLogsResponse, GetMemoryThreadParams, GetMemoryThreadResponse, GetToolResponse, GetWorkflowResponse, RequestOptions, SaveMessageToMemoryParams, SaveMessageToMemoryResponse } from './types';
+import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource } from './resources';
+
+export class MastraClient extends BaseResource {
+
+    constructor(options: ClientOptions) {
+        super(options);
+    }
+
+
+    /**
+     * Retrieves all available agents
+     * @returns Promise containing map of agent IDs to agent details
+     */
+    public getAgents(): Promise<Record<string, GetAgentResponse>> {
+        return this.request('/api/agents');
+    }
+
+    /**
+     * Gets an agent instance by ID
+     * @param agentId - ID of the agent to retrieve
+     * @returns Agent instance
+     */
+    public getAgent(agentId: string) {
+        return new Agent(this.options, agentId);
+    }
+
+    /**
+     * Retrieves memory threads for a resource
+     * @param params - Parameters containing the resource ID
+     * @returns Promise containing array of memory threads
+     */
+    public getMemoryThreads(params: GetMemoryThreadParams): Promise<GetMemoryThreadResponse> {
+        return this.request(`/api/memory/threads?resourceid=${params.resourceId}`);
+    }
+
+    /**
+     * Creates a new memory thread
+     * @param params - Parameters for creating the memory thread
+     * @returns Promise containing the created memory thread
+     */
+    public createMemoryThread(params: CreateMemoryThreadParams): Promise<CreateMemoryThreadResponse> {
+        return this.request('/api/memory/threads', { method: 'POST', body: params });
+    }
+
+    /**
+     * Gets a memory thread instance by ID
+     * @param threadId - ID of the memory thread to retrieve
+     * @returns MemoryThread instance
+     */
+    public getMemoryThread(threadId: string) {
+        return new MemoryThread(this.options, threadId);
+    }
+
+    /**
+     * Saves messages to memory
+     * @param params - Parameters containing messages to save
+     * @returns Promise containing the saved messages
+     */
+    public saveMessageToMemory(params: SaveMessageToMemoryParams): Promise<SaveMessageToMemoryResponse> {
+        return this.request('/api/memory/save-messages', {
+            method: 'POST',
+            body: params,
+        });
+    }
+
+    /**
+     * Gets the status of the memory system
+     * @returns Promise containing memory system status
+     */
+    public getMemoryStatus(): Promise<{ result: boolean }> {
+        return this.request('/api/memory/status');
+    }
+
+    /**
+     * Retrieves all available tools
+     * @returns Promise containing map of tool IDs to tool details
+     */
+    public getTools(): Promise<Record<string, GetToolResponse>> {
+        return this.request('/api/tools');
+    }
+
+    /**
+     * Gets a tool instance by ID
+     * @param toolId - ID of the tool to retrieve
+     * @returns Tool instance
+     */
+    public getTool(toolId: string) {
+        return new Tool(this.options, toolId);
+    }
+
+    /**
+     * Retrieves all available workflows
+     * @returns Promise containing map of workflow IDs to workflow details
+     */
+    public getWorkflows(): Promise<Record<string, GetWorkflowResponse>> {
+        return this.request('/api/workflows');
+    }
+
+    /**
+     * Gets a workflow instance by ID
+     * @param workflowId - ID of the workflow to retrieve
+     * @returns Workflow instance
+     */
+    public getWorkflow(workflowId: string) {
+        return new Workflow(this.options, workflowId);
+    }
+
+    /**
+     * Gets a vector instance by name
+     * @param vectorName - Name of the vector to retrieve
+     * @returns Vector instance
+     */
+    public getVector(vectorName: string) {
+        return new Vector(this.options, vectorName);
+    }
+
+    /**
+     * Retrieves logs
+     * @param params - Parameters for filtering logs
+     * @returns Promise containing array of log messages
+     */
+    public getLogs(params: GetLogsParams): Promise<GetLogsResponse> {
+        return this.request(`/api/logs?transportId=${params.transportId}`);
+    }
+
+    /**
+     * Gets logs for a specific run
+     * @param params - Parameters containing run ID to retrieve
+     * @returns Promise containing array of log messages
+     */
+    public getLogForRun(params: GetLogParams): Promise<GetLogsResponse> {
+        return this.request(`/api/logs/${params.runId}?transportId=${params.transportId}`);
+    }
+}