@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-vnextWorkflows-20250416071310

package/dist/{index.mjs → index.js}

@@ -1,5 +1,6 @@
 import { ZodSchema } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
+import { processDataStream } from '@ai-sdk/ui-utils';
 
 // src/resources/agent.ts
 
@@ -24,11 +25,12 @@ var BaseResource = class {
         const response = await fetch(`${baseUrl}${path}`, {
           ...options,
           headers: {
-            "Content-Type": "application/json",
             ...headers,
             ...options.headers
+            // TODO: Bring this back once we figure out what we/users need to do to make this work with cross-origin requests
+            // 'x-mastra-client-type': 'js',
           },
-          body: options.body ? JSON.stringify(options.body) : void 0
+          body: options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : void 0
         });
         if (!response.ok) {
           const errorBody = await response.text();
@@ -62,11 +64,60 @@ var BaseResource = class {
 };
 
 // src/resources/agent.ts
+var AgentVoice = class extends BaseResource {
+  constructor(options, agentId) {
+    super(options);
+    this.agentId = agentId;
+    this.agentId = agentId;
+  }
+  /**
+   * Convert text to speech using the agent's voice provider
+   * @param text - Text to convert to speech
+   * @param options - Optional provider-specific options for speech generation
+   * @returns Promise containing the audio data
+   */
+  async speak(text, options) {
+    return this.request(`/api/agents/${this.agentId}/voice/speak`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: { input: text, options },
+      stream: true
+    });
+  }
+  /**
+   * Convert speech to text using the agent's voice provider
+   * @param audio - Audio data to transcribe
+   * @param options - Optional provider-specific options
+   * @returns Promise containing the transcribed text
+   */
+  listen(audio, options) {
+    const formData = new FormData();
+    formData.append("audio", audio);
+    if (options) {
+      formData.append("options", JSON.stringify(options));
+    }
+    return this.request(`/api/agents/${this.agentId}/voice/listen`, {
+      method: "POST",
+      body: formData
+    });
+  }
+  /**
+   * Get available speakers for the agent's voice provider
+   * @returns Promise containing list of available speakers
+   */
+  getSpeakers() {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  }
+};
 var Agent = class extends BaseResource {
   constructor(options, agentId) {
     super(options);
     this.agentId = agentId;
+    this.voice = new AgentVoice(options, this.agentId);
   }
+  voice;
   /**
    * Retrieves details about the agent
    * @returns Promise containing agent details including model and instructions
@@ -82,7 +133,8 @@ var Agent = class extends BaseResource {
   generate(params) {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof ZodSchema ? zodToJsonSchema(params.experimental_output) : params.experimental_output
     };
     return this.request(`/api/agents/${this.agentId}/generate`, {
       method: "POST",
@@ -92,18 +144,29 @@ var Agent = class extends BaseResource {
   /**
    * Streams a response from the agent
    * @param params - Stream parameters including prompt
-   * @returns Promise containing the streamed response
+   * @returns Promise containing the enhanced Response object with processDataStream method
    */
-  stream(params) {
+  async stream(params) {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof ZodSchema ? zodToJsonSchema(params.experimental_output) : params.experimental_output
     };
-    return this.request(`/api/agents/${this.agentId}/stream`, {
+    const response = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: "POST",
       body: processedParams,
       stream: true
     });
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    response.processDataStream = async (options = {}) => {
+      await processDataStream({
+        stream: response.body,
+        ...options
+      });
+    };
+    return response;
   }
   /**
    * Gets details about a specific tool available to the agent
@@ -128,6 +191,62 @@ var Agent = class extends BaseResource {
     return this.request(`/api/agents/${this.agentId}/evals/live`);
   }
 };
+var Network = class extends BaseResource {
+  constructor(options, networkId) {
+    super(options);
+    this.networkId = networkId;
+  }
+  /**
+   * Retrieves details about the network
+   * @returns Promise containing network details
+   */
+  details() {
+    return this.request(`/api/networks/${this.networkId}`);
+  }
+  /**
+   * 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,
+      experimental_output: params.experimental_output instanceof ZodSchema ? zodToJsonSchema(params.experimental_output) : params.experimental_output
+    };
+    return this.request(`/api/networks/${this.networkId}/generate`, {
+      method: "POST",
+      body: processedParams
+    });
+  }
+  /**
+   * Streams a response from the agent
+   * @param params - Stream parameters including prompt
+   * @returns Promise containing the enhanced Response object with processDataStream method
+   */
+  async stream(params) {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof ZodSchema ? zodToJsonSchema(params.experimental_output) : params.experimental_output
+    };
+    const response = await this.request(`/api/networks/${this.networkId}/stream`, {
+      method: "POST",
+      body: processedParams,
+      stream: true
+    });
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    response.processDataStream = async (options = {}) => {
+      await processDataStream({
+        stream: response.body,
+        ...options
+      });
+    };
+    return response;
+  }
+};
 
 // src/resources/memory-thread.ts
 var MemoryThread = class extends BaseResource {
@@ -239,6 +358,7 @@ var Vector = class extends BaseResource {
 };
 
 // src/resources/workflow.ts
+var RECORD_SEPARATOR = "";
 var Workflow = class extends BaseResource {
   constructor(options, workflowId) {
     super(options);
@@ -252,6 +372,7 @@ var Workflow = class extends BaseResource {
     return this.request(`/api/workflows/${this.workflowId}`);
   }
   /**
+   * @deprecated Use `startAsync` instead
    * Executes the workflow with the provided parameters
    * @param params - Parameters required for workflow execution
    * @returns Promise containing the workflow execution results
@@ -263,7 +384,31 @@ var Workflow = class extends BaseResource {
     });
   }
   /**
-   * Resumes a suspended workflow step
+   * Creates a new workflow run
+   * @returns Promise containing the generated run ID
+   */
+  createRun(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    return this.request(`/api/workflows/${this.workflowId}/createRun?${searchParams.toString()}`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Starts a workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the runId and triggerData
+   * @returns Promise containing success message
+   */
+  start(params) {
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
+      method: "POST",
+      body: params?.triggerData
+    });
+  }
+  /**
+   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
    * @param stepId - ID of the step to resume
    * @param runId - ID of the workflow run
    * @param context - Context to resume the workflow with
@@ -274,23 +419,106 @@ var Workflow = class extends BaseResource {
     runId,
     context
   }) {
-    return this.request(`/api/workflows/${this.workflowId}/resume`, {
+    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
       body: {
         stepId,
-        runId,
         context
       }
     });
   }
+  /**
+   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the optional runId and triggerData
+   * @returns Promise containing the workflow execution results
+   */
+  startAsync(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+      method: "POST",
+      body: params?.triggerData
+    });
+  }
+  /**
+   * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the runId, stepId, and context
+   * @returns Promise containing the workflow resume results
+   */
+  resumeAsync(params) {
+    return this.request(`/api/workflows/${this.workflowId}/resume-async?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        stepId: params.stepId,
+        context: params.context
+      }
+    });
+  }
+  /**
+   * Creates an async generator that processes a readable stream and yields records
+   * separated by the Record Separator character (\x1E)
+   *
+   * @param stream - The readable stream to process
+   * @returns An async generator that yields parsed records
+   */
+  async *streamProcessor(stream) {
+    const reader = stream.getReader();
+    let doneReading = false;
+    let buffer = "";
+    try {
+      while (!doneReading) {
+        const { done, value } = await reader.read();
+        doneReading = done;
+        if (done && !value) continue;
+        try {
+          const decoded = value ? new TextDecoder().decode(value) : "";
+          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
+          buffer = chunks.pop() || "";
+          for (const chunk of chunks) {
+            if (chunk) {
+              if (typeof chunk === "string") {
+                try {
+                  const parsedChunk = JSON.parse(chunk);
+                  yield parsedChunk;
+                } catch {
+                }
+              }
+            }
+          }
+        } catch (error) {
+        }
+      }
+      if (buffer) {
+        try {
+          yield JSON.parse(buffer);
+        } catch {
+        }
+      }
+    } finally {
+      reader.cancel().catch(() => {
+      });
+    }
+  }
   /**
    * Watches workflow transitions in real-time
-   * @returns Promise containing the workflow watch stream
+   * @param runId - Optional run ID to filter the watch stream
+   * @returns AsyncGenerator that yields parsed records from the workflow watch stream
    */
-  watch() {
-    return this.request(`/api/workflows/${this.workflowId}/watch`, {
+  async watch({ runId }, onRecord) {
+    const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
       stream: true
     });
+    if (!response.ok) {
+      throw new Error(`Failed to watch workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    for await (const record of this.streamProcessor(response.body)) {
+      onRecord(record);
+    }
   }
 };
 
@@ -451,9 +679,6 @@ var MastraClient = class extends BaseResource {
   getTelemetry(params) {
     const { name, scope, page, perPage, attribute } = params || {};
     const _attribute = attribute ? Object.entries(attribute).map(([key, value]) => `${key}:${value}`) : [];
-    ({
-      ..._attribute?.length ? { attribute: _attribute } : {}
-    });
     const searchParams = new URLSearchParams();
     if (name) {
       searchParams.set("name", name);
@@ -482,6 +707,21 @@ var MastraClient = class extends BaseResource {
       return this.request(`/api/telemetry`);
     }
   }
+  /**
+   * Retrieves all available networks
+   * @returns Promise containing map of network IDs to network details
+   */
+  getNetworks() {
+    return this.request("/api/networks");
+  }
+  /**
+   * Gets a network instance by ID
+   * @param networkId - ID of the network to retrieve
+   * @returns Network instance
+   */
+  getNetwork(networkId) {
+    return new Network(this.options, networkId);
+  }
 };
 
 export { MastraClient };

package/package.json

@@ -1,41 +1,47 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.0.0-storage-20250225005900",
+  "version": "0.0.0-vnextWorkflows-20250416071310",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
-  "types": "dist/index.d.mts",
-  "main": "dist/index.mjs",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     },
     "./package.json": "./package.json"
   },
   "repository": "github:mastra-ai/client-js",
