@mastra/core 0.10.13 → 0.10.15-alpha.0

package/dist/vector/index.d.cts

@@ -0,0 +1,77 @@
+import { M as MastraBase } from '../base-B_y9sMg0.cjs';
+import { VectorFilter } from './filter/index.cjs';
+import '@opentelemetry/api';
+import '../logger-B8XXh6ya.cjs';
+import '../error/index.cjs';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+
+interface QueryResult {
+    id: string;
+    score: number;
+    metadata?: Record<string, any>;
+    vector?: number[];
+    /**
+     * The document content, if available.
+     * Note: Currently only supported by Chroma vector store.
+     * For other vector stores, documents should be stored in metadata.
+     */
+    document?: string;
+}
+interface IndexStats {
+    dimension: number;
+    count: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+interface UpsertVectorParams {
+    indexName: string;
+    vectors: number[][];
+    metadata?: Record<string, any>[];
+    ids?: string[];
+}
+interface CreateIndexParams {
+    indexName: string;
+    dimension: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+interface QueryVectorParams<Filter = VectorFilter> {
+    indexName: string;
+    queryVector: number[];
+    topK?: number;
+    filter?: Filter;
+    includeVector?: boolean;
+}
+interface DescribeIndexParams {
+    indexName: string;
+}
+interface DeleteIndexParams {
+    indexName: string;
+}
+interface UpdateVectorParams {
+    indexName: string;
+    id: string;
+    update: {
+        vector?: number[];
+        metadata?: Record<string, any>;
+    };
+}
+interface DeleteVectorParams {
+    indexName: string;
+    id: string;
+}
+
+declare abstract class MastraVector<Filter = VectorFilter> extends MastraBase {
+    constructor();
+    get indexSeparator(): string;
+    abstract query(params: QueryVectorParams<Filter>): Promise<QueryResult[]>;
+    abstract upsert(params: UpsertVectorParams): Promise<string[]>;
+    abstract createIndex(params: CreateIndexParams): Promise<void>;
+    abstract listIndexes(): Promise<string[]>;
+    abstract describeIndex(params: DescribeIndexParams): Promise<IndexStats>;
+    abstract deleteIndex(params: DeleteIndexParams): Promise<void>;
+    abstract updateVector(params: UpdateVectorParams): Promise<void>;
+    abstract deleteVector(params: DeleteVectorParams): Promise<void>;
+    protected validateExistingIndex(indexName: string, dimension: number, metric: string): Promise<void>;
+}
+
+export { type CreateIndexParams, type DeleteIndexParams, type DeleteVectorParams, type DescribeIndexParams, type IndexStats, MastraVector, type QueryResult, type QueryVectorParams, type UpdateVectorParams, type UpsertVectorParams };

package/dist/vector/index.d.ts

@@ -0,0 +1,77 @@
+import { M as MastraBase } from '../base-ClrXcCRx.js';
+import { VectorFilter } from './filter/index.js';
+import '@opentelemetry/api';
+import '../logger-Bpa2oLL4.js';
+import '../error/index.js';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+
+interface QueryResult {
+    id: string;
+    score: number;
+    metadata?: Record<string, any>;
+    vector?: number[];
+    /**
+     * The document content, if available.
+     * Note: Currently only supported by Chroma vector store.
+     * For other vector stores, documents should be stored in metadata.
+     */
+    document?: string;
+}
+interface IndexStats {
+    dimension: number;
+    count: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+interface UpsertVectorParams {
+    indexName: string;
+    vectors: number[][];
+    metadata?: Record<string, any>[];
+    ids?: string[];
+}
+interface CreateIndexParams {
+    indexName: string;
+    dimension: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+interface QueryVectorParams<Filter = VectorFilter> {
+    indexName: string;
+    queryVector: number[];
+    topK?: number;
+    filter?: Filter;
+    includeVector?: boolean;
+}
+interface DescribeIndexParams {
+    indexName: string;
+}
+interface DeleteIndexParams {
+    indexName: string;
+}
+interface UpdateVectorParams {
+    indexName: string;
+    id: string;
+    update: {
+        vector?: number[];
+        metadata?: Record<string, any>;
+    };
+}
+interface DeleteVectorParams {
+    indexName: string;
+    id: string;
+}
+
+declare abstract class MastraVector<Filter = VectorFilter> extends MastraBase {
+    constructor();
+    get indexSeparator(): string;
+    abstract query(params: QueryVectorParams<Filter>): Promise<QueryResult[]>;
+    abstract upsert(params: UpsertVectorParams): Promise<string[]>;
+    abstract createIndex(params: CreateIndexParams): Promise<void>;
+    abstract listIndexes(): Promise<string[]>;
+    abstract describeIndex(params: DescribeIndexParams): Promise<IndexStats>;
+    abstract deleteIndex(params: DeleteIndexParams): Promise<void>;
+    abstract updateVector(params: UpdateVectorParams): Promise<void>;
+    abstract deleteVector(params: DeleteVectorParams): Promise<void>;
+    protected validateExistingIndex(indexName: string, dimension: number, metric: string): Promise<void>;
+}
+
+export { type CreateIndexParams, type DeleteIndexParams, type DeleteVectorParams, type DescribeIndexParams, type IndexStats, MastraVector, type QueryResult, type QueryVectorParams, type UpdateVectorParams, type UpsertVectorParams };

package/dist/vector/index.js

@@ -0,0 +1 @@
+export { MastraVector } from '../chunk-V5D2LIF5.js';

package/dist/voice/index.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunkZPOUMTTH_cjs = require('../chunk-ZPOUMTTH.cjs');
+
+
+
+Object.defineProperty(exports, "CompositeVoice", {
+  enumerable: true,
+  get: function () { return chunkZPOUMTTH_cjs.CompositeVoice; }
+});
+Object.defineProperty(exports, "DefaultVoice", {
+  enumerable: true,
+  get: function () { return chunkZPOUMTTH_cjs.DefaultVoice; }
+});
+Object.defineProperty(exports, "MastraVoice", {
+  enumerable: true,
+  get: function () { return chunkZPOUMTTH_cjs.MastraVoice; }
+});

package/dist/voice/index.d.cts

@@ -0,0 +1,29 @@
+export { bL as CompositeVoice, bM as DefaultVoice, bK as MastraVoice, bJ as VoiceConfig, bI as VoiceEventMap, bH as VoiceEventType } from '../base-CTj7ESwt.cjs';
+import 'ai';
+import '../base-B_y9sMg0.cjs';
+import '@opentelemetry/api';
+import '../logger-B8XXh6ya.cjs';
+import '../error/index.cjs';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+import 'json-schema';
+import 'zod';
+import '../types-Bo1uigWx.cjs';
+import 'sift';
+import '../runtime-context/index.cjs';
+import 'xstate';
+import 'node:events';
+import '../vector/index.cjs';
+import '../vector/filter/index.cjs';
+import '../tts/index.cjs';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import '../workflows/constants.cjs';
+import 'ai/test';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
+import 'hono/cors';
+import 'hono-openapi';

package/dist/voice/index.d.ts

@@ -0,0 +1,29 @@
+export { bL as CompositeVoice, bM as DefaultVoice, bK as MastraVoice, bJ as VoiceConfig, bI as VoiceEventMap, bH as VoiceEventType } from '../base-qVqAnB-c.js';
+import 'ai';
+import '../base-ClrXcCRx.js';
+import '@opentelemetry/api';
+import '../logger-Bpa2oLL4.js';
+import '../error/index.js';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+import 'json-schema';
+import 'zod';
+import '../types-Bo1uigWx.js';
+import 'sift';
+import '../runtime-context/index.js';
+import 'xstate';
+import 'node:events';
+import '../vector/index.js';
+import '../vector/filter/index.js';
+import '../tts/index.js';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import '../workflows/constants.js';
+import 'ai/test';
+import '../deployer/index.js';
+import '../bundler/index.js';
+import 'hono/cors';
+import 'hono-openapi';

package/dist/voice/index.js

@@ -0,0 +1 @@
+export { CompositeVoice, DefaultVoice, MastraVoice } from '../chunk-5HTMDAXP.js';

package/dist/workflows/constants.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkBB6DPGIV_cjs = require('../chunk-BB6DPGIV.cjs');
+
+
+
+Object.defineProperty(exports, "EMITTER_SYMBOL", {
+  enumerable: true,
+  get: function () { return chunkBB6DPGIV_cjs.EMITTER_SYMBOL; }
+});

package/dist/workflows/constants.d.cts

@@ -0,0 +1,3 @@
+declare const EMITTER_SYMBOL: unique symbol;
+
+export { EMITTER_SYMBOL };

package/dist/workflows/constants.d.ts

@@ -0,0 +1,3 @@
+declare const EMITTER_SYMBOL: unique symbol;
+
+export { EMITTER_SYMBOL };

package/dist/workflows/constants.js

@@ -0,0 +1 @@
+export { EMITTER_SYMBOL } from '../chunk-Y7D2JLKS.js';

package/dist/workflows/index.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var chunkZCU3PLIL_cjs = require('../chunk-ZCU3PLIL.cjs');
+
+
+
+Object.defineProperty(exports, "DefaultExecutionEngine", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.DefaultExecutionEngine; }
+});
+Object.defineProperty(exports, "ExecutionEngine", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.ExecutionEngine; }
+});
+Object.defineProperty(exports, "Run", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.Run; }
+});
+Object.defineProperty(exports, "Workflow", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.Workflow; }
+});
+Object.defineProperty(exports, "cloneStep", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.cloneStep; }
+});
+Object.defineProperty(exports, "cloneWorkflow", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.cloneWorkflow; }
+});
+Object.defineProperty(exports, "createStep", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.createStep; }
+});
+Object.defineProperty(exports, "createWorkflow", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.createWorkflow; }
+});
+Object.defineProperty(exports, "mapVariable", {
+  enumerable: true,
+  get: function () { return chunkZCU3PLIL_cjs.mapVariable; }
+});

