@mastra/client-js 0.1.0-alpha.9 → 0.1.1

package/src/resources/vector.ts

@@ -1,82 +1,83 @@
 import type {
-    CreateIndexParams,
-    GetVectorIndexResponse,
-    QueryVectorParams,
-    QueryVectorResponse,
-    ClientOptions,
-    UpsertVectorParams,
+  CreateIndexParams,
+  GetVectorIndexResponse,
+  QueryVectorParams,
+  QueryVectorResponse,
+  ClientOptions,
+  UpsertVectorParams,
 } from '../types';
+
 import { BaseResource } from './base';
 
 export class Vector extends BaseResource {
-    constructor(
-        options: ClientOptions,
-        private vectorName: string
-    ) {
-        super(options);
-    }
+  constructor(
+    options: ClientOptions,
+    private vectorName: string,
+  ) {
+    super(options);
+  }
 
-    /**
-     * 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> {
-        return this.request(`/api/vector/${this.vectorName}/indexes/${indexName}`);
-    }
+  /**
+   * 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> {
+    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: string): Promise<{ success: boolean }> {
-        return this.request(`/api/vector/${this.vectorName}/indexes/${indexName}`, {
-            method: 'DELETE'
-        });
-    }
+  /**
+   * Deletes a vector index
+   * @param indexName - Name of the index to delete
+   * @returns Promise indicating deletion success
+   */
+  delete(indexName: string): Promise<{ success: boolean }> {
+    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(): Promise<{ indexes: string[] }> {
-        return this.request(`/api/vector/${this.vectorName}/indexes`);
-    }
+  /**
+   * Retrieves a list of all available indexes
+   * @returns Promise containing array of index names
+   */
+  getIndexes(): Promise<{ indexes: string[] }> {
+    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: CreateIndexParams): Promise<{ success: boolean }> {
-        return this.request(`/api/vector/${this.vectorName}/create-index`, {
-            method: 'POST',
-            body: params
-        });
-    }
+  /**
+   * 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 }> {
+    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: UpsertVectorParams): Promise<string[]> {
-        return this.request(`/api/vector/${this.vectorName}/upsert`, {
-            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: UpsertVectorParams): Promise<string[]> {
+    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: QueryVectorParams): Promise<QueryVectorResponse> {
-        return this.request(`/api/vector/${this.vectorName}/query`, {
-            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: QueryVectorParams): Promise<QueryVectorResponse> {
+    return this.request(`/api/vector/${this.vectorName}/query`, {
+      method: 'POST',
+      body: params,
+    });
+  }
+}

package/src/resources/workflow.ts

@@ -1,31 +1,68 @@
 import type { GetWorkflowResponse, ClientOptions } from '../types';
+
 import { BaseResource } from './base';
 
 export class Workflow extends BaseResource {
-    constructor(
-        options: ClientOptions,
-        private workflowId: string
-    ) {
-        super(options);
-    }
+  constructor(
+    options: ClientOptions,
+    private workflowId: string,
+  ) {
+    super(options);
+  }
+
+  /**
+   * Retrieves details about the workflow
+   * @returns Promise containing workflow details including steps and graphs
+   */
+  details(): Promise<GetWorkflowResponse> {
+    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: Record<string, any>): Promise<Record<string, any>> {
+    return this.request(`/api/workflows/${this.workflowId}/execute`, {
+      method: 'POST',
+      body: params,
+    });
+  }
 
-    /**
-     * Retrieves details about the workflow
-     * @returns Promise containing workflow details including steps and graphs
-     */
-    details(): Promise<GetWorkflowResponse> {
-        return this.request(`/api/workflows/${this.workflowId}`);
-    }
+  /**
+   * 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>> {
+    return this.request(`/api/workflows/${this.workflowId}/resume`, {
+      method: 'POST',
+      body: {
+        stepId,
+        runId,
+        context,
+      },
+    });
+  }
 
-    /**
-     * 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>> {
-        return this.request(`/api/workflows/${this.workflowId}/execute`, {
-            method: 'POST',
-            body: params,
-        });
-    }
-}
+  /**
+   * Watches workflow transitions in real-time
+   * @returns Promise containing the workflow watch stream
+   */
+  watch(): Promise<Response> {
+    return this.request(`/api/workflows/${this.workflowId}/watch`, {
+      stream: true,
+    });
+  }
+}

package/src/types.ts

@@ -1,142 +1,163 @@
-import type { MessageType, AiMessageType, CoreMessage, QueryResult, StepAction, StepGraph, StorageThreadType, BaseLogMessage, OutputType } from "@mastra/core";
+import type {
+  MessageType,
+  AiMessageType,
+  CoreMessage,
+  QueryResult,
+  StepAction,
+  StepGraph,
+  StorageThreadType,
+  BaseLogMessage,
+  OutputType,
+} from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
-import { ZodSchema } from "zod";
+import { ZodSchema } from 'zod';
 
 export interface ClientOptions {
-    /** Base URL for API requests */
-    baseUrl: string;
-    /** Number of retry attempts for failed requests */
-    retries?: number;
-    /** Initial backoff time in milliseconds between retries */
-    backoffMs?: number;
-    /** Maximum backoff time in milliseconds between retries */
-    maxBackoffMs?: number;
-    /** Custom headers to include with requests */
-    headers?: Record<string, string>;
+  /** 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>;
 }
 
 export interface RequestOptions {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: any;
-    stream?: boolean;
+  method?: string;
+  headers?: Record<string, string>;
+  body?: any;
+  stream?: boolean;
 }
 
 export interface GetAgentResponse {
-    name: string;
-    model: string;
-    instructions: string;
-    tools: Record<string, GetToolResponse>;
+  name: string;
+  instructions: string;
+  tools: Record<string, GetToolResponse>;
+  provider: string;
 }
 
 export interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-    messages: MessageType[];
-    threadId?: string;
-    resourceid?: string;
-    output?: OutputType | T
+  messages: string | string[] | CoreMessage[];
+  threadId?: string;
+  resourceid?: string;
+  output?: OutputType | T;
 }
 
 export interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-    messages: MessageType[];
-    threadId?: string;
-    resourceid?: string;
-    output?: OutputType | T
+  messages: string | string[] | CoreMessage[];
+  threadId?: string;
+  resourceid?: string;
+  output?: OutputType | T;
 }
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
-    evals: any[];
+  evals: any[];
 }
 
 export interface GetToolResponse {
-    id: string;
-    description: string;
-    inputSchema: string;
-    outputSchema: string;
+  id: string;
+  description: string;
+  inputSchema: string;
+  outputSchema: string;
 }
 
 export interface GetWorkflowResponse {
-    name: string;
-    triggerSchema: string;
-    steps: Record<string, StepAction<any, any, any, any>>;
-    stepGraph: StepGraph
-    stepSubscriberGraph: Record<string, StepGraph>
+  name: string;
+  triggerSchema: string;
+  steps: Record<string, StepAction<any, any, any, any>>;
+  stepGraph: StepGraph;
+  stepSubscriberGraph: Record<string, StepGraph>;
 }
 
 export interface UpsertVectorParams {
-    indexName: string;
-    vectors: number[][];
-    metadata?: Record<string, any>[];
-    ids?: string[];
+  indexName: string;
+  vectors: number[][];
+  metadata?: Record<string, any>[];
+  ids?: string[];
 }
 export interface CreateIndexParams {
-    indexName: string;
-    dimension: number;
-    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+  indexName: string;
+  dimension: number;
+  metric?: 'cosine' | 'euclidean' | 'dotproduct';
 }
 
 export interface QueryVectorParams {
-    indexName: string;
-    queryVector: number[];
-    topK?: number;
-    filter?: Record<string, any>;
-    includeVector?: boolean;
+  indexName: string;
+  queryVector: number[];
+  topK?: number;
+  filter?: Record<string, any>;
+  includeVector?: boolean;
 }
 
 export interface QueryVectorResponse {
-    results: QueryResult[];
+  results: QueryResult[];
 }
 
 export interface GetVectorIndexResponse {
-    dimension: number;
-    metric: 'cosine' | 'euclidean' | 'dotproduct';
-    count: number;
+  dimension: number;
+  metric: 'cosine' | 'euclidean' | 'dotproduct';
+  count: number;
 }
 
 export interface SaveMessageToMemoryParams {
-    messages: MessageType[];
+  messages: MessageType[];
+  agentId: string;
 }
 
-export type SaveMessageToMemoryResponse = MessageType[]
+export type SaveMessageToMemoryResponse = MessageType[];
 
 export interface CreateMemoryThreadParams {
-    title: string;
-    metadata: Record<string, any>;
-    resourceid: string;
-    threadId: string;
+  title: string;
+  metadata: Record<string, any>;
+  resourceid: string;
+  threadId: string;
+  agentId: string;
 }
 
-export type CreateMemoryThreadResponse = StorageThreadType
+export type CreateMemoryThreadResponse = StorageThreadType;
 
 export interface GetMemoryThreadParams {
-    resourceId: string;
+  resourceId: string;
+  agentId: string;
 }
 
-export type GetMemoryThreadResponse = StorageThreadType[]
+export type GetMemoryThreadResponse = StorageThreadType[];
 
 export interface UpdateMemoryThreadParams {
-    title: string;
-    metadata: Record<string, any>;
-    resourceid: string;
+  title: string;
+  metadata: Record<string, any>;
+  resourceid: string;
 }
 
-
 export interface GetMemoryThreadMessagesResponse {
-    messages: CoreMessage[];
-    uiMessages: AiMessageType[];
+  messages: CoreMessage[];
+  uiMessages: AiMessageType[];
 }
 
 export interface GetLogsParams {
-    transportId: string;
+  transportId: string;
 }
 
 export interface GetLogParams {
-    runId: string;
-    transportId: string;
+  runId: string;
+  transportId: string;
 }
 
-export type GetLogsResponse = BaseLogMessage[]
+export type GetLogsResponse = BaseLogMessage[];
+
+export type RequestFunction = (path: string, options?: RequestOptions) => Promise<any>;
 
-export type RequestFunction = (
-    path: string,
-    options?: RequestOptions
-) => Promise<any>;
+export interface GetTelemetryResponse {
+  traces: any[];
+}
+
+export interface GetTelemetryParams {
+  name?: string;
+  scope?: string;
+  page?: number;
+  perPage?: number;
+  attribute?: Record<string, string>;
+}

package/tsconfig.json

@@ -1,29 +1,5 @@
 {
-    "$schema": "https://json.schemastore.org/tsconfig",
-    "compilerOptions": {
-        /* Base Options: */
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "target": "es2022",
-        "allowJs": true,
-        "resolveJsonModule": true,
-        "moduleDetection": "force",
-        "isolatedModules": true,
-        "verbatimModuleSyntax": true,
-        /* Strictness */
-        "strict": true,
-        "noUncheckedIndexedAccess": true,
-        // "noImplicitOverride": true,
-        /* AND if you're building for a library in a monorepo: */
-        // "composite": true,
-        "declaration": true,
-        "declarationMap": true,
-        /* If NOT transpiling with TypeScript: */
-        "module": "Preserve",
-        "noEmit": true,
-        /* If your code doesn't run in the DOM: */
-        "lib": [
-            "es2022"
-        ]
-    }
-}
+  "extends": "../../tsconfig.node.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}

