@mastra/client-js 0.1.5-alpha.1 → 0.1.5-alpha.4

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
-> @mastra/client-js@0.1.5-alpha.1 build /home/runner/work/mastra/mastra/client-sdks/client-js
-> tsup src/index.ts --format esm --dts --clean --treeshake
+> @mastra/client-js@0.1.5-alpha.4 build /home/runner/work/mastra/mastra/client-sdks/client-js
+> tsup src/index.ts --format esm,cjs --dts --clean --treeshake
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
@@ -8,8 +8,12 @@
 CLI Target: es2022
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.mjs 13.56 KB
-ESM ⚡️ Build success in 606ms
+CJS Build start
+CJS dist/index.cjs 13.96 KB
+CJS ⚡️ Build success in 649ms
+ESM dist/index.js 13.86 KB
+ESM ⚡️ Build success in 652ms
 DTS Build start
-DTS ⚡️ Build success in 9532ms
-DTS dist/index.d.mts 13.64 KB
+DTS ⚡️ Build success in 9179ms
+DTS dist/index.d.ts  13.64 KB
+DTS dist/index.d.cts 13.64 KB

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @mastra/client-js
 
+## 0.1.5-alpha.4
+
+### Patch Changes
+
+- Updated dependencies [dabecf4]
+  - @mastra/core@0.4.3-alpha.4
+
+## 0.1.5-alpha.3
+
+### Patch Changes
+
+- 0d25b75: Add all agent stream,generate option to cliend-js sdk
+- 7a64aff: Add more types to client-js sdk
+- bb4f447: Add support for commonjs
+- Updated dependencies [0fd78ac]
+- Updated dependencies [0d25b75]
+- Updated dependencies [fd14a3f]
+- Updated dependencies [3f369a2]
+- Updated dependencies [4d4e1e1]
+- Updated dependencies [bb4f447]
+  - @mastra/core@0.4.3-alpha.3
+
+## 0.1.5-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [2512a93]
+- Updated dependencies [e62de74]
+  - @mastra/core@0.4.3-alpha.2
+
 ## 0.1.5-alpha.1
 
 ### Patch Changes

package/dist/index.cjs

@@ -0,0 +1,491 @@
+'use strict';
+
+var zod = require('zod');
+var zodToJsonSchema = require('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 zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.experimental_output) : params.experimental_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 zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.experimental_output) : params.experimental_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/ci`);
+  }
+  /**
+   * 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, agentId) {
+    super(options);
+    this.threadId = threadId;
+    this.agentId = agentId;
+  }
+  /**
+   * Retrieves the memory thread details
+   * @returns Promise containing thread details including title and metadata
+   */
+  get() {
+    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) {
+    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() {
+    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() {
+    return this.request(`/api/memory/threads/${this.threadId}/messages?agentId=${this.agentId}`);
+  }
+};
+
+// 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
+    });
+  }
+  /**
+   * 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
+  }) {
+    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() {
+    return this.request(`/api/workflows/${this.workflowId}/watch`, {
+      stream: true
+    });
+  }
+};
+
+// 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}&agentId=${params.agentId}`);
+  }
+  /**
+   * 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?agentId=${params.agentId}`, { 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, agentId) {
+    return new MemoryThread(this.options, threadId, agentId);
+  }
+  /**
+   * 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?agentId=${params.agentId}`, {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Gets the status of the memory system
+   * @returns Promise containing memory system status
+   */
+  getMemoryStatus(agentId) {
+    return this.request(`/api/memory/status?agentId=${agentId}`);
+  }
+  /**
+   * 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}`);
+  }
+  /**
+   * List of all log transports
+   * @returns Promise containing list of log transports
+   */
+  getLogTransports() {
+    return this.request("/api/logs/transports");
+  }
+  /**
+   * List of all traces (paged)
+   * @param params - Parameters for filtering traces
+   * @returns Promise containing telemetry data
+   */
+  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);
+    }
+    if (scope) {
+      searchParams.set("scope", scope);
+    }
+    if (page) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage) {
+      searchParams.set("perPage", String(perPage));
+    }
+    if (_attribute) {
+      if (Array.isArray(_attribute)) {
+        for (const attr of _attribute) {
+          searchParams.append("attribute", attr);
+        }
+      } else {
+        searchParams.set("attribute", _attribute);
+      }
+    }
+    if (searchParams.size) {
+      return this.request(`/api/telemetry?${searchParams}`);
+    } else {
+      return this.request(`/api/telemetry`);
+    }
+  }
+};
+
+exports.MastraClient = MastraClient;

