@mastra/playground-ui 5.1.6-alpha.3 → 5.1.6-alpha.5

package/dist/index.es.js

@@ -30,7 +30,6 @@ import { C as Colors } from './colors-CBG_Mm7P.js';
 import { processDataStream } from '@ai-sdk/ui-utils';
 import Markdown from 'react-markdown';
 import { useDebouncedCallback } from 'use-debounce';
-import { RuntimeContext as RuntimeContext$1 } from '@mastra/core/runtime-context';
 import { MarkerType, Handle, Position, useNodesState, useEdgesState, ReactFlow, Controls, MiniMap, Background, BackgroundVariant, ReactFlowProvider, useViewport, useReactFlow, Panel } from '@xyflow/react';
 import '@xyflow/react/dist/style.css';
 import Dagre from '@dagrejs/dagre';
@@ -6909,41 +6908,6 @@ function Skeleton({ className, ...props }) {
   return /* @__PURE__ */ jsx("div", { className: cn("animate-pulse rounded-md bg-muted/50", className), ...props });
 }
 
-const sanitizeWorkflowWatchResult = (record) => {
-  const formattedResults = Object.entries(record.payload.workflowState.steps || {}).reduce(
-    (acc, [key, value]) => {
-      let output = value.status === "success" ? value.output : void 0;
-      if (output) {
-        output = Object.entries(output).reduce(
-          (_acc, [_key, _value]) => {
-            const val = _value;
-            _acc[_key] = val.type?.toLowerCase() === "buffer" ? { type: "Buffer", data: `[...buffered data]` } : val;
-            return _acc;
-          },
-          {}
-        );
-      }
-      acc[key] = { ...value, output };
-      return acc;
-    },
-    {}
-  );
-  const sanitizedRecord = {
-    ...record,
-    sanitizedOutput: record ? JSON.stringify(
-      {
-        ...record,
-        payload: {
-          ...record.payload,
-          workflowState: { ...record.payload.workflowState, steps: formattedResults }
-        }
-      },
-      null,
-      2
-    ).slice(0, 5e4) : null
-  };
-  return sanitizedRecord;
-};
 const useLegacyWorkflow = (workflowId) => {
   const [legacyWorkflow, setLegacyWorkflow] = useState(null);
   const [isLoading, setIsLoading] = useState(true);
@@ -7001,16 +6965,6 @@ const useExecuteWorkflow = () => {
       throw error;
     }
   };