package/dist/workflows/index.d.cts

@@ -0,0 +1,285 @@
+import { bm as ExecutionEngine, f as Step, bo as Emitter, bu as StepResult, bl as ExecutionGraph, bc as SerializedStepFlowEntry, ba as StepFlowEntry, bn as ExecuteFunction, aw as DefaultEngineType } from '../base-CTj7ESwt.cjs';
+export { bw as DynamicMapping, bz as ExtractSchemaFromStep, by as ExtractSchemaType, bx as PathsToStringProps, bk as Run, bb as SerializedStep, bq as StepFailure, bs as StepRunning, bp as StepSuccess, br as StepSuspended, bt as StepWaiting, bd as StepWithComponent, bv as StepsRecord, bB as StreamEvent, bA as VariableReference, bD as WatchEvent, e as Workflow, ax as WorkflowConfig, bj as WorkflowResult, bF as WorkflowRunState, bC as WorkflowRunStatus, bE as ZodPathType, bg as cloneStep, bi as cloneWorkflow, bf as createStep, bh as createWorkflow, be as mapVariable } from '../base-CTj7ESwt.cjs';
+import { Span } from '@opentelemetry/api';
+import { RuntimeContext } from '../runtime-context/index.cjs';
+import 'ai';
+import '../base-B_y9sMg0.cjs';
+import '../logger-B8XXh6ya.cjs';
+import '../error/index.cjs';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+import 'json-schema';
+import 'zod';
+import '../types-Bo1uigWx.cjs';
+import 'sift';
+import 'xstate';
+import 'node:events';
+import '../vector/index.cjs';
+import '../vector/filter/index.cjs';
+import '../tts/index.cjs';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import './constants.cjs';
+import 'ai/test';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
+import 'hono/cors';
+import 'hono-openapi';
+
+type ExecutionContext = {
+    workflowId: string;
+    runId: string;
+    executionPath: number[];
+    suspendedPaths: Record<string, number[]>;
+    retryConfig: {
+        attempts: number;
+        delay: number;
+    };
+    executionSpan: Span;
+};
+/**
+ * Default implementation of the ExecutionEngine using XState
+ */
+declare class DefaultExecutionEngine extends ExecutionEngine {
+    /**
+     * The runCounts map is used to keep track of the run count for each step.
+     * The step id is used as the key and the run count is the value.
+     */
+    protected runCounts: Map<string, number>;
+    /**
+     * Get or generate the run count for a step.
+     * If the step id is not in the map, it will be added and the run count will be 0.
+     * If the step id is in the map, it will return the run count.
+     *
+     * @param stepId - The id of the step.
+     * @returns The run count for the step.
+     */
+    protected getOrGenerateRunCount(stepId: Step['id']): number;
+    protected runtimeContext: Record<string, any>;
+    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: Emitter, stepResults: Record<string, StepResult<any, any, any, any>>, lastOutput: StepResult<any, any, any, any>, error?: Error | string): Promise<TOutput>;
+    /**
+     * Executes a workflow run with the provided execution graph and input
+     * @param graph The execution graph to execute
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+            snapshotRuntimeContext?: Record<string, any>;
+        };
+        emitter: Emitter;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+        abortController: AbortController;
+    }): Promise<TOutput>;
+    getStepOutput(stepResults: Record<string, any>, step?: StepFlowEntry): any;
+    executeSleep({ runId, entry, prevOutput, stepResults, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        entry: {
+            type: 'sleep';
+            id: string;
+            duration?: number;
+            fn?: ExecuteFunction<any, any, any, any, DefaultEngineType>;
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<void>;
+    executeSleepUntil({ runId, entry, prevOutput, stepResults, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        entry: {
+            type: 'sleepUntil';
+            id: string;
+            date?: Date;
+            fn?: ExecuteFunction<any, any, any, any, DefaultEngineType>;
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<void>;
+    executeWaitForEvent({ event, emitter, timeout, }: {
+        event: string;
+        emitter: Emitter;
+        timeout?: number;
+    }): Promise<any>;
+    executeStep({ workflowId, runId, step, stepResults, executionContext, resume, prevOutput, emitter, abortController, runtimeContext, skipEmits, }: {
+        workflowId: string;
+        runId: string;
+        step: Step<string, any, any>;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        executionContext: ExecutionContext;
+        resume?: {
+            steps: string[];
+            resumePayload: any;
+        };
+        prevOutput: any;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+        skipEmits?: boolean;
+    }): Promise<StepResult<any, any, any, any>>;
+    executeParallel({ workflowId, runId, entry, prevStep, serializedStepGraph, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'parallel';
+            steps: StepFlowEntry[];
+        };
+        serializedStepGraph: SerializedStepFlowEntry[];
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, serializedStepGraph, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        entry: {
+            type: 'conditional';
+            steps: StepFlowEntry[];
+            conditions: ExecuteFunction<any, any, any, any, DefaultEngineType>[];
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    executeLoop({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'loop';
+            step: Step;
+            condition: ExecuteFunction<any, any, any, any, DefaultEngineType>;
+            loopType: 'dowhile' | 'dountil';
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    executeForeach({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'foreach';
+            step: Step;
+            opts: {
+                concurrency: number;
+            };
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    protected persistStepUpdate({ workflowId, runId, stepResults, serializedStepGraph, executionContext, workflowStatus, result, error, }: {
+        workflowId: string;
+        runId: string;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        executionContext: ExecutionContext;
+        workflowStatus: 'success' | 'failed' | 'suspended' | 'running' | 'waiting';
+        result?: Record<string, any>;
+        error?: string | Error;
+    }): Promise<void>;
+    executeEntry({ workflowId, runId, entry, prevStep, serializedStepGraph, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: StepFlowEntry;
+        prevStep: StepFlowEntry;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<{
+        result: StepResult<any, any, any, any>;
+        stepResults?: Record<string, StepResult<any, any, any, any>>;
+        executionContext?: ExecutionContext;
+    }>;
+}
+
+export { DefaultEngineType, DefaultExecutionEngine, Emitter, ExecuteFunction, type ExecutionContext, ExecutionEngine, ExecutionGraph, SerializedStepFlowEntry, Step, StepFlowEntry, StepResult };