@mastra/playground-ui 59.0.0 → 60.0.0-alpha.1

package/dist/src/domains/workflows/components/workflow-step-detail.d.ts

@@ -0,0 +1,3 @@
+export declare function WorkflowStepDetailContent({ requestContext }: {
+    requestContext: Record<string, any>;
+}): import("react").JSX.Element | null;

package/dist/src/domains/workflows/components/workflow-tracing-run-options.d.ts

@@ -0,0 +1,14 @@
+export interface WorkflowTracingRunOptionsProps {
+    editorClassName?: string;
+    onSaved?: () => void;
+}
+/**
+ * Workflow-specific tracing run options editor.
+ *
+ * Unlike the shared inline `TracingRunOptions`, this is rendered inside a dialog and
+ * persists only on an explicit "Save" click (mirroring the Request Context dialog). The
+ * editor owns its raw text locally, so typing/backspacing never writes to tracing settings
+ * mid-edit — which previously caused per-keystroke re-renders that remounted and closed the
+ * dialog.
+ */
+export declare const WorkflowTracingRunOptions: ({ editorClassName, onSaved, }: WorkflowTracingRunOptionsProps) => import("react").JSX.Element;

package/dist/src/domains/workflows/components/workflows-list/no-workflows-info.d.ts

@@ -0,0 +1 @@
+export declare const NoWorkflowsInfo: () => import("react").JSX.Element;

package/dist/src/domains/workflows/components/workflows-list/workflows-list.d.ts

@@ -0,0 +1,12 @@
+import { GetWorkflowResponse } from '@mastra/client-js';
+import { WorkflowsSort, WorkflowsSortKey } from './workflows-sort';
+import { DataListSort } from '../../../../ds/components/DataList';
+export interface WorkflowsListProps {
+    workflows: Record<string, GetWorkflowResponse>;
+    isLoading: boolean;
+    search?: string;
+    sort?: WorkflowsSort;
+    onSortChange?: (direction: DataListSort, key: WorkflowsSortKey) => void;
+    requestContext?: Record<string, any>;
+}
+export declare function WorkflowsList({ workflows, isLoading, search, sort, onSortChange, requestContext, }: WorkflowsListProps): import("react").JSX.Element;

package/dist/src/domains/workflows/components/workflows-list/workflows-sort.d.ts

@@ -0,0 +1,12 @@
+import { GetWorkflowResponse } from '@mastra/client-js';
+import { ListSort } from '../../../../lib/sort/sort-by';
+export type WorkflowsSortKey = 'name' | 'running' | 'suspended' | 'steps';
+export type WorkflowsSort = ListSort<WorkflowsSortKey>;
+type RunCounts = Record<string, {
+    running?: number;
+    suspended?: number;
+} | undefined>;
+export declare function sortWorkflows<T extends GetWorkflowResponse & {
+    id: string;
+}>(workflows: T[], sort: WorkflowsSort, runCounts: RunCounts): T[];
+export {};

package/dist/src/domains/workflows/context/use-current-run.d.ts

@@ -0,0 +1,17 @@
+import { WorkflowRunStreamStep } from './workflow-run-context';
+export type TripwireData = {
+    reason: string;
+    retry?: boolean;
+    metadata?: unknown;
+    processorId?: string;
+};
+export type Step = Pick<WorkflowRunStreamStep, 'status' | 'error' | 'tripwire' | 'startedAt' | 'endedAt' | 'suspendedAt' | 'resumedAt' | 'output' | 'suspendOutput' | 'suspendPayload' | 'foreachProgress'> & {
+    input?: WorkflowRunStreamStep['payload'];
+    resumeData?: WorkflowRunStreamStep['resumePayload'];
+};
+type UseCurrentRunReturnType = {
+    steps: Record<string, Step>;
+    runId?: string;
+};
+export declare const useCurrentRun: () => UseCurrentRunReturnType;
+export {};

package/dist/src/domains/workflows/context/use-local-run.d.ts

@@ -0,0 +1,11 @@
+import { WorkflowRunStreamResult } from './workflow-run-context';
+export declare function useLocalRun(initialRunId: string | undefined): {
+    runId: string;
+    payload: unknown;
+    override: WorkflowRunStreamResult | null;
+    setRunId: (runId: string) => void;
+    setPayload: (payload: unknown) => void;
+    setResult: (result: WorkflowRunStreamResult | null) => void;
+    dropOverride: (runId: string) => void;
+    reset: () => void;
+};

package/dist/src/domains/workflows/context/use-persisted-workflow-run.d.ts

