@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-stream-vnext-usage-20250908171242

package/src/resources/agent.ts

@@ -1,116 +0,0 @@
-import type { GenerateReturn, StreamReturn } from '@mastra/core';
-import type { JSONSchema7 } from 'json-schema';
-import { ZodSchema } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-
-import type {
-  GenerateParams,
-  GetAgentResponse,
-  GetEvalsByAgentIdResponse,
-  GetToolResponse,
-  ClientOptions,
-  StreamParams,
-} from '../types';
-
-import { BaseResource } from './base';
-
-export class AgentTool extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private agentId: string,
-    private toolId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Executes a specific tool for an agent
-   * @param params - Parameters required for tool execution
-   * @returns Promise containing tool execution results
-   */
-  execute(params: { data: any }): Promise<any> {
-    return this.request(`/api/agents/${this.agentId}/tools/${this.toolId}/execute`, {
-      method: 'POST',
-      body: params,
-    });
-  }
-}
-
-export class Agent extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private agentId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves details about the agent
-   * @returns Promise containing agent details including model and instructions
-   */
-  details(): Promise<GetAgentResponse> {
-    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<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T>,
-  ): Promise<GenerateReturn<T>> {
-    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<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response> {
-    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: string): Promise<GetToolResponse> {
-    return this.request(`/api/agents/${this.agentId}/tools/${toolId}`);
-  }
-
-  /**
-   * Retrieves evaluation results for the agent
-   * @returns Promise containing agent evaluations
-   */
-  evals(): Promise<GetEvalsByAgentIdResponse> {
-    return this.request(`/api/agents/${this.agentId}/evals/ci`);
-  }
-
-  /**
-   * Retrieves live evaluation results for the agent
-   * @returns Promise containing live agent evaluations
-   */
-  liveEvals(): Promise<GetEvalsByAgentIdResponse> {
-    return this.request(`/api/agents/${this.agentId}/evals/live`);
-  }
-}

package/src/resources/base.ts

@@ -1,68 +0,0 @@
-import type { RequestFunction, RequestOptions, ClientOptions } from '../types';
-
-export class BaseResource {
-  readonly options: ClientOptions;
-
-  constructor(options: ClientOptions) {
-    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
-   */
-  public async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
-    let lastError: Error | null = null;
-    const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1000, 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) : undefined,
-        });
-
-        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 as unknown as T;
-        }
-
-        const data = await response.json();
-        return data as T;
-      } catch (error) {
-        lastError = error as Error;
-
-        if (attempt === retries) {
-          break;
-        }
-
-        await new Promise(resolve => setTimeout(resolve, delay));
-        delay = Math.min(delay * 2, maxBackoffMs);
-      }
-    }
-
-    throw lastError || new Error('Request failed');
-  }
-}

package/src/resources/index.ts

@@ -1,6 +0,0 @@
-export * from './agent';
-export * from './memory-thread';
-export * from './vector';
-export * from './workflow';
-export * from './tool';
-export * from './base';

package/src/resources/memory-thread.ts

@@ -1,60 +0,0 @@
-import type { StorageThreadType } from '@mastra/core';
-
-import type {
-  CreateMemoryThreadParams,
-  GetMemoryThreadMessagesResponse,
-  GetMemoryThreadResponse,
-  ClientOptions,
-  SaveMessageToMemoryParams,
-  UpdateMemoryThreadParams,
-} from '../types';
-
-import { BaseResource } from './base';
-
-export class MemoryThread extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private threadId: string,
-    private agentId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves the memory thread details
-   * @returns Promise containing thread details including title and metadata
-   */
-  get(): Promise<StorageThreadType> {
-    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: UpdateMemoryThreadParams): Promise<StorageThreadType> {
-    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(): Promise<{ result: string }> {
-    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(): Promise<GetMemoryThreadMessagesResponse> {
-    return this.request(`/api/memory/threads/${this.threadId}/messages?agentId=${this.agentId}`);
-  }
-}

package/src/resources/tool.ts

@@ -1,32 +0,0 @@
-import type { GetToolResponse, ClientOptions } from '../types';
-
-import { BaseResource } from './base';
-
-export class Tool extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private toolId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves details about the tool
-   * @returns Promise containing tool details including description and schemas
-   */
-  details(): Promise<GetToolResponse> {
-    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: { data: any }): Promise<any> {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
-      method: 'POST',
-      body: params,
-    });
-  }
-}