-  const createWorkflowRun = async ({ workflowId, prevRunId }) => {
-    try {
-      const workflow = client.getWorkflow(workflowId);
-      const { runId: newRunId } = await workflow.createRun({ runId: prevRunId });
-      return { runId: newRunId };
-    } catch (error) {
-      console.error("Error creating workflow run:", error);
-      throw error;
-    }
-  };
   const startLegacyWorkflowRun = async ({
     workflowId,
     runId,
@@ -7024,56 +6978,14 @@ const useExecuteWorkflow = () => {
       throw error;
     }
   };
-  const startWorkflowRun = async ({
-    workflowId,
-    runId,
-    input,
-    runtimeContext: playgroundRuntimeContext
-  }) => {
-    try {
-      const runtimeContext = new RuntimeContext$1();
-      Object.entries(playgroundRuntimeContext).forEach(([key, value]) => {
-        runtimeContext.set(key, value);
-      });
-      const workflow = client.getWorkflow(workflowId);
-      await workflow.start({ runId, inputData: input || {}, runtimeContext });
-    } catch (error) {
-      console.error("Error starting workflow run:", error);
-      throw error;
-    }
-  };
-  const startAsyncWorkflowRun = async ({
-    workflowId,
-    runId,
-    input,
-    runtimeContext: playgroundRuntimeContext
-  }) => {
-    try {
-      const runtimeContext = new RuntimeContext$1();
-      Object.entries(playgroundRuntimeContext).forEach(([key, value]) => {
-        runtimeContext.set(key, value);
-      });
-      const workflow = client.getWorkflow(workflowId);
-      const result = await workflow.startAsync({ runId, inputData: input || {}, runtimeContext });
-      return result;
-    } catch (error) {
-      console.error("Error starting workflow run:", error);
-      throw error;
-    }
-  };
   return {
-    startWorkflowRun,
-    createWorkflowRun,
     startLegacyWorkflowRun,
-    createLegacyWorkflowRun,
-    startAsyncWorkflowRun
+    createLegacyWorkflowRun
   };
 };
 const useWatchWorkflow = () => {
   const [isWatchingLegacyWorkflow, setIsWatchingLegacyWorkflow] = useState(false);
-  const [isWatchingWorkflow, setIsWatchingWorkflow] = useState(false);
   const [legacyWatchResult, setLegacyWatchResult] = useState(null);
-  const [watchResult, setWatchResult] = useState(null);
   const client = useMastraClient();
   const debouncedSetLegacyWorkflowWatchResult = useDebouncedCallback((record) => {
     const formattedResults = Object.entries(record.results || {}).reduce(
@@ -7121,43 +7033,14 @@ const useWatchWorkflow = () => {
       setIsWatchingLegacyWorkflow(false);
     }
   };
-  const debouncedSetWorkflowWatchResult = useDebouncedCallback((record) => {
-    const sanitizedRecord = sanitizeWorkflowWatchResult(record);
-    setWatchResult(sanitizedRecord);
-  }, 100);
-  const watchWorkflow = async ({ workflowId, runId }) => {
-    try {
-      setIsWatchingWorkflow(true);
-      const workflow = client.getWorkflow(workflowId);
-      await workflow.watch({ runId }, (record) => {
-        try {
-          debouncedSetWorkflowWatchResult(record);
-        } catch (err) {
-          console.error("Error processing workflow record:", err);
-          setWatchResult({
-            ...record
-          });
-        }
-      });
-    } catch (error) {
-      console.error("Error watching workflow:", error);
-      throw error;
-    } finally {
-      setIsWatchingWorkflow(false);
-    }
-  };
   return {
     watchLegacyWorkflow,
     isWatchingLegacyWorkflow,
-    legacyWatchResult,
-    watchWorkflow,
-    isWatchingWorkflow,
-    watchResult
+    legacyWatchResult
   };
 };
 const useResumeWorkflow = () => {
   const [isResumingLegacyWorkflow, setIsResumingLegacyWorkflow] = useState(false);
-  const [isResumingWorkflow, setIsResumingWorkflow] = useState(false);
   const client = useMastraClient();
   const resumeLegacyWorkflow = async ({
     workflowId,
@@ -7176,33 +7059,9 @@ const useResumeWorkflow = () => {
       setIsResumingLegacyWorkflow(false);
     }
   };
-  const resumeWorkflow = async ({
-    workflowId,
-    step,
-    runId,
-    resumeData,
-    runtimeContext: playgroundRuntimeContext
-  }) => {
-    try {
-      setIsResumingWorkflow(true);
-      const runtimeContext = new RuntimeContext$1();
-      Object.entries(playgroundRuntimeContext).forEach(([key, value]) => {
-        runtimeContext.set(key, value);
-      });
-      const response = await client.getWorkflow(workflowId).resume({ step, runId, resumeData, runtimeContext });
-      return response;
-    } catch (error) {
-      console.error("Error resuming workflow:", error);
-      throw error;
-    } finally {
-      setIsResumingWorkflow(false);
-    }
-  };
   return {
     resumeLegacyWorkflow,
-    isResumingLegacyWorkflow,
-    resumeWorkflow,
-    isResumingWorkflow
+    isResumingLegacyWorkflow
   };
 };
 
@@ -9812,13 +9671,17 @@ function WorkflowTrigger({
   workflowId,
   setRunId,
   workflow,
-  isLoading
+  isLoading,
+  createWorkflowRun,
+  startWorkflowRun,
+  resumeWorkflow,
+  watchWorkflow,
+  watchResult,
+  isWatchingWorkflow,
+  isResumingWorkflow
 }) {
   const { runtimeContext } = usePlaygroundStore();
   const { result, setResult, payload, setPayload } = useContext(WorkflowRunContext);
-  const { createWorkflowRun, startWorkflowRun } = useExecuteWorkflow();
-  const { watchWorkflow, watchResult, isWatchingWorkflow } = useWatchWorkflow();
-  const { resumeWorkflow, isResumingWorkflow } = useResumeWorkflow();
   const [suspendedSteps, setSuspendedSteps] = useState([]);
   const [isRunning, setIsRunning] = useState(false);
   const triggerSchema = workflow?.inputSchema;