@@ -0,0 +1,107 @@
+export declare function usePersistedWorkflowRun(workflowId: string, runId: string, { poll }: {
+    poll: boolean;
+}): {
+    persistedRun: {
+        timestamp: number | undefined;
+        status: "running" | "waiting" | "suspended" | "success" | "failed" | "canceled" | "pending" | "bailed" | "tripwire" | "paused" | "skipped";
+        payload?: {
+            [x: string]: any;
+        } | undefined;
+        error?: {
+            [x: string]: any;
+            name: string;
+            message: string;
+            stack?: string | undefined;
+            cause?: import('@mastra/core/error').SerializedError | unknown;
+        } | undefined;
+        steps?: ({
+            [x: string]: unknown;
+        } & {
+            [x: string]: {
+                status: import('@mastra/core/workflows').WorkflowStepStatus;
+                output?: any;
+                payload?: any;
+                resumePayload?: any;
+                suspendPayload?: any;
+                suspendOutput?: any;
+                error?: {
+                    [x: string]: any;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: import('@mastra/core/error').SerializedError | unknown;
+                } | undefined;
+                startedAt?: number | undefined;
+                endedAt?: number | undefined;
+                suspendedAt?: number | undefined;
+                resumedAt?: number | undefined;
+                metadata?: {
+                    [x: string]: any;
+                } | undefined;
+            } | {
+                status: import('@mastra/core/workflows').WorkflowStepStatus;
+                output?: any;
+                payload?: any;
+                resumePayload?: any;
+                suspendPayload?: any;
+                suspendOutput?: any;
+                error?: {
+                    [x: string]: any;
+                    name: string;
+                    message: string;
+                    stack?: string | undefined;
+                    cause?: import('@mastra/core/error').SerializedError | unknown;
+                } | undefined;
+                startedAt?: number | undefined;
+                endedAt?: number | undefined;
+                suspendedAt?: number | undefined;
+                resumedAt?: number | undefined;
+                metadata?: {
+                    [x: string]: any;
+                } | undefined;
+            }[];
+        }) | undefined;
+        result?: {
+            [x: string]: any;
+        } | undefined;
+        runId: string;
+        createdAt: string;
+        updatedAt: string;
+        resourceId?: string | undefined;
+        workflowName: string;
+        initialState?: ({
+            [x: string]: unknown;
+        } & {
+            [x: string]: any;
+        }) | undefined;
+        activeStepsPath?: ({
+            [x: string]: number[];
+        } & {
+            [x: string]: number[];
+        }) | undefined;
+        requestContext?: {
+            [x: string]: any;
+        } | undefined;
+        stepExecutionPath?: string[] | undefined;
+        resumeLabels?: {
+            [x: string]: {
+                stepId: string;
+                foreachIndex?: number | undefined;
+            };
+        } | undefined;
+        isFromInMemory?: boolean | undefined;
+        suspendedPaths?: {
+            [x: string]: number[];
+        } | undefined;
+        waitingPaths?: {
+            [x: string]: number[];
+        } | undefined;
+        tracingContext?: {
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            parentSpanId?: string | undefined;
+        } | undefined;
+        serializedStepGraph?: import('@mastra/core/workflows').SerializedStepFlowEntry[] | undefined;
+    } | undefined;
+    isLoading: boolean;
+};

package/dist/src/domains/workflows/context/use-stream-for-run.d.ts

@@ -0,0 +1,17 @@
+import { useStreamWorkflow } from '@mastra/react';
+export type StreamMode = 'execute' | 'observe';
+type StreamForRunParams = {
+    runId: string;
+} & Pick<Parameters<typeof useStreamWorkflow>[0], 'debugMode' | 'tracingOptions'>;
+export declare function useStreamForRun({ runId, debugMode, tracingOptions }: StreamForRunParams): {
+    result: import('@mastra/react').WorkflowStreamResult | null;
+    isOpen: boolean;
+    isObserving: boolean;
+    select: (runId: string, mode?: StreamMode) => void;
+    close: () => void;
+    streamWorkflow: (variables: import('@mastra/react').StreamWorkflowParams) => Promise<void>;
+    resumeWorkflowStream: (variables: import('@mastra/react').ResumeWorkflowStreamParams) => Promise<void>;
+    observeWorkflowStream: (variables: import('@mastra/react').ObserveWorkflowStreamParams) => void;
+    timeTravelWorkflowStream: (variables: import('@mastra/react').TimeTravelWorkflowStreamParams) => Promise<void>;
+};
+export {};

package/dist/src/domains/workflows/context/use-workflow-selected-step.d.ts