package/src/resources/vector.ts

@@ -1,83 +0,0 @@
-import type {
-  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);
-  }
-
-  /**
-   * 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',
-    });
-  }
-
-  /**
-   * 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,
-    });
-  }
-
-  /**
-   * 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,
-    });
-  }
-}

package/src/resources/workflow.ts

@@ -1,68 +0,0 @@
-import type { GetWorkflowResponse, ClientOptions } from '../types';
-
-import { BaseResource } from './base';
-
-export class Workflow extends BaseResource {
-  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,
-    });
-  }
-
-  /**
-   * 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,
-      },
-    });
-  }
-
-  /**
-   * 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,163 +0,0 @@
-import type {
-  MessageType,
-  AiMessageType,
-  CoreMessage,
-  QueryResult,
-  StepAction,
-  StepGraph,
-  StorageThreadType,
-  BaseLogMessage,
-  OutputType,
-} from '@mastra/core';
-import type { JSONSchema7 } from 'json-schema';
-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>;
-}
-
-export interface RequestOptions {
-  method?: string;
-  headers?: Record<string, string>;
-  body?: any;
-  stream?: boolean;
-}
-
-export interface GetAgentResponse {
-  name: string;
-  instructions: string;
-  tools: Record<string, GetToolResponse>;
-  provider: string;
-}
-
-export interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-  messages: string | string[] | CoreMessage[];
-  threadId?: string;
-  resourceid?: string;
-  output?: OutputType | T;
-}
-
-export interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-  messages: string | string[] | CoreMessage[];
-  threadId?: string;
-  resourceid?: string;
-  output?: OutputType | T;
-}
-
-export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
-  evals: any[];
-}
-
-export interface GetToolResponse {
-  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>;
-}
-
-export interface UpsertVectorParams {
-  indexName: string;
-  vectors: number[][];
-  metadata?: Record<string, any>[];
-  ids?: string[];
-}
-export interface CreateIndexParams {
-  indexName: string;
-  dimension: number;
-  metric?: 'cosine' | 'euclidean' | 'dotproduct';
-}
-
-export interface QueryVectorParams {
-  indexName: string;
-  queryVector: number[];
-  topK?: number;
-  filter?: Record<string, any>;
-  includeVector?: boolean;
-}
-
-export interface QueryVectorResponse {
-  results: QueryResult[];
-}
-
-export interface GetVectorIndexResponse {
-  dimension: number;
-  metric: 'cosine' | 'euclidean' | 'dotproduct';
-  count: number;
-}
-
-export interface SaveMessageToMemoryParams {
-  messages: MessageType[];
-  agentId: string;
-}
-
-export type SaveMessageToMemoryResponse = MessageType[];
-
-export interface CreateMemoryThreadParams {
-  title: string;
-  metadata: Record<string, any>;
-  resourceid: string;
-  threadId: string;
-  agentId: string;
-}
-
-export type CreateMemoryThreadResponse = StorageThreadType;
-
-export interface GetMemoryThreadParams {
-  resourceId: string;
-  agentId: string;
-}
-
-export type GetMemoryThreadResponse = StorageThreadType[];
-
-export interface UpdateMemoryThreadParams {
-  title: string;
-  metadata: Record<string, any>;
-  resourceid: string;
-}
-
-export interface GetMemoryThreadMessagesResponse {
-  messages: CoreMessage[];
-  uiMessages: AiMessageType[];
-}
-
-export interface GetLogsParams {
-  transportId: string;
-}
-
-export interface GetLogParams {
-  runId: string;
-  transportId: string;
-}
-
-export type GetLogsResponse = BaseLogMessage[];
-
-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,5 +0,0 @@
-{
-  "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.test.ts"]
-}

package/vitest.config.js

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-});