-  "license": "ISC",
+  "license": "Elastic-2.0",
   "dependencies": {
+    "@ai-sdk/ui-utils": "^1.1.19",
     "json-schema": "^0.4.0",
-    "zod": "^3.24.1",
-    "zod-to-json-schema": "^3.24.1",
-    "@mastra/core": "^0.0.0-storage-20250225005900"
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.3",
+    "@mastra/core": "0.0.0-vnextWorkflows-20250416071310"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.26.0",
-    "@babel/preset-typescript": "^7.26.0",
-    "@tsconfig/recommended": "^1.0.7",
+    "@babel/preset-env": "^7.26.9",
+    "@babel/preset-typescript": "^7.27.0",
+    "@tsconfig/recommended": "^1.0.8",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^22.9.0",
-    "tsup": "^8.0.1",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.4",
-    "@internal/lint": "0.0.0"
+    "@types/node": "^20.17.27",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2",
+    "vitest": "^3.0.9",
+    "@internal/lint": "0.0.2"
   },
   "scripts": {
-    "build": "tsup-node src/index.ts --format esm --dts --clean --treeshake",
-    "dev": "tsup-node src/index.ts --format esm --dts --clean --treeshake --watch",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting",
+    "dev": "pnpm build --watch",
     "test": "vitest run"
   }
 }