@@ -0,0 +1 @@
+export declare function useWorkflowSelectedStep(): import('./workflow-selected-step-context-value').WorkflowSelectedStepContextType;

package/dist/src/domains/workflows/context/workflow-run-context.d.ts

@@ -0,0 +1,103 @@
+import { GetWorkflowResponse, GetWorkflowRunByIdResponse, StreamVNextChunkType, TimeTravelParams } from '@mastra/client-js';
+import { StepTripwireInfo, WorkflowRunState, WorkflowState, WorkflowStateSingleStepResult } from '@mastra/core/workflows';
+import { WorkflowStreamResult } from '@mastra/react';
+import { Dispatch, SetStateAction } from 'react';
+type StepProgress = Extract<StreamVNextChunkType, {
+    type: 'workflow-step-progress';
+}>['payload'];
+export type WorkflowRunStreamStep = Omit<WorkflowStateSingleStepResult, 'error'> & {
+    error?: WorkflowStateSingleStepResult['error'] | Error;
+    tripwire?: StepTripwireInfo;
+    foreachProgress?: Pick<StepProgress, 'completedCount' | 'totalCount' | 'currentIndex' | 'iterationStatus' | 'iterationOutput'>;
+};
+export type WorkflowRunStreamResult = {
+    status: WorkflowState['status'];
+    input: WorkflowStreamResult['input'];
+    steps: Record<string, WorkflowRunStreamStep>;
+    result?: Extract<WorkflowStreamResult, {
+        status: 'success';
+    }>['result'];
+    error?: WorkflowState['error'] | Error;
+    state?: Extract<WorkflowStreamResult, {
+        status: 'success';
+    }>['state'];
+    stepExecutionPath?: WorkflowState['stepExecutionPath'];
+    resumeLabels?: WorkflowState['resumeLabels'];
+    tripwire?: StepTripwireInfo;
+    suspended?: string[][];
+    suspendPayload?: Extract<WorkflowStreamResult, {
+        status: 'suspended';
+    }>['suspendPayload'];
+};
+export type WorkflowRunSnapshot = WorkflowRunState | (GetWorkflowRunByIdResponse & {
+    timestamp?: number;
+});
+export type StreamWorkflowRunParams = {
+    workflowId: string;
+    runId: string;
+    inputData: Record<string, unknown>;
+    initialState?: Record<string, unknown>;
+    requestContext: Record<string, unknown>;
+    perStep?: boolean;
+    resourceId?: string;
+};
+export type ResumeWorkflowRunParams = {
+    workflowId: string;
+    runId: string;
+    step: string | string[];
+    resumeData: Record<string, unknown>;
+    requestContext: Record<string, unknown>;
+    perStep?: boolean;
+};
+export type ObserveWorkflowRunParams = {
+    workflowId: string;
+    runId: string;
+    storedStatus?: WorkflowRunStreamResult['status'];
+};
+export type TimeTravelWorkflowRunParams = {
+    workflowId: string;
+    runId: string;
+    requestContext: Record<string, unknown>;
+} & Omit<TimeTravelParams, 'requestContext'>;
+export type WorkflowRunContextType = {
+    workflowId: string;
+    workflow?: GetWorkflowResponse;
+    workflowError: Error | null;
+    isLoading?: boolean;
+    runId: string;
+    setRunId: (runId: string) => void;
+    result: WorkflowRunStreamResult | null;
+    setResult: (result: WorkflowRunStreamResult | null) => void;
+    streamResult: WorkflowRunStreamResult | null;
+    payload: any;
+    setPayload: (payload: unknown) => void;
+    clearData: () => void;
+    snapshot?: WorkflowRunState;
+    runSnapshot?: WorkflowRunSnapshot;
+    isLoadingRunExecutionResult?: boolean;
+    isStreamingWorkflow: boolean;
+    isCancellingWorkflowRun: boolean;
+    createWorkflowRun: (params: {
+        workflowId: string;
+        prevRunId?: string;
+        resourceId?: string;
+    }) => Promise<{
+        runId: string;
+    }>;
+    streamWorkflow: (params: StreamWorkflowRunParams) => Promise<void>;
+    resumeWorkflow: (params: ResumeWorkflowRunParams) => Promise<void>;
+    observeWorkflowStream: (params: ObserveWorkflowRunParams) => void;
+    timeTravelWorkflowStream: (params: TimeTravelWorkflowRunParams) => Promise<void>;
+    cancelWorkflowRun: (params: {
+        workflowId: string;
+        runId: string;
+    }) => Promise<{
+        message: string;
+    }>;
+    closeStreamsAndReset: () => void;
+    withoutTimeTravel?: boolean;
+    debugMode: boolean;
+    setDebugMode: Dispatch<SetStateAction<boolean>>;
+};
+export declare const WorkflowRunContext: import('react').Context<WorkflowRunContextType>;
+export {};

