Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
import { useWorkflowParametersStore } from "./WorkflowParametersStore";
import { getInitialParameters } from "@/routes/workflows/editor/utils";
import {
selectEditorMutationLocked,
AUTHORING_SAVE_MESSAGE,
SAVE_STALE_MESSAGE,
beginSaveTransaction,
canInitializeWorkflow,
finishSaveTransaction,
getWorkflowLockMessage,
isYamlCommitOwnerCurrent,
markWorkflowSavePersisting,
markWorkflowSaveSettled,
refuseMutationDuringYamlCommit,
useWorkflowYamlEditorStore,
type YamlCommitContext,
type YamlCommitOwner,
} from "./WorkflowYamlEditorStore";
import { applyYamlCommitMetadata } from "./WorkflowTitleStore";
import { AxiosError } from "axios";
import { useEffect, useRef } from "react";
import { create } from "zustand";
import { useMutation, useQueryClient } from "@tanstack/react-query";
import { stringify as convertToYAML } from "yaml";
import { usePostHog } from "posthog-js/react";
import { getClient } from "@/api/AxiosClient";
import { toast } from "@/components/ui/use-toast";
import { useCredentialGetter } from "@/hooks/useCredentialGetter";
import { useLogging } from "@/hooks/useLogging";
import { flushBufferedEditorEdits } from "@/hooks/useDeferredLockedEdit";
import { buildWorkflowSaveRequest } from "@/routes/workflows/editor/workflowYamlDocument";
import { YamlCommitError } from "@/routes/workflows/editor/workflowVersionFromSaveData";
import {
type BlockYAML,
type ParameterYAML,
} from "@/routes/workflows/types/workflowYamlTypes";
import type {
WorkflowApiResponse,
WorkflowSettings,
} from "@/routes/workflows/types/workflowTypes";
type SaveData = {
parameters: Array<ParameterYAML>;
blocks: Array<BlockYAML>;
workflowDefinitionVersion: number;
title: string;
description: string | null;
settings: WorkflowSettings;
workflow: WorkflowApiResponse;
};
type WorkflowHasChangesStore = {
getSaveData: () => SaveData | null;
hydrateSavedSettings:
| ((
workflow: WorkflowApiResponse,
options?: { hydrateGraph?: boolean },
) => void)
| null;
hasChanges: boolean;
saveIsPending: boolean;
saveGeneration: number;
saveGenerationsByWorkflow: Record<string, number>;
recordPersistedSave: (workflowPermanentId?: string) => void;
// The server version each workflow's canvas descends from; a save sends it as its precondition.
baseVersions: Record<string, number>;
// The workflow whose last save the server rejected because a newer version exists.
saveConflict: string | null;
recordBaseVersion: (
workflow: Pick<WorkflowApiResponse, "workflow_permanent_id" | "version">,
) => void;
// Why workflow saves are held (an Accept whose server outcome is unconfirmed), or null.
saveBlockedReason: string | null;
saidOkToCodeCacheDeletion: boolean;
showConfirmCodeCacheDeletion: boolean;
// Reference-counted flag: multiple concurrent internal updates won't
// accidentally clear each other. Gate on > 0 in consumers.
internalUpdateCount: number;
// Whether the mounted editor canvas has any block node; null when no editor is mounted.
editorHasBlocks: boolean | null;
setGetSaveData: (getSaveData: () => SaveData) => void;
setHasChanges: (
hasChanges: boolean,
options?: { fromYamlCommit?: boolean },
) => void;
setSaveIsPending: (isPending: boolean) => void;
setSaveBlockedReason: (reason: string | null) => void;
setSaidOkToCodeCacheDeletion: (saidOkToCodeCacheDeletion: boolean) => void;
setShowConfirmCodeCacheDeletion: (show: boolean) => void;
beginInternalUpdate: () => void;
endInternalUpdate: () => void;
};
interface WorkflowSaveOpts {
status?: string;
}
function assertWorkflowSaveAllowed(
yamlCommit?: YamlCommitContext,
saveOwner?: YamlCommitOwner | null,
): void {
const blockedReason = useWorkflowHasChangesStore.getState().saveBlockedReason;
if (blockedReason) {
toast({
title: "Save is paused",
description: blockedReason,
variant: "destructive",
});
throw new YamlCommitError("workflow", blockedReason);
}
const state = useWorkflowYamlEditorStore.getState();
if (state.authoringInProgress) {
throw new SaveRefusedError(AUTHORING_SAVE_MESSAGE);
}
const owner = state.lockKind === "save" ? saveOwner : yamlCommit?.owner;
if (
state.copilotAcceptance ||
(state.commitInProgress && (!owner || !isYamlCommitOwnerCurrent(owner)))
) {
throw new SaveRefusedError(getWorkflowLockMessage());
}
}
const useWorkflowHasChangesStore = create<WorkflowHasChangesStore>(
(set, get) => {
let cancelInitializationRetry: (() => void) | undefined;
return {
hasChanges: false,
saveIsPending: false,
saveBlockedReason: null,
saveGeneration: 0,
saveGenerationsByWorkflow: {},
recordPersistedSave: (
workflowPermanentId = get().getSaveData()?.workflow
.workflow_permanent_id,
) =>
set((state) => ({
saveGeneration: state.saveGeneration + 1,
saveGenerationsByWorkflow: workflowPermanentId
? {
...state.saveGenerationsByWorkflow,
[workflowPermanentId]: state.saveGeneration + 1,
}
: state.saveGenerationsByWorkflow,
})),
baseVersions: {},
saveConflict: null,
recordBaseVersion: ({ workflow_permanent_id, version }) =>
set((state) => ({
baseVersions: {
...state.baseVersions,
[workflow_permanent_id]: version,
},
saveConflict:
state.saveConflict === workflow_permanent_id
? null
: state.saveConflict,
})),
saidOkToCodeCacheDeletion: false,
showConfirmCodeCacheDeletion: false,
internalUpdateCount: 0,
editorHasBlocks: null,
getSaveData: () => null,
hydrateSavedSettings: null,
setGetSaveData: (getSaveData: () => SaveData) => {
set({ getSaveData });
},
setHasChanges: (hasChanges: boolean, options) => {
const { commitInProgress, commitOwner, editorOwner } =
useWorkflowYamlEditorStore.getState();
// Navigation can mount a new editor owner before the old owner's PUT settles.
if (
!options?.fromYamlCommit &&
!hasChanges &&
commitInProgress &&
editorOwner?.active &&
commitOwner &&
editorOwner !== commitOwner
) {
cancelInitializationRetry?.();
cancelInitializationRetry = useWorkflowYamlEditorStore.subscribe(
(state) => {
if (state.editorOwner !== editorOwner || !editorOwner.active) {
cancelInitializationRetry?.();
cancelInitializationRetry = undefined;
} else if (!selectEditorMutationLocked(state)) {
cancelInitializationRetry?.();
cancelInitializationRetry = undefined;
get().setHasChanges(false);
}
},
);
return;
}
if (!options?.fromYamlCommit && refuseMutationDuringYamlCommit())
return;
cancelInitializationRetry?.();
cancelInitializationRetry = undefined;
if (hasChanges) useWorkflowYamlEditorStore.getState().bumpRevision();
set({ hasChanges });
},
setSaveIsPending: (isPending: boolean) => {
set({ saveIsPending: isPending });
},
setSaveBlockedReason: (reason) => {
set({ saveBlockedReason: reason });
},
setSaidOkToCodeCacheDeletion: (saidOkToCodeCacheDeletion: boolean) => {
set({ saidOkToCodeCacheDeletion });
},
setShowConfirmCodeCacheDeletion: (show: boolean) => {
set({ showConfirmCodeCacheDeletion: show });
},
beginInternalUpdate: () => {
set((state) => ({
internalUpdateCount: state.internalUpdateCount + 1,
}));
},
endInternalUpdate: () => {
set((state) => ({
internalUpdateCount: Math.max(0, state.internalUpdateCount - 1),
}));
},
};
},
);
export class SaveRefusedError extends Error {
constructor(message = getWorkflowLockMessage()) {
super(message);
this.name = "SaveRefusedError";
}
}
export class SaveStaleError extends Error {
constructor() {
super(SAVE_STALE_MESSAGE);
this.name = "SaveStaleError";
}
}
const WORKFLOW_SAVE_NOTICE_MS = 30_000;
function getSaveFailureReason(
error: AxiosError | YamlCommitError | SaveRefusedError | SaveStaleError,
) {
if (error instanceof SaveStaleError) return "stale";
if (error instanceof SaveRefusedError) return "refused";
if (!(error instanceof AxiosError)) return "other";
const status = error.response?.status;
if (status === 422) return "validation";
if (status === 409) return "conflict";
if (status === undefined) return "network";
if (status >= 500 && status < 600) return "server";
return "other";
}
const useWorkflowSave = (opts?: WorkflowSaveOpts) => {
const credentialGetter = useCredentialGetter();
const queryClient = useQueryClient();
const postHog = usePostHog();
const logging = useLogging();
const {
getSaveData,
setHasChanges,
setSaveIsPending,
setShowConfirmCodeCacheDeletion,
} = useWorkflowHasChangesStore();
const commitInProgress = useWorkflowYamlEditorStore(
(state) => state.commitInProgress,
);
const saveWorkflowMutation = useMutation({
mutationKey: ["saveWorkflow"],
mutationFn: async (
override?: Partial<SaveData> & {
yamlCommit?: YamlCommitContext;
codeCacheDeletionApproved?: boolean;
},
) => {
const changes = useWorkflowHasChangesStore.getState();
const codeCacheDeletionApproved =
override?.codeCacheDeletionApproved ??
changes.saidOkToCodeCacheDeletion;
if (override?.codeCacheDeletionApproved === undefined)
changes.setSaidOkToCodeCacheDeletion(false);
assertWorkflowSaveAllowed(override?.yamlCommit);
if (
override?.yamlCommit &&
!isYamlCommitOwnerCurrent(override.yamlCommit.owner)
)
return;
if (!override?.yamlCommit) {
useWorkflowYamlEditorStore.getState().flushDraft?.();
flushBufferedEditorEdits();
}
const store = useWorkflowYamlEditorStore.getState();
const owner =
override?.yamlCommit?.owner ??
useWorkflowYamlEditorStore.getState().editorOwner;
if (!override?.yamlCommit && (!owner || !beginSaveTransaction(owner))) {
throw new SaveRefusedError(
store.copilotAcceptance
? "Wait for the Copilot change to finish"
: !owner
? "The workflow editor is no longer available"
: undefined,
);
}
const revision = useWorkflowYamlEditorStore.getState().revision;
let uncertain = false;
try {
const base = useWorkflowHasChangesStore.getState().getSaveData();
if (!base)
throw new SaveRefusedError(
"The workflow editor is no longer available",
);
if (
owner &&
base.workflow.workflow_permanent_id !== owner.workflowPermanentId
) {
throw new SaveRefusedError(
"The workflow editor changed before saving",
);
}
// YAML-mode saves pass the parsed draft (blocks/parameters/version, plus
// a corrected finally_block_label) so we persist the edit directly
// instead of the graph, which lags a commit's async setNodes.
const saveData: SaveData = override ? { ...base, ...override } : base;
const client = await getClient(credentialGetter);
assertWorkflowSaveAllowed(override?.yamlCommit, owner);
if (
override?.yamlCommit &&
!isYamlCommitOwnerCurrent(override.yamlCommit.owner)
)
return;
if (
owner &&
(!isYamlCommitOwnerCurrent(owner) ||
useWorkflowYamlEditorStore.getState().revision !== revision)
) {
throw new SaveRefusedError(
"The workflow editor changed before saving",
);
}
const requestBody = buildWorkflowSaveRequest(saveData, opts);
const changesState = useWorkflowHasChangesStore.getState();
const yaml = convertToYAML(requestBody);
const baseVersion =
changesState.baseVersions[saveData.workflow.workflow_permanent_id] ??
saveData.workflow.version;
if (owner) markWorkflowSavePersisting(owner, baseVersion);
const requestStartedAt = Date.now();
const noticeTimer = setTimeout(() => {
if (!owner) return;
const state = useWorkflowYamlEditorStore.getState();
const pending = state.pendingSaves[owner.workflowPermanentId];
if (pending?.owner !== owner || !pending.persisting) return;
useWorkflowYamlEditorStore.setState({
pendingSaves: {
...state.pendingSaves,
[owner.workflowPermanentId]: { ...pending, slow: true },
},
});
logging.warn("Workflow save slow", {
workflow_permanent_id: saveData.workflow.workflow_permanent_id,
elapsed_ms: Date.now() - requestStartedAt,
});
}, WORKFLOW_SAVE_NOTICE_MS);
let response;
try {
response = await client.put<WorkflowApiResponse>(
`/workflows/${saveData.workflow.workflow_permanent_id}`,
yaml,
{
headers: {
"Content-Type": "text/plain",
},
params: {
delete_code_cache_is_ok: codeCacheDeletionApproved
? "true"
: "false",
expected_version: baseVersion,
},
},
);
} catch (error) {
if (!(error as AxiosError | null)?.response) {
uncertain = true;
if (owner) {
const state = useWorkflowYamlEditorStore.getState();
const pending = state.pendingSaves[owner.workflowPermanentId];
if (pending?.owner === owner)
useWorkflowYamlEditorStore.setState({
pendingSaves: {
...state.pendingSaves,
[owner.workflowPermanentId]: { ...pending, slow: true },
},
});
}
} else if (owner && !owner.active) {
const loaded = useWorkflowHasChangesStore
.getState()
.getSaveData()?.workflow;
if (
loaded?.workflow_permanent_id === owner.workflowPermanentId &&
hydrateWorkflowEditor(loaded)
)
setHasChanges(false, { fromYamlCommit: true });
}
throw error;
} finally {
clearTimeout(noticeTimer);
}
if (!owner || owner.active)
useWorkflowHasChangesStore
.getState()
.recordBaseVersion(response.data);
if (
!owner ||
owner.active ||
useWorkflowYamlEditorStore.getState().editorOwner
?.workflowPermanentId === saveData.workflow.workflow_permanent_id
)
useWorkflowHasChangesStore
.getState()
.recordPersistedSave(saveData.workflow.workflow_permanent_id);
const activeOwner = useWorkflowYamlEditorStore.getState().editorOwner;
if (
owner &&
!owner.active &&
activeOwner?.active &&
activeOwner.workflowPermanentId === owner.workflowPermanentId &&
hydrateWorkflowEditor(response.data)
) {
// Only the detail GET computes effective_default_engine; the PUT omits it.
queryClient.setQueryData(
["workflow", saveData.workflow.workflow_permanent_id],
(prev?: WorkflowApiResponse) => ({
...response.data,
effective_default_engine:
"effective_default_engine" in response.data
? response.data.effective_default_engine
: prev?.effective_default_engine,
}),
);
setHasChanges(false, { fromYamlCommit: true });
}
if (owner && !override?.yamlCommit) {
// An unmounted editor cannot accept metadata, but its acknowledged
// write still invalidates that workflow's cache.
if (owner.active) {
const state = useWorkflowYamlEditorStore.getState();
if (!isYamlCommitOwnerCurrent(owner) || state.authoringInProgress)
throw new SaveStaleError();
if (useWorkflowYamlEditorStore.getState().revision !== revision) {
const error = new SaveStaleError();
useWorkflowYamlEditorStore.getState().setError(error.message);
throw error;
}
useWorkflowHasChangesStore
.getState()
.hydrateSavedSettings?.(response.data);
applyYamlCommitMetadata(response.data, {}, true);
setHasChanges(false, { fromYamlCommit: true });
}
if (owner.active) {
void queryClient.invalidateQueries({
queryKey: ["workflow", base.workflow.workflow_permanent_id],
});
void queryClient.invalidateQueries({ queryKey: ["workflows"] });
void queryClient.invalidateQueries({
queryKey: ["block-scripts", base.workflow.workflow_permanent_id],
});
}
}
return response;
} finally {
if (owner && !uncertain) {
markWorkflowSaveSettled(owner);
if (!override?.yamlCommit || !owner.active)
finishSaveTransaction(owner);
}
}
},
onMutate: (override) => {
const store = useWorkflowYamlEditorStore.getState();
const owner = override?.yamlCommit?.owner ?? store.editorOwner;
const saveData = getSaveData();
return {
owner,
revision: store.revision,
workflowPermanentId:
owner?.workflowPermanentId ??
saveData?.workflow.workflow_permanent_id,
organizationId: saveData?.workflow.organization_id,
startedAt: Date.now(),
};
},
onSuccess: (_response, override, context) => {
if (context?.owner && !context.owner.active) return;
if (
override?.yamlCommit &&
!isYamlCommitOwnerCurrent(override.yamlCommit.owner)
)
return;
if (
override?.yamlCommit &&
useWorkflowYamlEditorStore.getState().revision !==
override.yamlCommit.revision
)
return;
const saveData = getSaveData();
if (!saveData) {
return;
}
postHog.capture("builder.workflow.saved", {
org_id: saveData.workflow.organization_id,
workflow_permanent_id: saveData.workflow.workflow_permanent_id,
block_count: saveData.blocks.length,
block_types: saveData.blocks.map((b) => b.block_type),
duration_ms: Math.max(0, Date.now() - context.startedAt),
});
toast({
title: "Changes saved",
description: "Your changes have been saved",
variant: "success",
});
},
onError: (
error: AxiosError | YamlCommitError | SaveRefusedError | SaveStaleError,
override,
context,
) => {
const status =
error instanceof AxiosError ? error.response?.status : undefined;
const saveData = getSaveData();
postHog.capture("builder.workflow.save_failed", {
org_id: context?.organizationId ?? saveData?.workflow.organization_id,
workflow_permanent_id:
context?.workflowPermanentId ??
saveData?.workflow.workflow_permanent_id,
reason: getSaveFailureReason(error),
http_status: status ?? null,
});
if (status !== undefined && status >= 400 && status < 500) {
logging.warn("Workflow save rejected", {
workflow_permanent_id:
context?.workflowPermanentId ??
saveData?.workflow.workflow_permanent_id,
http_status: status,
error,
});
}
if (context?.owner && !context.owner.active) return;
if (
override?.yamlCommit &&
!isYamlCommitOwnerCurrent(override.yamlCommit.owner)
)
return;
if (status === 409 && context?.workflowPermanentId) {
useWorkflowHasChangesStore.setState({
saveConflict: context.workflowPermanentId,
});
void queryClient.invalidateQueries({
queryKey: ["workflowVersions", context.workflowPermanentId],
});
return;
}
if (
error instanceof SaveRefusedError ||
error instanceof SaveStaleError
) {
toast({ title: error.message, variant: "destructive" });
return;
}
if (error instanceof YamlCommitError) {
toast({
title: "Failed to save agent",
description: error.message,
variant: "destructive",
});
return;
}
if (
context?.owner &&
useWorkflowYamlEditorStore.getState().pendingSaves[
context.owner.workflowPermanentId
]?.persisting
)
return;
const responseData = error.response?.data as
| {
detail?:
| string
| Array<{
loc?: Array<string | number>;
msg?: string;
type?: string;
}>;
}
| undefined;
const rawDetail = responseData?.detail;
if (
typeof rawDetail === "string" &&
rawDetail.startsWith("No confirmation for code cache deletion")
) {
setShowConfirmCodeCacheDeletion(true);
return;
}
let description: string;
if (typeof rawDetail === "string" && rawDetail) {
description = rawDetail;
} else if (Array.isArray(rawDetail) && rawDetail.length > 0) {
// FastAPI's own 422 responses (e.g. request body validation) return detail
// as an array; our custom ValidationError handler returns it as a string.
description = rawDetail
.map((err) => {
const loc = err.loc
?.filter((part) => part !== "body" && part !== "__root__")
.join(" -> ");
return loc ? `${loc}: ${err.msg}` : (err.msg ?? "Unknown error");
})
.join("; ");
} else {
description =
"Failed to save agent. Please check your agent configuration and try again.";
}
toast({
title: "Failed to save agent",
description,
variant: "destructive",
});
},
onSettled: (_response, _error, _override, context) => {
if (
context?.owner &&
!context.owner.active &&
context.workflowPermanentId
) {
// The cache outlives the editor, and a failed response can still follow
// a persisted update. Reopening must fetch the submitted workflow.
for (const queryKey of [
["workflow", context.workflowPermanentId],
["workflows"],
["block-scripts", context.workflowPermanentId],
])
void queryClient.invalidateQueries({ queryKey });
}
},
});
useEffect(() => {
setSaveIsPending(commitInProgress);
}, [commitInProgress, setSaveIsPending]);
return saveWorkflowMutation;
};
function hydrateWorkflowEditor(workflow: WorkflowApiResponse): boolean {
const owner = useWorkflowYamlEditorStore.getState().editorOwner;
const hydrate = useWorkflowHasChangesStore.getState().hydrateSavedSettings;
if (
!owner?.active ||
owner.workflowPermanentId !== workflow.workflow_permanent_id ||
!hydrate
)
return false;
hydrate(workflow, { hydrateGraph: true });
useWorkflowHasChangesStore.getState().recordBaseVersion(workflow);
applyYamlCommitMetadata(workflow, {}, true);
return true;
}
function hydrateRestoredWorkflowSave(
workflow: WorkflowApiResponse,
owner: YamlCommitOwner,
): void {
const state = useWorkflowYamlEditorStore.getState();
const pending = state.pendingSaves[owner.workflowPermanentId];
if (
!pending?.restored ||
pending.owner !== owner ||
workflow.workflow_permanent_id !== owner.workflowPermanentId ||
state.editorOwner?.workflowPermanentId !== owner.workflowPermanentId
)
return;
if (!hydrateWorkflowEditor(workflow)) return;
useWorkflowHasChangesStore
.getState()
.setHasChanges(false, { fromYamlCommit: true });
markWorkflowSaveSettled(owner);
finishSaveTransaction(owner);
}
export function discardRestoredWorkflowSave(
owner: YamlCommitOwner,
workflow: WorkflowApiResponse,
): void {
hydrateRestoredWorkflowSave(workflow, owner);
}
export function reloadConflictedWorkflow(workflow: WorkflowApiResponse): void {
if (!hydrateWorkflowEditor(workflow)) return;
useWorkflowYamlEditorStore.getState().close();
useWorkflowHasChangesStore
.getState()
.setHasChanges(false, { fromYamlCommit: true });
}
export function usePendingWorkflowSaveRecovery(
workflow: WorkflowApiResponse,
): void {
const pending = useWorkflowYamlEditorStore(
(state) => state.pendingSaves[workflow.workflow_permanent_id],
);
const hydrate = useWorkflowHasChangesStore(
(state) => state.hydrateSavedSettings,
);
useEffect(() => {
// Only a reload loses the original PUT response. Live requests retain their reservation.
if (
!pending?.restored ||
!hydrate ||
!(workflow.version > pending.restored.baseVersion)
)
return;
hydrateRestoredWorkflowSave(workflow, pending.owner);
}, [workflow, pending, hydrate]);
}
export function reflectYamlDraftDirtiness(
entryHadChanges: boolean,
draftDirty: boolean,
): void {
const changes = useWorkflowHasChangesStore.getState();
const hasChanges = entryHadChanges || draftDirty;
// A dirty draft re-asserts the flag to invalidate an in-flight save; a clean
// one that already matches has nothing to write, which also keeps opening
// YAML during a Copilot turn from tripping its edit lock.
if (!draftDirty && changes.hasChanges === hasChanges) return;
changes.setHasChanges(hasChanges);
}
export {
useWorkflowSave,
useWorkflowHasChangesStore,
type SaveData as WorkflowSaveData,
};
export function useHydrateWorkflowParameters(
workflow: WorkflowApiResponse | undefined,
routeWorkflowPermanentId: string | undefined,
): void {
const hydratedWorkflowId = useRef<string | null>(null);
const observedWorkflow = useRef<WorkflowApiResponse>();
const hydrationLocked = useWorkflowYamlEditorStore(() =>
routeWorkflowPermanentId
? !canInitializeWorkflow(routeWorkflowPermanentId)
: true,
);
const setParameters = useWorkflowParametersStore(
(state) => state.setParameters,
);
useEffect(() => {
if (
hydrationLocked ||
!workflow ||
workflow.workflow_permanent_id !== routeWorkflowPermanentId
)
return;
// Unlocking a save must not replay the unchanged pre-save response.
const workflowChanged = observedWorkflow.current !== workflow;
if (
useWorkflowParametersStore.getState().parametersWorkflowPermanentId !==
routeWorkflowPermanentId &&
(hydratedWorkflowId.current !== routeWorkflowPermanentId ||
(workflowChanged && !useWorkflowHasChangesStore.getState().hasChanges))
) {
if (
setParameters(getInitialParameters(workflow), {
workflowPermanentId: routeWorkflowPermanentId,
})
) {
hydratedWorkflowId.current = routeWorkflowPermanentId;
observedWorkflow.current = workflow;
}
} else {
observedWorkflow.current = workflow;
}
}, [workflow, routeWorkflowPermanentId, setParameters, hydrationLocked]);
}