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

package/dist/index.cjs.js

@@ -32,7 +32,6 @@ const colors = require('./colors-Du4i-E0i.cjs');
 const uiUtils = require('@ai-sdk/ui-utils');
 const Markdown = require('react-markdown');
 const useDebounce = require('use-debounce');
-const runtimeContext = require('@mastra/core/runtime-context');
 const react$2 = require('@xyflow/react');
 require('@xyflow/react/dist/style.css');
 const Dagre = require('@dagrejs/dagre');
@@ -6941,41 +6940,6 @@ function Skeleton({ className, ...props }) {
   return /* @__PURE__ */ jsxRuntime.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] = React.useState(null);
   const [isLoading, setIsLoading] = React.useState(true);
@@ -7033,16 +6997,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,
@@ -7056,56 +7010,14 @@ const useExecuteWorkflow = () => {
       throw error;
     }
   };
-  const startWorkflowRun = async ({
-    workflowId,
-    runId,
-    input,
-    runtimeContext: playgroundRuntimeContext
-  }) => {
-    try {
-      const runtimeContext$1 = new runtimeContext.RuntimeContext();
-      Object.entries(playgroundRuntimeContext).forEach(([key, value]) => {
-        runtimeContext$1.set(key, value);
-      });
-      const workflow = client.getWorkflow(workflowId);
-      await workflow.start({ runId, inputData: input || {}, runtimeContext: runtimeContext$1 });
-    } catch (error) {
-      console.error("Error starting workflow run:", error);
-      throw error;
-    }
-  };
-  const startAsyncWorkflowRun = async ({
-    workflowId,
-    runId,
-    input,
-    runtimeContext: playgroundRuntimeContext
-  }) => {
-    try {
-      const runtimeContext$1 = new runtimeContext.RuntimeContext();
-      Object.entries(playgroundRuntimeContext).forEach(([key, value]) => {
-        runtimeContext$1.set(key, value);
-      });
-      const workflow = client.getWorkflow(workflowId);
-      const result = await workflow.startAsync({ runId, inputData: input || {}, runtimeContext: runtimeContext$1 });
-      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] = React.useState(false);
-  const [isWatchingWorkflow, setIsWatchingWorkflow] = React.useState(false);
   const [legacyWatchResult, setLegacyWatchResult] = React.useState(null);
-  const [watchResult, setWatchResult] = React.useState(null);
   const client = useMastraClient();
   const debouncedSetLegacyWorkflowWatchResult = useDebounce.useDebouncedCallback((record) => {
     const formattedResults = Object.entries(record.results || {}).reduce(
@@ -7153,43 +7065,14 @@ const useWatchWorkflow = () => {
       setIsWatchingLegacyWorkflow(false);
     }
   };
-  const debouncedSetWorkflowWatchResult = useDebounce.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] = React.useState(false);
-  const [isResumingWorkflow, setIsResumingWorkflow] = React.useState(false);
   const client = useMastraClient();
   const resumeLegacyWorkflow = async ({
     workflowId,
@@ -7208,33 +7091,9 @@ const useResumeWorkflow = () => {
       setIsResumingLegacyWorkflow(false);
     }
   };
-  const resumeWorkflow = async ({
-    workflowId,
-    step,
-    runId,
-    resumeData,
-    runtimeContext: playgroundRuntimeContext
-  }) => {
-    try {
-      setIsResumingWorkflow(true);
-      const runtimeContext$1 = new runtimeContext.RuntimeContext();
-      Object.entries(playgroundRuntimeContext).forEach(([key, value]) => {
-        runtimeContext$1.set(key, value);
-      });
-      const response = await client.getWorkflow(workflowId).resume({ step, runId, resumeData, runtimeContext: runtimeContext$1 });
-      return response;
-    } catch (error) {
-      console.error("Error resuming workflow:", error);
-      throw error;
-    } finally {
-      setIsResumingWorkflow(false);
-    }
-  };
   return {
     resumeLegacyWorkflow,
-    isResumingLegacyWorkflow,
-    resumeWorkflow,
-    isResumingWorkflow
+    isResumingLegacyWorkflow
   };
 };
 
@@ -9844,13 +9703,17 @@ function WorkflowTrigger({
   workflowId,
   setRunId,
   workflow,
-  isLoading
+  isLoading,
+  createWorkflowRun,
+  startWorkflowRun,
+  resumeWorkflow,
+  watchWorkflow,
+  watchResult,
+  isWatchingWorkflow,
+  isResumingWorkflow
 }) {
   const { runtimeContext } = usePlaygroundStore();
   const { result, setResult, payload, setPayload } = React.useContext(WorkflowRunContext);
-  const { createWorkflowRun, startWorkflowRun } = useExecuteWorkflow();
-  const { watchWorkflow, watchResult, isWatchingWorkflow } = useWatchWorkflow();
-  const { resumeWorkflow, isResumingWorkflow } = useResumeWorkflow();
   const [suspendedSteps, setSuspendedSteps] = React.useState([]);
   const [isRunning, setIsRunning] = React.useState(false);
   const triggerSchema = workflow?.inputSchema;