@mastra/client-js 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/index.d.mts

@@ -0,0 +1,346 @@
+import { StorageThreadType, CoreMessage, AiMessageType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn, StreamReturn } from '@mastra/core';
+import { StorageThreadType as StorageThreadType$1 } from '@mastra/core/memory';
+
+interface ClientOptions {
+    baseUrl: string;
+    retries?: number;
+    backoffMs?: number;
+    maxBackoffMs?: number;
+    headers?: Record<string, string>;
+}
+interface RequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+}
+interface GetAgentResponse {
+    name: string;
+    model: string;
+    instructions: string;
+    tools: Record<string, GetToolResponse>;
+}
+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[];
+}
+type SaveMessageToMemoryResponse = MessageType[];
+interface CreateMemoryThreadParams {
+    title: string;
+    metadata: Record<string, any>;
+    resourceid: string;
+    threadId: string;
+}
+type CreateMemoryThreadResponse = StorageThreadType;
+interface GetMemoryThreadParams {
+    resourceId: 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>;
+
+declare class Agent {
+    private request;
+    private agentId;
+    constructor(request: RequestFunction, 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>(params: any): Promise<GenerateReturn<T>>;
+    /**
+     * Streams a response from the agent
+     * @param params - Stream parameters including prompt
+     * @returns Promise containing the streamed response
+     */
+    stream<T>(params: any): Promise<StreamReturn<T>>;
+    /**
+     * 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 {
+    private request;
+    private threadId;
+    constructor(request: RequestFunction, threadId: string);
+    /**
+     * Retrieves the memory thread details
+     * @returns Promise containing thread details including title and metadata
+     */
+    get(): Promise<StorageThreadType$1>;
+    /**
+     * Updates the memory thread properties
+     * @param params - Update parameters including title and metadata
+     * @returns Promise containing updated thread details
+     */
+    update(params: UpdateMemoryThreadParams): Promise<StorageThreadType$1>;
+    /**
+     * 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 Tool {
+    private request;
+    private toolId;
+    constructor(request: RequestFunction, 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: Record<string, any>): Promise<Record<string, any>>;
+}
+
+declare class Workflow {
+    private request;
+    private workflowId;
+    constructor(request: RequestFunction, 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>>;
+}
+
+declare class Vector {
+    private request;
+    private vectorName;
+    constructor(request: RequestFunction, 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 MastraClient {
+    readonly baseUrl: string;
+    private readonly retries;
+    private readonly backoffMs;
+    private readonly maxBackoffMs;
+    private readonly headers;
+    constructor(options: ClientOptions);
+    /**
+     * Makes an HTTP request to the Mastra API
+     * @param path - API endpoint path
+     * @param options - Request options including method, headers, and body
+     * @returns Promise containing the API response
+     * @throws Error if the request fails after all retries
+     */
+    request(path: string, options?: RequestOptions): Promise<any>;
+    /**
+     * 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): 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(): 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>;
+}
+
+export { type ClientOptions, type CreateIndexParams, type CreateMemoryThreadParams, type CreateMemoryThreadResponse, type GetAgentResponse, type GetEvalsByAgentIdResponse, type GetLogParams, type GetLogsParams, type GetLogsResponse, type GetMemoryThreadMessagesResponse, type GetMemoryThreadParams, type GetMemoryThreadResponse, type GetToolResponse, type GetVectorIndexResponse, type GetWorkflowResponse, MastraClient, type QueryVectorParams, type QueryVectorResponse, type RequestFunction, type RequestOptions, type SaveMessageToMemoryParams, type SaveMessageToMemoryResponse, type UpdateMemoryThreadParams, type UpsertVectorParams };