package/src/client.ts

@@ -1,4 +1,4 @@
-import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource } from './resources';
+import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource, Network } from './resources';
 import type {
   ClientOptions,
   CreateMemoryThreadParams,
@@ -9,6 +9,7 @@ import type {
   GetLogsResponse,
   GetMemoryThreadParams,
   GetMemoryThreadResponse,
+  GetNetworkResponse,
   GetTelemetryParams,
   GetTelemetryResponse,
   GetToolResponse,
@@ -202,4 +203,21 @@ export class MastraClient extends BaseResource {
       return this.request(`/api/telemetry`);
     }
   }
+
+  /**
+   * Retrieves all available networks
+   * @returns Promise containing map of network IDs to network details
+   */
+  public getNetworks(): Promise<Record<string, GetNetworkResponse>> {
+    return this.request('/api/networks');
+  }
+
+  /**
+   * Gets a network instance by ID
+   * @param networkId - ID of the network to retrieve
+   * @returns Network instance
+   */
+  public getNetwork(networkId: string) {
+    return new Network(this.options, networkId);
+  }
 }

package/src/example.ts

@@ -1,43 +1,65 @@
-import { MastraClient } from './client';
-
-(async () => {
-  const client = new MastraClient({
-    baseUrl: 'http://localhost:4111',
-  });
-
-  try {
-    const agent = client.getAgent('weatherAgent');
-    const response = await agent.stream({
-      messages: [
-        {
-          role: 'user',
-          content: 'Hello, world!',
-        },
-      ],
-    });
-
-    const reader = response?.body?.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-
-    while (true) {
-      if (!reader) break;
-      const { value, done } = await reader.read();
-      if (done) break;
-
-      const chunk = decoder.decode(value);
-      buffer += chunk;
-
-      console.log(buffer);
-
-      const matches = buffer.matchAll(/0:"([^"]*)"/g);
-
-      for (const match of matches) {
-        const content = match[1];
-        process.stdout.write(`${content}\n`);
-      }
-    }
-  } catch (error) {
-    console.error(error);
-  }
-})();
+// import { MastraClient } from './client';
+// import type { WorkflowRunResult } from './types';
+
+// Agent
+
+// (async () => {
+//   const client = new MastraClient({
+//     baseUrl: 'http://localhost:4111',
+//   });
+
+//   console.log('Starting agent...');
+
+//   try {
+//     const agent = client.getAgent('weatherAgent');
+//     const response = await agent.stream({
+//       messages: 'what is the weather in new york?',
+//     })
+
+//     response.processDataStream({
+//       onTextPart: (text) => {
+//         process.stdout.write(text);
+//       },
+//       onFilePart: (file) => {
+//         console.log(file);
+//       },
+//       onDataPart: (data) => {
+//         console.log(data);
+//       },
+//       onErrorPart: (error) => {
+//         console.error(error);
+//       },
+//     });
+
+//   } catch (error) {
+//     console.error(error);
+//   }
+// })();
+
+// Workflow
+// (async () => {
+//   const client = new MastraClient({
+//     baseUrl: 'http://localhost:4111',
+//   });
+
+//   try {
+//     const workflowId = 'myWorkflow';
+//     const workflow = client.getWorkflow(workflowId);
+
+//     const { runId } = await workflow.createRun();
+
+//     workflow.watch({ runId }, record => {
+//       console.log(new Date().toTimeString(), record);
+//     });
+
+//     await workflow.start({
+//       runId,
+//       triggerData: {
+//         city: 'New York',
+//       },
+//     });
+
+//   } catch (e) {
+//     console.error('Workflow error:', e);
+//   }
+// })();