Skip to content

Automate browser based workflows with AI

27.3 KB
Raw Blame
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]);
}