package/.eslintrc.js

@@ -1,10 +0,0 @@
-module.exports = {
-  parser: '@typescript-eslint/parser',
-  plugins: ['@typescript-eslint', 'unused-imports', 'prettier'],
-  rules: {
-    'no-unused-vars': 'off',
-    'prettier/prettier': 'error',
-    'unused-imports/no-unused-imports': 'error',
-  },
-  root: true,
-};

package/.prettierignore

@@ -1,3 +0,0 @@
-
-/node_modules
-/dist

package/.prettierrc.json

@@ -1,26 +0,0 @@
-{
-  "endOfLine": "lf",
-  "semi": true,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "useTabs": false,
-  "trailingComma": "all",
-  "bracketSpacing": true,
-  "printWidth": 120,
-  "arrowParens": "avoid",
-  "importOrder": [
-    "<THIRD_PARTY_MODULES>",
-    "^next\\/(.*)$",
-    "^@\\/components/(.*)$",
-    "^@\\/icons/(.*)$",
-    "^@\\/lib/(.*)$",
-    "^@\\/(.*)$",
-    "^[\\w\\d-_]+\\/(.*)$",
-    "^\\.\\.\\/(.*)$",
-    "^\\.\\/(.*)$",
-    "^[./]"
-  ],
-  "importOrderSeparation": true,
-  "importOrderParserPlugins": ["jsx", "typescript", "classProperties", "decorators-legacy"],
-  "plugins": ["@trivago/prettier-plugin-sort-imports"]
-}