package/dist/src/domains/workflows/context/workflow-run-provider.d.ts

@@ -0,0 +1,10 @@
+import { WorkflowRunState } from '@mastra/core/workflows';
+import { ReactNode } from 'react';
+export declare function WorkflowRunProvider({ children, snapshot, workflowId, initialRunId, withoutTimeTravel, requestContext, }: {
+    children: ReactNode;
+    snapshot?: WorkflowRunState;
+    workflowId: string;
+    initialRunId?: string;
+    withoutTimeTravel?: boolean;
+    requestContext?: Record<string, any>;
+}): import("react").JSX.Element;

package/dist/src/domains/workflows/context/workflow-selected-step-context-value.d.ts

@@ -0,0 +1,8 @@
+import { Dispatch, SetStateAction } from 'react';
+export type WorkflowSelectedStepContextType = {
+    selectedStepId: string | null;
+    hoverStepId: string | null;
+    setSelectedStepId: Dispatch<SetStateAction<string | null>>;
+    setHoverStepId: Dispatch<SetStateAction<string | null>>;
+};
+export declare const WorkflowSelectedStepContext: import('react').Context<WorkflowSelectedStepContextType>;

package/dist/src/domains/workflows/context/workflow-selected-step-context.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export declare function WorkflowSelectedStepProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/src/domains/workflows/context/workflow-step-detail-context.d.ts

@@ -0,0 +1,43 @@
+import { SerializedStepFlowEntry } from '@mastra/core/workflows';
+export type WorkflowDataSelection = {
+    type: 'step-input' | 'step-output';
+    stepId: string;
+} | {
+    type: 'workflow-input' | 'workflow-output';
+    workflowName?: string;
+};
+export type StepDetailData = {
+    type: 'data';
+    selection: WorkflowDataSelection;
+} | {
+    type: 'map-config';
+    stepName: string;
+    stepId?: string;
+    mapConfig: string;
+} | {
+    type: 'nested-graph';
+    stepName: string;
+    nestedGraph: {
+        label: string;
+        stepGraph: SerializedStepFlowEntry[];
+        fullStep: string;
+    };
+};
+export type WorkflowStepDetailContextType = {
+    stepDetail: StepDetailData | null;
+    showMapConfig: (params: {
+        stepName: string;
+        stepId?: string;
+        mapConfig: string;
+    }) => void;
+    showNestedGraph: (params: {
+        label: string;
+        stepGraph: SerializedStepFlowEntry[];
+        fullStep: string;
+    }) => void;
+    showData: (selection: WorkflowDataSelection, trigger: HTMLButtonElement) => void;
+    closeStepDetail: () => void;
+    resetStepDetail: () => void;
+};
+export declare const WorkflowStepDetailContext: import('react').Context<WorkflowStepDetailContextType | null>;
+export declare function useWorkflowStepDetail(): WorkflowStepDetailContextType;

package/dist/src/domains/workflows/context/workflow-step-detail-provider.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export declare function WorkflowStepDetailProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/src/domains/workflows/context/workflow-step-timing.d.ts

@@ -0,0 +1,25 @@
+import { WorkflowRunStatus, WorkflowStepStatus } from '@mastra/core/workflows';
+export interface WorkflowStepTiming {
+    status?: WorkflowStepStatus;
+    startedAt?: number;
+    endedAt?: number;
+    suspendedAt?: number;
+    resumedAt?: number;
+}
+export interface WorkflowStepSpan {
+    start: number;
+    end?: number;
+    isLive: boolean;
+    spansSuspension: boolean;
+}
+export interface WorkflowRunTiming {
+    span: {
+        startedAt: number;
+        endedAt?: number;
+    };
+    spansSuspension: boolean;
+    waitingSince?: number;
+}
+export declare function isAwaitingInput(timing: WorkflowStepTiming): boolean;
+export declare function resolveStepSpan(timing: WorkflowStepTiming): WorkflowStepSpan | undefined;
+export declare function resolveRunTiming(steps: Record<string, WorkflowStepTiming> | undefined, status?: WorkflowRunStatus): WorkflowRunTiming | undefined;

package/dist/src/domains/workflows/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export * from './use-workflows';
+export * from './use-workflow';
+export * from './use-workflow-runs';
+export * from './use-workflows-run-counts';