package/dist/{index.d.mts → index.d.cts}

@@ -1,6 +1,7 @@
-import { CoreMessage, OutputType, StorageThreadType, AiMessageType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
+import { CoreMessage, StorageThreadType, AiMessageType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
+import { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
 
 interface ClientOptions {
     /** Base URL for API requests */
@@ -25,19 +26,14 @@ interface GetAgentResponse {
     instructions: string;
     tools: Record<string, GetToolResponse>;
     provider: string;
+    modelId: string;
 }
-interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
+type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
     messages: string | string[] | CoreMessage[];
-    threadId?: string;
-    resourceid?: string;
-    output?: OutputType | T;
-}
-interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
+} & Partial<AgentGenerateOptions<T>>;
+type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
     messages: string | string[] | CoreMessage[];
-    threadId?: string;
-    resourceid?: string;
-    output?: OutputType | T;
-}
+} & Partial<AgentStreamOptions<T>>;
 interface GetEvalsByAgentIdResponse extends GetAgentResponse {
     evals: any[];
 }

package/dist/index.d.ts

@@ -0,0 +1,401 @@
+import { CoreMessage, StorageThreadType, AiMessageType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
+import { JSONSchema7 } from 'json-schema';
+import { ZodSchema } from 'zod';
+import { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
+
+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;
+    instructions: string;
+    tools: Record<string, GetToolResponse>;
+    provider: string;
+    modelId: string;
+}
+type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+    messages: string | string[] | CoreMessage[];
+} & Partial<AgentGenerateOptions<T>>;
+type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+    messages: string | string[] | CoreMessage[];
+} & Partial<AgentStreamOptions<T>>;
+interface GetEvalsByAgentIdResponse extends GetAgentResponse {
+    evals: any[];
+}
+interface GetToolResponse {
+    id: string;
+    description: string;
+    inputSchema: string;
+    outputSchema: string;
+}
+interface GetWorkflowResponse {
+    name: string;
+    triggerSchema: string;
+    steps: Record<string, StepAction<any, any, any, any>>;
+    stepGraph: StepGraph;
+    stepSubscriberGraph: Record<string, StepGraph>;
+}
+interface UpsertVectorParams {
+    indexName: string;
+    vectors: number[][];
+    metadata?: Record<string, any>[];
+    ids?: string[];
+}
+interface CreateIndexParams {
+    indexName: string;
+    dimension: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+interface QueryVectorParams {
+    indexName: string;
+    queryVector: number[];
+    topK?: number;
+    filter?: Record<string, any>;
+    includeVector?: boolean;
+}
+interface QueryVectorResponse {
+    results: QueryResult[];
+}
+interface GetVectorIndexResponse {
+    dimension: number;
+    metric: 'cosine' | 'euclidean' | 'dotproduct';
+    count: number;
+}
+interface SaveMessageToMemoryParams {
+    messages: MessageType[];
+    agentId: string;
+}
+type SaveMessageToMemoryResponse = MessageType[];
+interface CreateMemoryThreadParams {
+    title: string;
+    metadata: Record<string, any>;
+    resourceid: string;
+    threadId: string;
+    agentId: string;
+}
+type CreateMemoryThreadResponse = StorageThreadType;
+interface GetMemoryThreadParams {
+    resourceId: string;
+    agentId: string;
+}
+type GetMemoryThreadResponse = StorageThreadType[];
+interface UpdateMemoryThreadParams {
+    title: string;
+    metadata: Record<string, any>;
+    resourceid: string;
+}
+interface GetMemoryThreadMessagesResponse {
+    messages: CoreMessage[];
+    uiMessages: AiMessageType[];
+}
+interface GetLogsParams {
+    transportId: string;
+}
+interface GetLogParams {
+    runId: string;
+    transportId: string;
+}
+type GetLogsResponse = BaseLogMessage[];
+type RequestFunction = (path: string, options?: RequestOptions) => Promise<any>;
+interface GetTelemetryResponse {
+    traces: any[];
+}
+interface GetTelemetryParams {
+    name?: string;
+    scope?: string;
+    page?: number;
+    perPage?: number;
+    attribute?: Record<string, string>;
+}
+
+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(options: ClientOptions, agentId: string);
+    /**
+     * Retrieves details about the agent
+     * @returns Promise containing agent details including model and instructions
+     */
+    details(): Promise<GetAgentResponse>;
+    /**
+     * Generates a response from the agent
+     * @param params - Generation parameters including prompt
+     * @returns Promise containing the generated response
+     */
+    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 | 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
+     * @returns Promise containing tool details
+     */
+    getTool(toolId: string): Promise<GetToolResponse>;
+    /**
+     * Retrieves evaluation results for the agent
+     * @returns Promise containing agent evaluations
+     */
+    evals(): Promise<GetEvalsByAgentIdResponse>;
+    /**
+     * Retrieves live evaluation results for the agent
+     * @returns Promise containing live agent evaluations
+     */
+    liveEvals(): Promise<GetEvalsByAgentIdResponse>;
+}
+
+declare class MemoryThread extends BaseResource {
+    private threadId;
+    private agentId;
+    constructor(options: ClientOptions, threadId: string, agentId: string);
+    /**
+     * Retrieves the memory thread details
+     * @returns Promise containing thread details including title and metadata
+     */
+    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>;
+    /**
+     * Deletes the memory thread
+     * @returns Promise containing deletion result
+     */
+    delete(): Promise<{
+        result: string;
+    }>;
+    /**
+     * Retrieves messages associated with the thread
+     * @returns Promise containing thread messages and UI messages
+     */
+    getMessages(): Promise<GetMemoryThreadMessagesResponse>;
+}
+
+declare class Vector extends BaseResource {
+    private vectorName;
+    constructor(options: ClientOptions, vectorName: string);
+    /**
+     * 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>;
+    /**
+     * Deletes a vector index
+     * @param indexName - Name of the index to delete
+     * @returns Promise indicating deletion success
+     */
+    delete(indexName: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Retrieves a list of all available indexes
+     * @returns Promise containing array of index names
+     */
+    getIndexes(): Promise<{
+        indexes: string[];
+    }>;
+    /**
+     * 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;
+    }>;
+    /**
+     * 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[]>;
+    /**
+     * 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>;
+}
+
+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>>;
+    /**
+     * 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>>;
+    /**
+     * Watches workflow transitions in real-time
+     * @returns Promise containing the workflow watch stream
+     */
+    watch(): Promise<Response>;
+}
+
+declare class Tool extends BaseResource {
+    private toolId;
+    constructor(options: ClientOptions, 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: {
+        data: any;
+    }): Promise<any>;
+}
+
+declare class MastraClient extends BaseResource {
+    constructor(options: ClientOptions);
+    /**
+     * Retrieves all available agents
+     * @returns Promise containing map of agent IDs to agent details
+     */
+    getAgents(): Promise<Record<string, GetAgentResponse>>;
+    /**
+     * Gets an agent instance by ID
+     * @param agentId - ID of the agent to retrieve
+     * @returns Agent instance
+     */
+    getAgent(agentId: string): Agent;
+    /**
+     * Retrieves memory threads for a resource
+     * @param params - Parameters containing the resource ID
+     * @returns Promise containing array of memory threads
+     */
+    getMemoryThreads(params: GetMemoryThreadParams): Promise<GetMemoryThreadResponse>;
+    /**
+     * Creates a new memory thread
+     * @param params - Parameters for creating the memory thread
+     * @returns Promise containing the created memory thread
+     */
+    createMemoryThread(params: CreateMemoryThreadParams): Promise<CreateMemoryThreadResponse>;
+    /**
+     * Gets a memory thread instance by ID
+     * @param threadId - ID of the memory thread to retrieve
+     * @returns MemoryThread instance
+     */
+    getMemoryThread(threadId: string, agentId: string): MemoryThread;
+    /**
+     * Saves messages to memory
+     * @param params - Parameters containing messages to save
+     * @returns Promise containing the saved messages
+     */
+    saveMessageToMemory(params: SaveMessageToMemoryParams): Promise<SaveMessageToMemoryResponse>;
+    /**
+     * Gets the status of the memory system
+     * @returns Promise containing memory system status
+     */
+    getMemoryStatus(agentId: string): Promise<{
+        result: boolean;
+    }>;
+    /**
+     * Retrieves all available tools
+     * @returns Promise containing map of tool IDs to tool details
+     */
+    getTools(): Promise<Record<string, GetToolResponse>>;
+    /**
+     * Gets a tool instance by ID
+     * @param toolId - ID of the tool to retrieve
+     * @returns Tool instance
+     */
+    getTool(toolId: string): Tool;
+    /**
+     * Retrieves all available workflows
+     * @returns Promise containing map of workflow IDs to workflow details
+     */
+    getWorkflows(): Promise<Record<string, GetWorkflowResponse>>;
+    /**
+     * Gets a workflow instance by ID
+     * @param workflowId - ID of the workflow to retrieve
+     * @returns Workflow instance
+     */
+    getWorkflow(workflowId: string): Workflow;
+    /**
+     * Gets a vector instance by name
+     * @param vectorName - Name of the vector to retrieve
+     * @returns Vector instance
+     */
+    getVector(vectorName: string): Vector;
+    /**
+     * Retrieves logs
+     * @param params - Parameters for filtering logs
+     * @returns Promise containing array of log messages
+     */
+    getLogs(params: GetLogsParams): Promise<GetLogsResponse>;
+    /**
+     * Gets logs for a specific run
+     * @param params - Parameters containing run ID to retrieve
+     * @returns Promise containing array of log messages
+     */
+    getLogForRun(params: GetLogParams): Promise<GetLogsResponse>;
+    /**
+     * List of all log transports
+     * @returns Promise containing list of log transports
+     */
+    getLogTransports(): Promise<{
+        transports: string[];
+    }>;
+    /**
+     * List of all traces (paged)
+     * @param params - Parameters for filtering traces
+     * @returns Promise containing telemetry data
+     */
+    getTelemetry(params?: GetTelemetryParams): Promise<GetTelemetryResponse>;
+}
+
+export { type ClientOptions, type CreateIndexParams, type CreateMemoryThreadParams, type CreateMemoryThreadResponse, type GenerateParams, type GetAgentResponse, type GetEvalsByAgentIdResponse, type GetLogParams, type GetLogsParams, type GetLogsResponse, type GetMemoryThreadMessagesResponse, type GetMemoryThreadParams, type GetMemoryThreadResponse, type GetTelemetryParams, type GetTelemetryResponse, type GetToolResponse, type GetVectorIndexResponse, type GetWorkflowResponse, MastraClient, type QueryVectorParams, type QueryVectorResponse, type RequestFunction, type RequestOptions, type SaveMessageToMemoryParams, type SaveMessageToMemoryResponse, type StreamParams, type UpdateMemoryThreadParams, type UpsertVectorParams };

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

@@ -82,7 +82,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",
@@ -97,7 +98,8 @@ var Agent = class extends BaseResource {
   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`, {
       method: "POST",

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.1.5-alpha.1",
+  "version": "0.1.5-alpha.4",
   "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"
@@ -20,7 +25,7 @@
     "json-schema": "^0.4.0",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.24.1",
-    "@mastra/core": "^0.4.3-alpha.1"
+    "@mastra/core": "^0.4.3-alpha.4"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.26.0",
@@ -34,8 +39,8 @@
     "@internal/lint": "0.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean --treeshake",
-    "dev": "tsup src/index.ts --format esm --dts --clean --treeshake --watch",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean --treeshake",
+    "dev": "pnpm build --watch",
     "test": "vitest run"
   }
 }

package/src/resources/agent.ts

@@ -63,6 +63,10 @@ export class Agent extends BaseResource {
     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/agents/${this.agentId}/generate`, {
@@ -80,6 +84,10 @@ export class Agent extends BaseResource {
     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/agents/${this.agentId}/stream`, {

package/src/types.ts

@@ -9,6 +9,8 @@ import type {
   BaseLogMessage,
   OutputType,
 } from '@mastra/core';
+
+import type { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
 
@@ -37,21 +39,16 @@ export interface GetAgentResponse {
   instructions: string;
   tools: Record<string, GetToolResponse>;
   provider: string;
+  modelId: string;
 }
 
-export interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
+export type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
   messages: string | string[] | CoreMessage[];
-  threadId?: string;
-  resourceid?: string;
-  output?: OutputType | T;
-}
+} & Partial<AgentGenerateOptions<T>>;
 
-export interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
+export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
   messages: string | string[] | CoreMessage[];
-  threadId?: string;
-  resourceid?: string;
-  output?: OutputType | T;
-}
+} & Partial<AgentStreamOptions<T>>;
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
   evals: any[];