Skip to content

Automate browser based workflows with AI

[SKY-8784][SKY-8553] Address Schedule Missing Params (#5409)

Aaron Perezf8cf5ee49bd6
diff --git a/skyvern-frontend/src/components/FileUpload.tsx b/skyvern-frontend/src/components/FileUpload.tsx
index 069ad5541..93d9fbf58 100644
--- a/skyvern-frontend/src/components/FileUpload.tsx
+++ b/skyvern-frontend/src/components/FileUpload.tsx
@@ -21,6 +21,7 @@ export type FileInputValue =
type Props = {
value: FileInputValue;
onChange: (value: FileInputValue) => void;
+ required?: boolean;
};
const FILE_SIZE_LIMIT_IN_BYTES = 10 * 1024 * 1024; // 10 MB
@@ -34,7 +35,7 @@ function showFileSizeError() {
});
}
-function FileUpload({ value, onChange }: Props) {
+function FileUpload({ value, onChange, required }: Props) {
const credentialGetter = useCredentialGetter();
const [file, setFile] = useState<File | null>(null);
const inputId = useId();
@@ -155,6 +156,7 @@ function FileUpload({ value, onChange }: Props) {
id={inputId}
type="file"
onChange={handleFileChange}
+ aria-required={required || undefined}
accept=".csv,.pdf"
className="hidden"
/>
@@ -176,6 +178,7 @@ function FileUpload({ value, onChange }: Props) {
<Label>File URL</Label>
{typeof value === "string" && (
<Input
+ aria-required={required || undefined}
value={value}
onChange={(event) => onChange(event.target.value)}
/>
diff --git a/skyvern-frontend/src/routes/schedules/CreateOrgScheduleDialog.tsx b/skyvern-frontend/src/routes/schedules/CreateOrgScheduleDialog.tsx
index 9c88bff5b..5cd2ef1f4 100644
--- a/skyvern-frontend/src/routes/schedules/CreateOrgScheduleDialog.tsx
+++ b/skyvern-frontend/src/routes/schedules/CreateOrgScheduleDialog.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
import { useNavigate } from "react-router-dom";
import { Button } from "@/components/ui/button";
import {
@@ -14,7 +14,10 @@ import { Label } from "@/components/ui/label";
import { useQuery } from "@tanstack/react-query";
import { getClient } from "@/api/AxiosClient";
import { useCredentialGetter } from "@/hooks/useCredentialGetter";
-import type { WorkflowApiResponse } from "@/routes/workflows/types/workflowTypes";
+import type {
+ WorkflowApiResponse,
+ Parameter,
+} from "@/routes/workflows/types/workflowTypes";
import {
CRON_PRESETS,
cronToHumanReadable,
@@ -25,6 +28,10 @@ import {
isValidCron,
} from "@/routes/workflows/editor/panels/schedulePanel/cronUtils";
import { cn } from "@/util/utils";
+import { useWorkflowQuery } from "@/routes/workflows/hooks/useWorkflowQuery";
+import { ScheduleParametersSection } from "@/routes/workflows/components/ScheduleParametersSection";
+import { buildScheduleParametersPayload } from "@/routes/workflows/components/scheduleParameters";
+import { useScheduleParameterState } from "@/routes/workflows/hooks/useScheduleParameterState";
import { useCreateOrgScheduleMutation } from "./useCreateOrgScheduleMutation";
type Props = {
@@ -48,6 +55,8 @@ function CreateOrgScheduleDialog({ open, onOpenChange }: Readonly<Props>) {
const [scheduleName, setScheduleName] = useState("");
const [scheduleDescription, setScheduleDescription] = useState("");
+ const allTimezones = useMemo(() => getTimezones(), []);
+
const { data: workflows = [] } = useQuery<Array<WorkflowApiResponse>>({
queryKey: ["workflows", "scheduleDialogPicker", workflowSearch],
queryFn: async () => {
@@ -64,13 +73,65 @@ function CreateOrgScheduleDialog({ open, onOpenChange }: Readonly<Props>) {
enabled: open,
});
- const allTimezones = useMemo(() => getTimezones(), []);
+ const { data: selectedWorkflowDetail } = useWorkflowQuery({
+ workflowPermanentId: selectedWorkflow?.workflow_permanent_id,
+ });
+
+ // The workflow detail (and therefore the parameter definitions) is loaded
+ // iff the resolved workflow id matches the selection. While the request is
+ // still in flight or stale, the form must not allow submission — otherwise
+ // we'd POST without `parameters` for a workflow that has required inputs
+ // and the backend would 400 with "Missing schedule parameters".
+ const workflowDetailLoaded =
+ selectedWorkflow !== null &&
+ selectedWorkflowDetail?.workflow_permanent_id ===
+ selectedWorkflow.workflow_permanent_id;
+
+ const workflowParameters = useMemo<ReadonlyArray<Parameter>>(() => {
+ if (
+ !selectedWorkflowDetail ||
+ selectedWorkflowDetail.workflow_permanent_id !==
+ selectedWorkflow?.workflow_permanent_id
+ ) {
+ return [];
+ }
+
+ return selectedWorkflowDetail.workflow_definition.parameters;
+ }, [selectedWorkflow, selectedWorkflowDetail]);
+ const {
+ values: parameters,
+ errors: parameterErrors,
+ handleChange: handleParameterChange,
+ validate: validateParameters,
+ reset: resetParameters,
+ clear: clearParameters,
+ } = useScheduleParameterState(workflowParameters);
+
+ // Re-seed parameter state when (a) the user switches workflows or
+ // (b) the parameter definitions for the currently-selected workflow
+ // arrive from a still-in-flight react-query fetch. We track the
+ // (workflowId, paramsLength) tuple in a ref so refetches that produce
+ // an identical parameter set don't clobber user-typed values.
+ const selectedWorkflowId = selectedWorkflow?.workflow_permanent_id ?? null;
+ const lastSeededRef = useRef<{ id: string | null; count: number }>({
+ id: null,
+ count: 0,
+ });
+ useEffect(() => {
+ const last = lastSeededRef.current;
+ const next = { id: selectedWorkflowId, count: workflowParameters.length };
+ if (last.id !== next.id || last.count !== next.count) {
+ lastSeededRef.current = next;
+ resetParameters();
+ }
+ }, [selectedWorkflowId, workflowParameters, resetParameters]);
+
const filteredTimezones = useMemo(() => {
if (timezoneFilter === null) return allTimezones;
if (!timezoneFilter) return allTimezones;
const lower = timezoneFilter.toLowerCase();
return allTimezones.filter((tz) => tz.toLowerCase().includes(lower));
- }, [allTimezones, timezoneFilter]);
+ }, [timezoneFilter, allTimezones]);
const valid = isValidCron(cronExpression);
const humanReadable = valid ? cronToHumanReadable(cronExpression) : null;
@@ -85,10 +146,17 @@ function CreateOrgScheduleDialog({ open, onOpenChange }: Readonly<Props>) {
setTimezoneFilter(null);
setScheduleName("");
setScheduleDescription("");
+ clearParameters();
}
function handleSubmit() {
- if (!valid || !selectedWorkflow) return;
+ if (!selectedWorkflow || !workflowDetailLoaded) return;
+ const parametersValid = validateParameters();
+ if (!valid || !parametersValid) return;
+ const payload = buildScheduleParametersPayload(
+ parameters,
+ workflowParameters,
+ );
createMutation.mutate(
{
workflowPermanentId: selectedWorkflow.workflow_permanent_id,
@@ -97,6 +165,7 @@ function CreateOrgScheduleDialog({ open, onOpenChange }: Readonly<Props>) {
timezone,
...(scheduleName && { name: scheduleName }),
...(scheduleDescription && { description: scheduleDescription }),
+ ...(payload && { parameters: payload }),
},
},
{
@@ -195,6 +264,14 @@ function CreateOrgScheduleDialog({ open, onOpenChange }: Readonly<Props>) {
/>
</div>
+ <ScheduleParametersSection
+ parameters={workflowParameters}
+ values={parameters}
+ onChange={handleParameterChange}
+ errors={parameterErrors}
+ disabled={createMutation.isPending}
+ />
+
{/* Cron Presets */}
<div className="space-y-2">
<Label>Quick Presets</Label>
@@ -305,7 +382,9 @@ function CreateOrgScheduleDialog({ open, onOpenChange }: Readonly<Props>) {
Cancel
</Button>
<Button
- disabled={!valid || !selectedWorkflow || createMutation.isPending}
+ disabled={
+ !valid || !workflowDetailLoaded || createMutation.isPending
+ }
onClick={handleSubmit}
>
{createMutation.isPending ? "Creating..." : "Create Schedule"}
diff --git a/skyvern-frontend/src/routes/schedules/ScheduleDetailPage.tsx b/skyvern-frontend/src/routes/schedules/ScheduleDetailPage.tsx
index 70717afce..9037e5682 100644
--- a/skyvern-frontend/src/routes/schedules/ScheduleDetailPage.tsx
+++ b/skyvern-frontend/src/routes/schedules/ScheduleDetailPage.tsx
@@ -18,10 +18,7 @@ import {
import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
import { Switch } from "@/components/ui/switch";
-import { useQuery } from "@tanstack/react-query";
-import { getClient } from "@/api/AxiosClient";
-import { useCredentialGetter } from "@/hooks/useCredentialGetter";
-import type { WorkflowApiResponse } from "@/routes/workflows/types/workflowTypes";
+import { useWorkflowQuery } from "@/routes/workflows/hooks/useWorkflowQuery";
import { useScheduleDetailQuery } from "./useScheduleDetailQuery";
import {
useDeleteOrgScheduleMutation,
@@ -39,12 +36,22 @@ import {
} from "@/routes/workflows/editor/panels/schedulePanel/cronUtils";
import { cn } from "@/util/utils";
import { basicLocalTimeFormat, basicTimeFormat } from "@/util/timeFormat";
+import { ScheduleParametersSection } from "@/routes/workflows/components/ScheduleParametersSection";
+import {
+ buildScheduleParametersPayload,
+ formatScheduleParameterValue,
+ hasUserFacingParameters,
+ isScheduleParameter,
+} from "@/routes/workflows/components/scheduleParameters";
+import { useScheduleParameterState } from "@/routes/workflows/hooks/useScheduleParameterState";
+import type { Parameter } from "@/routes/workflows/types/workflowTypes";
+
+const allTimezones = getTimezones();
function ScheduleDetailPage() {
const navigate = useNavigate();
const location = useLocation();
const { workflowPermanentId, scheduleId } = useParams();
- const credentialGetter = useCredentialGetter();
const { data, isLoading, isError } = useScheduleDetailQuery(
workflowPermanentId,
scheduleId,
@@ -52,15 +59,8 @@ function ScheduleDetailPage() {
const titleFromState = (location.state as { workflowTitle?: string })
?.workflowTitle;
- const { data: workflow } = useQuery<WorkflowApiResponse>({
- queryKey: ["workflow", workflowPermanentId],
- queryFn: async () => {
- const client = await getClient(credentialGetter);
- return client
- .get(`/workflows/${workflowPermanentId}`)
- .then((r) => r.data);
- },
- enabled: !!workflowPermanentId && !titleFromState,
+ const { data: workflow, isSuccess: workflowLoaded } = useWorkflowQuery({
+ workflowPermanentId,
});
const workflowTitle =
titleFromState || workflow?.title || workflowPermanentId || "Schedule";
@@ -82,13 +82,27 @@ function ScheduleDetailPage() {
const [editName, setEditName] = useState("");
const [editDescription, setEditDescription] = useState("");
- const allTimezones = useMemo(() => getTimezones(), []);
+ const workflowParameters: ReadonlyArray<Parameter> = useMemo(
+ () => workflow?.workflow_definition.parameters ?? [],
+ [workflow],
+ );
+ const {
+ values: editParameters,
+ errors: parameterErrors,
+ handleChange: handleParameterChange,
+ validate: validateParameters,
+ reset: resetParameters,
+ } = useScheduleParameterState(
+ workflowParameters,
+ data?.schedule.parameters ?? null,
+ );
+
const filteredTimezones = useMemo(() => {
if (timezoneFilter === null) return allTimezones;
if (!timezoneFilter) return allTimezones;
const lower = timezoneFilter.toLowerCase();
return allTimezones.filter((tz) => tz.toLowerCase().includes(lower));
- }, [allTimezones, timezoneFilter]);
+ }, [timezoneFilter]);
// ! end TODO
const editValid = isValidCron(editCron);
@@ -120,16 +134,30 @@ function ScheduleDetailPage() {
setTimezoneFilter(null);
setEditName(schedule.name ?? "");
setEditDescription(schedule.description ?? "");
+ resetParameters();
setEditing(true);
}
function cancelEditing() {
setEditing(false);
setTimezoneFilter(null);
+ // Drop any in-progress parameter edits so they don't reappear on
+ // re-entry; re-seed from the stored schedule values.
+ resetParameters();
}
function handleSave() {
- if (!editValid || !workflowPermanentId || !scheduleId) return;
+ if (!workflowPermanentId || !scheduleId) return;
+ const parametersValid = validateParameters();
+ if (!editValid || !parametersValid) return;
+ // Only persist explicitly-set overrides. The form is seeded from
+ // workflow defaults, so blindly sending the whole values dict would
+ // pin the current default into the schedule and change semantics from
+ // "use workflow default at execution time" to "freeze current default".
+ const payload = buildScheduleParametersPayload(
+ editParameters,
+ workflowParameters,
+ );
updateMutation.mutate(
{
workflowPermanentId,
@@ -138,7 +166,7 @@ function ScheduleDetailPage() {
cron_expression: editCron,
timezone: editTimezone,
enabled: schedule.enabled,
- parameters: schedule.parameters,
+ parameters: payload,
...(editName && { name: editName }),
description: editDescription || undefined,
},
@@ -246,6 +274,10 @@ function ScheduleDetailPage() {
size="sm"
className="h-7 gap-1.5 px-2 text-xs"
onClick={startEditing}
+ disabled={!workflowLoaded}
+ title={
+ workflowLoaded ? undefined : "Loading workflow definition..."
+ }
>
<Pencil1Icon className="size-3" />
Edit
@@ -277,6 +309,14 @@ function ScheduleDetailPage() {
/>
</div>
+ <ScheduleParametersSection
+ parameters={workflowParameters}
+ values={editParameters}
+ onChange={handleParameterChange}
+ errors={parameterErrors}
+ disabled={updateMutation.isPending}
+ />
+
{/* Cron Presets */}
<div className="space-y-2">
<Label className="text-xs">Quick Presets</Label>
@@ -454,6 +494,50 @@ function ScheduleDetailPage() {
</div>
</div>
+ {hasUserFacingParameters(workflowParameters) && (
+ <div className="rounded-lg border border-slate-700 p-4">
+ <h3 className="mb-4 text-sm text-slate-400">
+ Workflow Parameters
+ </h3>
+ <div className="space-y-2">
+ {workflowParameters
+ .filter(isScheduleParameter)
+ .map((parameter) => {
+ const storedValue = schedule.parameters?.[parameter.key];
+ const hasValue =
+ storedValue !== undefined && storedValue !== null;
+ return (
+ <div
+ key={parameter.key}
+ className="flex items-start justify-between gap-4"
+ >
+ <span className="font-mono text-xs text-slate-400">
+ {parameter.key}
+ </span>
+ <span className="max-w-[60%] truncate text-right text-xs text-slate-50">
+ {hasValue ? (
+ formatScheduleParameterValue(storedValue)
+ ) : parameter.default_value !== null &&
+ parameter.default_value !== undefined ? (
+ <span className="italic text-slate-500">
+ default:{" "}
+ {formatScheduleParameterValue(
+ parameter.default_value,
+ )}
+ </span>
+ ) : (
+ <span className="italic text-slate-500">
+ (not set)
+ </span>
+ )}
+ </span>
+ </div>
+ );
+ })}
+ </div>
+ </div>
+ )}
+
<div className="rounded-lg border border-slate-700 p-4">
<h3 className="mb-4 text-sm text-slate-400">Upcoming Runs</h3>
<p className="mb-2 text-xs text-slate-400">
diff --git a/skyvern-frontend/src/routes/workflows/WorkflowParameterInput.tsx b/skyvern-frontend/src/routes/workflows/WorkflowParameterInput.tsx
index c254cc580..b3aa090c1 100644
--- a/skyvern-frontend/src/routes/workflows/WorkflowParameterInput.tsx
+++ b/skyvern-frontend/src/routes/workflows/WorkflowParameterInput.tsx
@@ -16,14 +16,24 @@ type Props = {
type: WorkflowParameterValueType;
value: unknown;
onChange: (value: unknown) => void;
+ required?: boolean;
+ disabled?: boolean;
};
-function WorkflowParameterInput({ type, value, onChange }: Props) {
+function WorkflowParameterInput({
+ type,
+ value,
+ onChange,
+ required,
+ disabled,
+}: Props) {
if (type === "json") {
return (
<CodeEditor
className="w-full"
language="json"
+ aria-required={required || undefined}
+ readOnly={disabled}
onChange={(value) => onChange(value)}
value={
typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -37,7 +47,9 @@ function WorkflowParameterInput({ type, value, onChange }: Props) {
if (type === "string") {
return (
<AutoResizingTextarea
- value={value as string}
+ aria-required={required || undefined}
+ disabled={disabled}
+ value={(value as string | null | undefined) ?? ""}
onChange={(e) => onChange(e.target.value)}
/>
);
@@ -46,6 +58,8 @@ function WorkflowParameterInput({ type, value, onChange }: Props) {
if (type === "integer") {
return (
<Input
+ aria-required={required || undefined}
+ disabled={disabled}
value={value === null ? "" : Number(value)}
onChange={(e) => {
const val = e.target.value;
@@ -60,6 +74,8 @@ function WorkflowParameterInput({ type, value, onChange }: Props) {
if (type === "float") {
return (
<Input
+ aria-required={required || undefined}
+ disabled={disabled}
value={value === null ? "" : Number(value)}
onChange={(e) => {
const val = e.target.value;
@@ -75,10 +91,11 @@ function WorkflowParameterInput({ type, value, onChange }: Props) {
if (type === "boolean") {
return (
<Select
+ disabled={disabled}
value={value === null ? "" : String(value)}
onValueChange={(v) => onChange(v === "true")}
>
- <SelectTrigger className="w-48">
+ <SelectTrigger aria-required={required || undefined} className="w-48">
<SelectValue placeholder="Select value..." />
</SelectTrigger>
<SelectContent>
@@ -92,6 +109,7 @@ function WorkflowParameterInput({ type, value, onChange }: Props) {
if (type === "file_url") {
return (
<FileUpload
+ required={required}
value={value as FileInputValue}
onChange={(value) => onChange(value)}
/>
@@ -102,11 +120,14 @@ function WorkflowParameterInput({ type, value, onChange }: Props) {
const credentialId = value as string | null;
return (
<CredentialSelector
+ required={required}
value={credentialId ?? ""}
onChange={(value) => onChange(value)}
/>
);
}
+
+ return null;
}
export { WorkflowParameterInput };
diff --git a/skyvern-frontend/src/routes/workflows/components/CodeEditor.tsx b/skyvern-frontend/src/routes/workflows/components/CodeEditor.tsx
index 3c7a6a263..fd48735ec 100644
--- a/skyvern-frontend/src/routes/workflows/components/CodeEditor.tsx
+++ b/skyvern-frontend/src/routes/workflows/components/CodeEditor.tsx
@@ -31,7 +31,7 @@ type Props = {
className?: string;
fontSize?: number;
fullHeight?: boolean;
-};
+} & Pick<React.HTMLAttributes<HTMLDivElement>, "aria-required">;
const fullHeightExtension = EditorView.theme({
"&": { height: "100%" },
@@ -49,6 +49,7 @@ function CodeEditor({
readOnly = false,
fontSize = 12,
fullHeight = false,
+ ...restProps
}: Props) {
const viewRef = useRef<EditorView | null>(null);
const [internalValue, setInternalValue] = useState(value);
@@ -127,6 +128,7 @@ function CodeEditor({
readOnly={readOnly}
className={cn("cursor-auto", className)}
style={style}
+ {...restProps}
onCreateEditor={(view) => {
viewRef.current = view;
}}
diff --git a/skyvern-frontend/src/routes/workflows/components/CredentialSelector.tsx b/skyvern-frontend/src/routes/workflows/components/CredentialSelector.tsx
index d6c5e1712..c52301026 100644
--- a/skyvern-frontend/src/routes/workflows/components/CredentialSelector.tsx
+++ b/skyvern-frontend/src/routes/workflows/components/CredentialSelector.tsx
@@ -22,9 +22,10 @@ type Props = {
value: string;
onChange: (value: string) => void;
placeholder?: string;
+ required?: boolean;
};
-function CredentialSelector({ value, onChange, placeholder }: Props) {
+function CredentialSelector({ value, onChange, placeholder, required }: Props) {
const { setIsOpen, setType } = useCredentialModalState();
const { data: credentials, isLoading } = useCredentialsQuery({
page_size: 100, // Reasonable limit for dropdown selector
@@ -51,7 +52,7 @@ function CredentialSelector({ value, onChange, placeholder }: Props) {
}
}}
>
- <SelectTrigger>
+ <SelectTrigger aria-required={required || undefined}>
<SelectValue placeholder={placeholder ?? "Select a credential"} />
</SelectTrigger>
<SelectContent>
diff --git a/skyvern-frontend/src/routes/workflows/components/ScheduleParametersSection.tsx b/skyvern-frontend/src/routes/workflows/components/ScheduleParametersSection.tsx
new file mode 100644
index 000000000..8a9b5327c
--- /dev/null
+++ b/skyvern-frontend/src/routes/workflows/components/ScheduleParametersSection.tsx
@@ -0,0 +1,91 @@
+import { Label } from "@/components/ui/label";
+import { WorkflowParameterInput } from "@/routes/workflows/WorkflowParameterInput";
+import type { Parameter } from "@/routes/workflows/types/workflowTypes";
+import { getLabelForWorkflowParameterType } from "@/routes/workflows/editor/workflowEditorUtils";
+import {
+ hasUserFacingParameters,
+ isRequired,
+ isScheduleParameter,
+} from "./scheduleParameters";
+
+type Props = {
+ parameters: ReadonlyArray<Parameter>;
+ values: Record<string, unknown>;
+ onChange: (key: string, value: unknown) => void;
+ errors?: Record<string, string | undefined>;
+ disabled?: boolean;
+};
+
+function ScheduleParametersSection({
+ parameters,
+ values,
+ onChange,
+ errors,
+ disabled,
+}: Readonly<Props>) {
+ if (!hasUserFacingParameters(parameters)) {
+ return null;
+ }
+
+ const workflowParameters = parameters.filter(isScheduleParameter);
+
+ return (
+ <div className="space-y-2">
+ <div className="space-y-1">
+ <Label>Workflow Parameters</Label>
+ <p className="text-xs text-slate-500">
+ Values supplied here are used every time this schedule runs.
+ </p>
+ </div>
+ <div className="space-y-4 rounded-md border border-slate-700 bg-slate-elevation3 p-3">
+ {workflowParameters.map((parameter) => {
+ const error = errors?.[parameter.key];
+ const required = isRequired(parameter);
+ return (
+ <div key={parameter.key} className="space-y-1.5">
+ <div className="flex items-center justify-between">
+ <Label className="text-xs">
+ {parameter.key}
+ {required && (
+ <span
+ aria-label="required"
+ className="ml-1 text-destructive"
+ >
+ *
+ </span>
+ )}
+ </Label>
+ <span className="text-[10px] uppercase tracking-wide text-slate-500">
+ {getLabelForWorkflowParameterType(
+ parameter.workflow_parameter_type,
+ )}
+ </span>
+ </div>
+ {parameter.description && (
+ <p className="text-xs text-slate-500">
+ {parameter.description}
+ </p>
+ )}
+ <fieldset disabled={disabled} className="contents">
+ <WorkflowParameterInput
+ type={parameter.workflow_parameter_type}
+ value={values[parameter.key] ?? null}
+ required={required}
+ disabled={disabled}
+ onChange={(next) => onChange(parameter.key, next)}
+ />
+ </fieldset>
+ {error && (
+ <p className="text-xs text-destructive" role="alert">
+ {error}
+ </p>
+ )}
+ </div>
+ );
+ })}
+ </div>
+ </div>
+ );
+}
+
+export { ScheduleParametersSection };
diff --git a/skyvern-frontend/src/routes/workflows/components/scheduleParameters.test.ts b/skyvern-frontend/src/routes/workflows/components/scheduleParameters.test.ts
new file mode 100644
index 000000000..c8cd7e566
--- /dev/null
+++ b/skyvern-frontend/src/routes/workflows/components/scheduleParameters.test.ts
@@ -0,0 +1,626 @@
+import { describe, test, expect } from "vitest";
+import {
+ isScheduleParameter,
+ isRequired,
+ isMissingRequiredValue,
+ hasUserFacingParameters,
+ buildInitialParameterValues,
+ buildScheduleParametersPayload,
+ formatScheduleParameterValue,
+ validateScheduleParameters,
+} from "./scheduleParameters";
+import type {
+ Parameter,
+ WorkflowParameter,
+} from "@/routes/workflows/types/workflowTypes";
+
+function makeWorkflowParam(
+ partial: Partial<WorkflowParameter> & {
+ key: string;
+ workflow_parameter_type: WorkflowParameter["workflow_parameter_type"];
+ },
+): WorkflowParameter {
+ return {
+ parameter_type: "workflow",
+ key: partial.key,
+ description: null,
+ workflow_parameter_type: partial.workflow_parameter_type,
+ default_value: partial.default_value ?? null,
+ // Cast-only fields the helpers never read:
+ workflow_parameter_id: "wp_test",
+ workflow_id: "w_test",
+ created_at: "2026-01-01T00:00:00Z",
+ modified_at: "2026-01-01T00:00:00Z",
+ deleted_at: null,
+ } as WorkflowParameter;
+}
+
+describe("isScheduleParameter", () => {
+ test("returns true for workflow parameters", () => {
+ const param = makeWorkflowParam({
+ key: "x",
+ workflow_parameter_type: "string",
+ });
+ expect(isScheduleParameter(param)).toBe(true);
+ });
+
+ test("returns false for context parameters", () => {
+ const param = { parameter_type: "context", key: "ctx" } as Parameter;
+ expect(isScheduleParameter(param)).toBe(false);
+ });
+
+ test("returns false for output parameters", () => {
+ const param = { parameter_type: "output", key: "out" } as Parameter;
+ expect(isScheduleParameter(param)).toBe(false);
+ });
+
+ test("returns false for aws_secret parameters", () => {
+ const param = { parameter_type: "aws_secret", key: "s" } as Parameter;
+ expect(isScheduleParameter(param)).toBe(false);
+ });
+});
+
+describe("isRequired", () => {
+ test("returns true for null default_value", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "string",
+ default_value: null,
+ });
+ expect(isRequired(p)).toBe(true);
+ });
+
+ test("returns true for undefined default_value", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "string",
+ });
+ // makeWorkflowParam coalesces undefined → null via ??, so explicitly set:
+ (p as { default_value: unknown }).default_value = undefined;
+ expect(isRequired(p)).toBe(true);
+ });
+
+ test("returns false for empty string default", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "string",
+ default_value: "",
+ });
+ expect(isRequired(p)).toBe(false);
+ });
+
+ test("returns false for false boolean default", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "boolean",
+ default_value: false,
+ });
+ expect(isRequired(p)).toBe(false);
+ });
+
+ test("returns false for 0 numeric default", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "integer",
+ default_value: 0,
+ });
+ expect(isRequired(p)).toBe(false);
+ });
+
+ test("returns false for non-empty string default", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "string",
+ default_value: "hello",
+ });
+ expect(isRequired(p)).toBe(false);
+ });
+});
+
+describe("isMissingRequiredValue", () => {
+ test("null is missing for every type", () => {
+ const types = [
+ "string",
+ "integer",
+ "float",
+ "boolean",
+ "json",
+ "file_url",
+ "credential_id",
+ ] as const;
+ for (const t of types) {
+ const p = makeWorkflowParam({ key: "k", workflow_parameter_type: t });
+ expect(isMissingRequiredValue(p, null)).toBe(true);
+ }
+ });
+
+ test("undefined is missing for every type", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "string",
+ });
+ expect(isMissingRequiredValue(p, undefined)).toBe(true);
+ });
+
+ test("empty string is NOT missing for string type", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "string",
+ });
+ expect(isMissingRequiredValue(p, "")).toBe(false);
+ });
+
+ test("empty string IS missing for integer/float/boolean/json/file_url/credential_id", () => {
+ const types = [
+ "integer",
+ "float",
+ "boolean",
+ "json",
+ "file_url",
+ "credential_id",
+ ] as const;
+ for (const t of types) {
+ const p = makeWorkflowParam({ key: "k", workflow_parameter_type: t });
+ expect(isMissingRequiredValue(p, "")).toBe(true);
+ }
+ });
+
+ test("whitespace-only string is missing for json", () => {
+ const p = makeWorkflowParam({ key: "k", workflow_parameter_type: "json" });
+ expect(isMissingRequiredValue(p, " ")).toBe(true);
+ });
+
+ test("whitespace-only string is missing for credential_id", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "credential_id",
+ });
+ expect(isMissingRequiredValue(p, " ")).toBe(true);
+ });
+
+ test("whitespace-only string is missing for integer/float/boolean", () => {
+ const types = ["integer", "float", "boolean"] as const;
+ for (const t of types) {
+ const p = makeWorkflowParam({ key: "k", workflow_parameter_type: t });
+ expect(isMissingRequiredValue(p, " ")).toBe(true);
+ }
+ });
+
+ test("whitespace-only string is missing for file_url", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "file_url",
+ });
+ expect(isMissingRequiredValue(p, " ")).toBe(true);
+ });
+
+ test("empty dict is missing for file_url", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "file_url",
+ });
+ expect(isMissingRequiredValue(p, {})).toBe(true);
+ });
+
+ test("file_url dict with empty s3uri is missing", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "file_url",
+ });
+ expect(isMissingRequiredValue(p, { s3uri: "" })).toBe(true);
+ });
+
+ test("file_url dict with non-empty s3uri is not missing", () => {
+ const p = makeWorkflowParam({
+ key: "k",
+ workflow_parameter_type: "file_url",
+ });
+ expect(isMissingRequiredValue(p, { s3uri: "s3://bucket/k" })).toBe(false);
+ });
+
+ test("valid values for each type are not missing", () => {
+ const cases: Array<
+ [WorkflowParameter["workflow_parameter_type"], unknown]
+ > = [
+ ["string", "hello"],
+ ["integer", 42],
+ ["float", 3.14],
+ ["boolean", true],
+ ["boolean", false],
+ ["json", '{"k": 1}'],
+ ["credential_id", "cred_abc"],
+ ];
+ for (const [t, v] of cases) {
+ const p = makeWorkflowParam({ key: "k", workflow_parameter_type: t });
+ expect(isMissingRequiredValue(p, v)).toBe(false);
+ }
+ });
+});
+
+describe("hasUserFacingParameters", () => {
+ test("returns false for empty array", () => {
+ expect(hasUserFacingParameters([])).toBe(false);
+ });
+
+ test("returns false when only context/output parameters exist", () => {
+ const params = [
+ { parameter_type: "context", key: "c" } as Parameter,
+ { parameter_type: "output", key: "o" } as Parameter,
+ ];
+ expect(hasUserFacingParameters(params)).toBe(false);
+ });
+
+ test("returns true when at least one workflow parameter exists", () => {
+ const params = [
+ { parameter_type: "context", key: "c" } as Parameter,
+ makeWorkflowParam({ key: "w", workflow_parameter_type: "string" }),
+ ];
+ expect(hasUserFacingParameters(params)).toBe(true);
+ });
+});
+
+describe("buildInitialParameterValues", () => {
+ test("returns empty object when no workflow parameters", () => {
+ expect(buildInitialParameterValues([], null)).toEqual({});
+ expect(buildInitialParameterValues([], {})).toEqual({});
+ });
+
+ test("seeds missing keys with parameter default_value", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "a",
+ workflow_parameter_type: "string",
+ default_value: "hello",
+ }),
+ makeWorkflowParam({
+ key: "b",
+ workflow_parameter_type: "integer",
+ default_value: 7,
+ }),
+ ];
+ expect(buildInitialParameterValues(params, null)).toEqual({
+ a: "hello",
+ b: 7,
+ });
+ });
+
+ test("existing values in stored override defaults", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "a",
+ workflow_parameter_type: "string",
+ default_value: "hello",
+ }),
+ ];
+ expect(buildInitialParameterValues(params, { a: "custom" })).toEqual({
+ a: "custom",
+ });
+ });
+
+ test("missing stored values with no default yield empty string for string type", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "a",
+ workflow_parameter_type: "string",
+ default_value: null,
+ }),
+ ];
+ expect(buildInitialParameterValues(params, null)).toEqual({ a: "" });
+ });
+
+ test("missing stored values with no default yield null for non-string types", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "n",
+ workflow_parameter_type: "integer",
+ default_value: null,
+ }),
+ makeWorkflowParam({
+ key: "b",
+ workflow_parameter_type: "boolean",
+ default_value: null,
+ }),
+ ];
+ expect(buildInitialParameterValues(params, null)).toEqual({
+ n: null,
+ b: null,
+ });
+ });
+
+ test("ignores unknown keys in stored (does not pass them through)", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "a",
+ workflow_parameter_type: "string",
+ default_value: null,
+ }),
+ ];
+ expect(buildInitialParameterValues(params, { a: "x", bogus: "y" })).toEqual(
+ { a: "x" },
+ );
+ });
+
+ test("json parameter with object default is stringified", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "j",
+ workflow_parameter_type: "json",
+ default_value: { foo: 1, bar: [2, 3] },
+ }),
+ ];
+ const result = buildInitialParameterValues(params, null);
+ expect(typeof result.j).toBe("string");
+ expect(JSON.parse(result.j as string)).toEqual({ foo: 1, bar: [2, 3] });
+ });
+
+ test("json parameter with string default is kept as-is", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "j",
+ workflow_parameter_type: "json",
+ default_value: '{"foo": 1}',
+ }),
+ ];
+ expect(buildInitialParameterValues(params, null)).toEqual({
+ j: '{"foo": 1}',
+ });
+ });
+
+ test('boolean parameter with string "true" default is coerced to true', () => {
+ const params = [
+ makeWorkflowParam({
+ key: "b",
+ workflow_parameter_type: "boolean",
+ default_value: "true",
+ }),
+ ];
+ expect(buildInitialParameterValues(params, null)).toEqual({ b: true });
+ });
+
+ test('boolean parameter with string "false" default is coerced to false', () => {
+ const params = [
+ makeWorkflowParam({
+ key: "b",
+ workflow_parameter_type: "boolean",
+ default_value: "false",
+ }),
+ ];
+ expect(buildInitialParameterValues(params, null)).toEqual({ b: false });
+ });
+
+ test("boolean parameter with actual true default is passed through", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "b",
+ workflow_parameter_type: "boolean",
+ default_value: true,
+ }),
+ ];
+ expect(buildInitialParameterValues(params, null)).toEqual({ b: true });
+ });
+
+ test("stored value overrides default without coercion", () => {
+ // Even if default_value would be stringified, an existing stored value
+ // (from an already-saved schedule) must be passed through verbatim so
+ // opening+saving the edit form is a no-op.
+ const params = [
+ makeWorkflowParam({
+ key: "j",
+ workflow_parameter_type: "json",
+ default_value: { foo: 1 },
+ }),
+ ];
+ // Stored value is already a string — passed through.
+ expect(buildInitialParameterValues(params, { j: '{"bar": 2}' })).toEqual({
+ j: '{"bar": 2}',
+ });
+ });
+});
+
+describe("formatScheduleParameterValue", () => {
+ test("null and undefined render as empty string", () => {
+ expect(formatScheduleParameterValue(null)).toBe("");
+ expect(formatScheduleParameterValue(undefined)).toBe("");
+ });
+
+ test("primitive strings render as-is", () => {
+ expect(formatScheduleParameterValue("hello")).toBe("hello");
+ expect(formatScheduleParameterValue("")).toBe("");
+ });
+
+ test("primitive numbers and booleans use String()", () => {
+ expect(formatScheduleParameterValue(42)).toBe("42");
+ expect(formatScheduleParameterValue(3.14)).toBe("3.14");
+ expect(formatScheduleParameterValue(true)).toBe("true");
+ expect(formatScheduleParameterValue(false)).toBe("false");
+ });
+
+ test("file_url dict with string s3uri unwraps to the URI", () => {
+ expect(formatScheduleParameterValue({ s3uri: "s3://bucket/key" })).toBe(
+ "s3://bucket/key",
+ );
+ });
+
+ test("file_url dict with non-string s3uri falls back to JSON", () => {
+ const value = { s3uri: null };
+ expect(formatScheduleParameterValue(value)).toBe(JSON.stringify(value));
+ });
+
+ test("plain objects render as JSON (not [object Object])", () => {
+ expect(formatScheduleParameterValue({ foo: 1, bar: [2, 3] })).toBe(
+ '{"foo":1,"bar":[2,3]}',
+ );
+ });
+
+ test("arrays render as JSON", () => {
+ expect(formatScheduleParameterValue([1, 2, 3])).toBe("[1,2,3]");
+ });
+});
+
+describe("validateScheduleParameters", () => {
+ test("returns empty object when all required values are present", () => {
+ const params = [
+ makeWorkflowParam({ key: "a", workflow_parameter_type: "string" }),
+ makeWorkflowParam({ key: "b", workflow_parameter_type: "integer" }),
+ ];
+ expect(validateScheduleParameters(params, { a: "hello", b: 7 })).toEqual(
+ {},
+ );
+ });
+
+ test("flags a single missing required parameter", () => {
+ const params = [
+ makeWorkflowParam({ key: "a", workflow_parameter_type: "integer" }),
+ ];
+ expect(validateScheduleParameters(params, {})).toEqual({ a: "Required" });
+ });
+
+ test("flags multiple missing required parameters", () => {
+ const params = [
+ makeWorkflowParam({ key: "a", workflow_parameter_type: "integer" }),
+ makeWorkflowParam({ key: "b", workflow_parameter_type: "boolean" }),
+ ];
+ expect(validateScheduleParameters(params, {})).toEqual({
+ a: "Required",
+ b: "Required",
+ });
+ });
+
+ test("ignores parameters that have a default value", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "a",
+ workflow_parameter_type: "integer",
+ default_value: 42,
+ }),
+ ];
+ expect(validateScheduleParameters(params, {})).toEqual({});
+ });
+
+ test("ignores non-workflow parameters (context, output, aws_secret)", () => {
+ const params: Parameter[] = [
+ { parameter_type: "context", key: "ctx" } as Parameter,
+ { parameter_type: "output", key: "out" } as Parameter,
+ { parameter_type: "aws_secret", key: "sec" } as Parameter,
+ ];
+ expect(validateScheduleParameters(params, {})).toEqual({});
+ });
+
+ test("flags whitespace-only string for json type (matches backend)", () => {
+ const params = [
+ makeWorkflowParam({ key: "j", workflow_parameter_type: "json" }),
+ ];
+ expect(validateScheduleParameters(params, { j: " " })).toEqual({
+ j: "Required",
+ });
+ });
+
+ test("does NOT flag empty string for plain string type", () => {
+ const params = [
+ makeWorkflowParam({ key: "s", workflow_parameter_type: "string" }),
+ ];
+ expect(validateScheduleParameters(params, { s: "" })).toEqual({});
+ });
+});
+
+describe("buildScheduleParametersPayload", () => {
+ test("returns null when there are no parameters", () => {
+ expect(buildScheduleParametersPayload({}, [])).toBeNull();
+ });
+
+ test("always includes required parameters even when empty string", () => {
+ const params = [
+ makeWorkflowParam({ key: "name", workflow_parameter_type: "string" }),
+ ];
+ expect(buildScheduleParametersPayload({ name: "" }, params)).toEqual({
+ name: "",
+ });
+ });
+
+ test("required parameters with values are included as-is", () => {
+ const params = [
+ makeWorkflowParam({ key: "name", workflow_parameter_type: "string" }),
+ makeWorkflowParam({ key: "n", workflow_parameter_type: "integer" }),
+ ];
+ expect(
+ buildScheduleParametersPayload({ name: "alice", n: 42 }, params),
+ ).toEqual({ name: "alice", n: 42 });
+ });
+
+ test("omits optional parameters whose value still matches the seeded default", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "greeting",
+ workflow_parameter_type: "string",
+ default_value: "hello",
+ }),
+ makeWorkflowParam({
+ key: "n",
+ workflow_parameter_type: "integer",
+ default_value: 5,
+ }),
+ ];
+ expect(
+ buildScheduleParametersPayload({ greeting: "hello", n: 5 }, params),
+ ).toBeNull();
+ });
+
+ test("includes optional parameter when user changed it from the default", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "greeting",
+ workflow_parameter_type: "string",
+ default_value: "hello",
+ }),
+ ];
+ expect(buildScheduleParametersPayload({ greeting: "hi" }, params)).toEqual({
+ greeting: "hi",
+ });
+ });
+
+ test("optional string cleared to empty is dropped (will use default at exec)", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "greeting",
+ workflow_parameter_type: "string",
+ default_value: "hello",
+ }),
+ ];
+ expect(buildScheduleParametersPayload({ greeting: "" }, params)).toBeNull();
+ });
+
+ test("drops empty file_url shaped objects for optional file_url params", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "doc",
+ workflow_parameter_type: "file_url",
+ default_value: "s3://default/key",
+ }),
+ ];
+ expect(
+ buildScheduleParametersPayload({ doc: { s3uri: "" } }, params),
+ ).toBeNull();
+ });
+
+ test("preserves boolean false set by user when default is true", () => {
+ const params = [
+ makeWorkflowParam({
+ key: "flag",
+ workflow_parameter_type: "boolean",
+ default_value: true,
+ }),
+ ];
+ expect(buildScheduleParametersPayload({ flag: false }, params)).toEqual({
+ flag: false,
+ });
+ });
+
+ test("ignores values for keys not in the parameter list", () => {
+ const params = [
+ makeWorkflowParam({ key: "a", workflow_parameter_type: "string" }),
+ ];
+ expect(
+ buildScheduleParametersPayload({ a: "hi", stale: "leftover" }, params),
+ ).toEqual({ a: "hi" });
+ });
+});
diff --git a/skyvern-frontend/src/routes/workflows/components/scheduleParameters.ts b/skyvern-frontend/src/routes/workflows/components/scheduleParameters.ts
new file mode 100644
index 000000000..f39472501
--- /dev/null
+++ b/skyvern-frontend/src/routes/workflows/components/scheduleParameters.ts
@@ -0,0 +1,329 @@
+import {
+ WorkflowParameterTypes,
+ type Parameter,
+ type WorkflowParameter,
+} from "@/routes/workflows/types/workflowTypes";
+
+/**
+ * Mirror of `_is_schedule_input_parameter` in
+ * skyvern/forge/sdk/workflow/service.py. Only `WorkflowParameter` instances
+ * (parameter_type === "workflow") are user-supplied for schedules.
+ */
+export function isScheduleParameter(
+ parameter: Parameter,
+): parameter is WorkflowParameter {
+ return parameter.parameter_type === WorkflowParameterTypes.Workflow;
+}
+
+/**
+ * A workflow parameter is "required" iff it has no default value. The form
+ * validators block submission until every required parameter has a value;
+ * parameters with defaults can be left blank and the backend will fall back
+ * to the default at execution time (see service.py:582-583).
+ */
+export function isRequired(parameter: WorkflowParameter): boolean {
+ return (
+ parameter.default_value === null || parameter.default_value === undefined
+ );
+}
+
+export function hasUserFacingParameters(
+ parameters: ReadonlyArray<Parameter>,
+): boolean {
+ return parameters.some(isScheduleParameter);
+}
+
+/**
+ * Compute the validation errors for a schedule parameter form. Returns
+ * a `{ key: "Required" }` map for every required parameter that is
+ * missing a value, mirroring the backend's loop in
+ * skyvern/forge/sdk/workflow/service.py:552-607. The caller decides
+ * what to do with the result — typically:
+ * const errors = validateScheduleParameters(workflowParameters, values);
+ * setParameterErrors(errors);
+ * if (Object.keys(errors).length > 0) return; // block submit
+ */
+export function validateScheduleParameters(
+ parameters: ReadonlyArray<Parameter>,
+ values: Record<string, unknown>,
+): Record<string, string> {
+ const errors: Record<string, string> = {};
+ for (const parameter of parameters) {
+ if (!isScheduleParameter(parameter)) continue;
+ if (!isRequired(parameter)) continue;
+ const value = values[parameter.key];
+ if (isMissingRequiredValue(parameter, value)) {
+ errors[parameter.key] = "Required";
+ }
+ }
+ return errors;
+}
+
+/**
+ * Format a stored schedule parameter value for read-only display in the
+ * schedule detail page. Plain `String(value)` produces "[object Object]"
+ * for `json` parameters with object values and for `file_url` parameters
+ * stored as `{ s3uri: "..." }` dicts. This helper unwraps a `s3uri` dict
+ * to its underlying URI string and falls back to `JSON.stringify` for
+ * other objects.
+ */
+export function formatScheduleParameterValue(value: unknown): string {
+ if (value === null || value === undefined) return "";
+ if (typeof value === "string") return value;
+ if (typeof value === "object") {
+ const obj = value as Record<string, unknown>;
+ if ("s3uri" in obj) {
+ const uri = obj.s3uri;
+ return typeof uri === "string" ? uri : JSON.stringify(value);
+ }
+ return JSON.stringify(value);
+ }
+ return String(value);
+}
+
+const BLANK_STRING_REQUIRED_TYPES = new Set<string>([
+ "json",
+ "credential_id",
+ "integer",
+ "float",
+ "boolean",
+]);
+
+function isBlankString(value: unknown): value is string {
+ return typeof value === "string" && value.trim() === "";
+}
+
+function isMissingFileUrlValue(value: unknown): boolean {
+ if (isBlankString(value)) return true;
+ if (typeof value !== "object" || value === null) return false;
+
+ const fileUrlValue = value as Record<string, unknown>;
+
+ return (
+ Object.keys(fileUrlValue).length === 0 ||
+ ("s3uri" in fileUrlValue &&
+ (fileUrlValue.s3uri === "" || fileUrlValue.s3uri == null))
+ );
+}
+
+/**
+ * Mirror of `_is_missing_required_value` in
+ * skyvern/forge/sdk/workflow/service.py:839. Keep these two in sync — if the
+ * backend rule changes, update both.
+ *
+ * Rules:
+ * - null/undefined is always missing
+ * - string parameters allow empty strings (per UI behavior comment in backend)
+ * - json / boolean / integer / float / credential_id treat empty/whitespace as missing
+ * - file_url treats empty string, empty dict, or dict with empty s3uri as missing
+ */
+export function isMissingRequiredValue(
+ parameter: WorkflowParameter,
+ value: unknown,
+): boolean {
+ if (value == null) return true;
+
+ const parameterType = parameter.workflow_parameter_type;
+
+ if (parameterType === "string") {
+ return false; // backend allows empty strings
+ }
+
+ if (parameterType === "file_url") {
+ return isMissingFileUrlValue(value);
+ }
+
+ if (BLANK_STRING_REQUIRED_TYPES.has(parameterType)) {
+ return isBlankString(value);
+ }
+
+ return false;
+}
+
+function hasStoredValue(
+ storedValues: Record<string, unknown> | null | undefined,
+ key: string,
+): storedValues is Record<string, unknown> {
+ return (
+ storedValues != null &&
+ Object.prototype.hasOwnProperty.call(storedValues, key)
+ );
+}
+
+function normalizeDefaultValue(parameter: WorkflowParameter): unknown {
+ const {
+ default_value: defaultValue,
+ workflow_parameter_type: parameterType,
+ } = parameter;
+
+ if (parameterType === "json") {
+ return typeof defaultValue === "string"
+ ? defaultValue
+ : JSON.stringify(defaultValue, null, 2);
+ }
+
+ if (parameterType === "boolean") {
+ // Backend stores booleans as strings; coerce to real boolean for the form.
+ return defaultValue === true || defaultValue === "true";
+ }
+
+ return defaultValue;
+}
+
+function resolveInitialParameterValue(
+ parameter: WorkflowParameter,
+ storedValues: Record<string, unknown> | null | undefined,
+): unknown {
+ const {
+ key,
+ default_value: defaultValue,
+ workflow_parameter_type: parameterType,
+ } = parameter;
+
+ if (hasStoredValue(storedValues, key)) {
+ return storedValues[key];
+ }
+
+ if (defaultValue != null) {
+ return normalizeDefaultValue(parameter);
+ }
+
+ return parameterType === "string" ? "" : null;
+}
+
+/**
+ * Build the parameters payload to send to the backend on schedule
+ * create/update. The schedule parameter form is seeded with a value for
+ * every workflow parameter (default-or-blank), and we want to:
+ *
+ * 1. Always include REQUIRED parameters (no default_value), even when
+ * the value is an empty string. The backend's
+ * `_is_missing_required_value` allows `""` for the `string` type, so
+ * stripping empty strings here would let an empty required string
+ * pass client validation but get dropped from the payload — at which
+ * point the backend treats the key as missing and 400s.
+ * 2. For OPTIONAL parameters (have a default_value), omit any value
+ * that still matches the seeded initial. Persisting an untouched
+ * default would pin it into the schedule and change semantics from
+ * "use workflow default at execution time" to "freeze current
+ * default", causing silent drift after the workflow default changes.
+ * 3. Strip placeholder empties (`""`, `{}`, `{ s3uri: "" }`) for
+ * non-required parameters so the backend doesn't reject the key.
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+ return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+function sanitizeOptionalValue(value: unknown): unknown {
+ if (value == null) return undefined;
+ if (typeof value === "string") {
+ return value.trim() === "" ? undefined : value;
+ }
+ if (Array.isArray(value)) {
+ const sanitized = value
+ .map((item) => sanitizeOptionalValue(item))
+ .filter((item) => item !== undefined);
+ return sanitized.length > 0 ? sanitized : undefined;
+ }
+ if (isPlainObject(value)) {
+ if (isMissingFileUrlValue(value)) return undefined;
+ const entries = Object.entries(value).flatMap(([key, nested]) => {
+ const sanitized = sanitizeOptionalValue(nested);
+ return sanitized === undefined ? [] : ([[key, sanitized]] as const);
+ });
+ return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+ }
+ return value;
+}
+
+function deepEqual(a: unknown, b: unknown): boolean {
+ if (a === b) return true;
+ if (a == null || b == null) return false;
+ if (typeof a !== typeof b) return false;
+ if (Array.isArray(a) && Array.isArray(b)) {
+ if (a.length !== b.length) return false;
+ return a.every((item, idx) => deepEqual(item, b[idx]));
+ }
+ if (isPlainObject(a) && isPlainObject(b)) {
+ const keysA = Object.keys(a);
+ const keysB = Object.keys(b);
+ if (keysA.length !== keysB.length) return false;
+ return keysA.every(
+ (key) =>
+ Object.prototype.hasOwnProperty.call(b, key) &&
+ deepEqual(a[key], b[key]),
+ );
+ }
+ return false;
+}
+
+export function buildScheduleParametersPayload(
+ values: Record<string, unknown>,
+ parameters: ReadonlyArray<Parameter>,
+): Record<string, unknown> | null {
+ const result: Record<string, unknown> = {};
+
+ for (const parameter of parameters) {
+ if (!isScheduleParameter(parameter)) continue;
+
+ const key = parameter.key;
+ if (!Object.prototype.hasOwnProperty.call(values, key)) continue;
+ const value = values[key];
+
+ if (isRequired(parameter)) {
+ // Required parameters must always round-trip — even an empty
+ // string for required `string` (which the backend allows).
+ result[key] =
+ value == null && parameter.workflow_parameter_type === "string"
+ ? ""
+ : value;
+ continue;
+ }
+
+ // Optional parameter: omit if it still matches the seeded default.
+ const seeded = resolveInitialParameterValue(parameter, null);
+ if (deepEqual(value, seeded)) continue;
+
+ const sanitized = sanitizeOptionalValue(value);
+ if (sanitized === undefined) continue;
+ result[key] = sanitized;
+ }
+
+ return Object.keys(result).length > 0 ? result : null;
+}
+
+/**
+ * Schedule-flavored variant of `getInitialValues` in
+ * `skyvern-frontend/src/routes/workflows/utils.ts`.
+ *
+ * Differs from the run-form equivalent in three ways:
+ * - Reads stored values from a `storedValues` record instead of router state
+ * - Narrows `Parameter[]` to schedule-editable workflow parameters via `isScheduleParameter`
+ * - Drops unknown keys from `storedValues` so removed workflow parameters
+ * do not leak into the submission payload
+ *
+ * Keep the JSON / boolean default coercion logic aligned with
+ * `getInitialValues` so both helpers produce consistent form state.
+ *
+ * Builds the initial values record for a schedule form. Each user-facing
+ * workflow parameter is seeded with:
+ * 1. the value already stored on the schedule, else
+ * 2. the parameter's `default_value`, else
+ * 3. an empty string for `"string"` parameters, `null` otherwise.
+ */
+export function buildInitialParameterValues(
+ parameters: ReadonlyArray<Parameter>,
+ storedValues: Record<string, unknown> | null | undefined,
+): Record<string, unknown> {
+ const initialValues: Record<string, unknown> = {};
+
+ for (const parameter of parameters) {
+ if (!isScheduleParameter(parameter)) continue;
+ initialValues[parameter.key] = resolveInitialParameterValue(
+ parameter,
+ storedValues,
+ );
+ }
+
+ return initialValues;
+}
diff --git a/skyvern-frontend/src/routes/workflows/editor/panels/schedulePanel/CreateScheduleDialog.tsx b/skyvern-frontend/src/routes/workflows/editor/panels/schedulePanel/CreateScheduleDialog.tsx
index aaac0482d..3ec14b4eb 100644
--- a/skyvern-frontend/src/routes/workflows/editor/panels/schedulePanel/CreateScheduleDialog.tsx
+++ b/skyvern-frontend/src/routes/workflows/editor/panels/schedulePanel/CreateScheduleDialog.tsx
@@ -1,4 +1,4 @@
-import { useState, useMemo } from "react";
+import { useEffect, useMemo, useState } from "react";
import { Button } from "@/components/ui/button";
import {
Dialog,
@@ -12,6 +12,10 @@ import {
import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
import { PlusIcon } from "@radix-ui/react-icons";
+import type { Parameter } from "@/routes/workflows/types/workflowTypes";
+import { ScheduleParametersSection } from "@/routes/workflows/components/ScheduleParametersSection";
+import { buildScheduleParametersPayload } from "@/routes/workflows/components/scheduleParameters";
+import { useScheduleParameterState } from "@/routes/workflows/hooks/useScheduleParameterState";
import {
CRON_PRESETS,
cronToHumanReadable,
@@ -24,24 +28,48 @@ import {
import { cn } from "@/util/utils";
type Props = {
+ workflowParameters: ReadonlyArray<Parameter>;
onSubmit: (
cronExpression: string,
timezone: string,
name: string,
description: string,
+ parameters: Record<string, unknown> | null,
callbacks: { onSuccess: () => void },
) => void;
isPending?: boolean;
};
-function CreateScheduleDialog({ onSubmit, isPending }: Props) {
+function CreateScheduleDialog({
+ workflowParameters,
+ onSubmit,
+ isPending,
+}: Readonly<Props>) {
const [open, setOpen] = useState(false);
const [cronExpression, setCronExpression] = useState("0 9 * * *");
const [timezone, setTimezone] = useState(getLocalTimezone);
- // TODO - Create shared util
const [timezoneFilter, setTimezoneFilter] = useState<string | null>(null);
const [name, setName] = useState("");
const [description, setDescription] = useState("");
+ const {
+ values: parameters,
+ errors: parameterErrors,
+ handleChange: handleParameterChange,
+ validate: validateParameters,
+ reset: resetParameters,
+ } = useScheduleParameterState(workflowParameters);
+
+ // Re-seed parameter state if the workflow definition resolves after mount
+ // (e.g., the query was still loading when this dialog mounted) or if the
+ // workflow's parameters change while the dialog is closed. Also re-fires
+ // when the workflowParameters reference changes so newly-arrived
+ // definitions get seeded with their defaults. Skipped while the dialog is
+ // open so we don't clobber user input mid-edit.
+ useEffect(() => {
+ if (!open) {
+ resetParameters();
+ }
+ }, [open, workflowParameters, resetParameters]);
const allTimezones = useMemo(() => getTimezones(), []);
const filteredTimezones = useMemo(() => {
@@ -50,28 +78,43 @@ function CreateScheduleDialog({ onSubmit, isPending }: Props) {
const lower = timezoneFilter.toLowerCase();
return allTimezones.filter((tz) => tz.toLowerCase().includes(lower));
}, [allTimezones, timezoneFilter]);
- // ! end TODO
const valid = isValidCron(cronExpression);
const humanReadable = valid ? cronToHumanReadable(cronExpression) : null;
const nextRuns = valid ? getNextRuns(cronExpression, timezone, 5) : [];
- const handleSubmit = () => {
- if (!valid) return;
- onSubmit(cronExpression, timezone, name, description, {
+ function resetFormState() {
+ setCronExpression("0 9 * * *");
+ setTimezone(getLocalTimezone());
+ setTimezoneFilter(null);
+ setName("");
+ setDescription("");
+ resetParameters();
+ }
+
+ function handleSubmit() {
+ const parametersValid = validateParameters();
+ if (!valid || !parametersValid) return;
+ const payload = buildScheduleParametersPayload(
+ parameters,
+ workflowParameters,
+ );
+ onSubmit(cronExpression, timezone, name, description, payload, {
onSuccess: () => {
setOpen(false);
- setCronExpression("0 9 * * *");
- setTimezone(getLocalTimezone());
- setTimezoneFilter(null);
- setName("");
- setDescription("");
+ resetFormState();
},
});
- };
+ }
return (
- <Dialog open={open} onOpenChange={setOpen}>
+ <Dialog
+ open={open}
+ onOpenChange={(next) => {
+ setOpen(next);
+ if (!next) resetFormState();
+ }}
+ >
<DialogTrigger asChild>
<Button variant="outline" size="sm" className="h-8 gap-1.5">
<PlusIcon className="size-3" />
@@ -87,7 +130,6 @@ function CreateScheduleDialog({ onSubmit, isPending }: Props) {
</DialogHeader>
<div className="space-y-6 py-4">
- {/* Schedule Name & Description */}
<div className="space-y-2">
<Label>Name (optional)</Label>
<Input
@@ -105,7 +147,14 @@ function CreateScheduleDialog({ onSubmit, isPending }: Props) {
/>
</div>
- {/* Cron Presets */}
+ <ScheduleParametersSection
+ parameters={workflowParameters}
+ values={parameters}
+ onChange={handleParameterChange}
+ errors={parameterErrors}
+ disabled={isPending}
+ />
+
<div className="space-y-2">
<Label>Quick Presets</Label>
<div className="flex flex-wrap gap-2">
@@ -126,7 +175,6 @@ function CreateScheduleDialog({ onSubmit, isPending }: Props) {
</div>
</div>
- {/* Custom Cron Input */}
<div className="space-y-2">
<Label>Cron Expression</Label>
<Input
@@ -145,7 +193,6 @@ function CreateScheduleDialog({ onSubmit, isPending }: Props) {
)}
</div>
- {/* Timezone Selector */}
<div className="space-y-2">
<Label>Timezone</Label>
<Input
@@ -192,7 +239,6 @@ function CreateScheduleDialog({ onSubmit, isPending }: Props) {
<p className="text-xs text-slate-500">Current: {timezone}</p>
</div>
- {/* Next Runs Preview */}
{nextRuns.length > 0 && (
<div className="space-y-2">
<Label>Next Scheduled Runs</Label>
diff --git a/skyvern-frontend/src/routes/workflows/editor/panels/schedulePanel/WorkflowSchedulePanel.tsx b/skyvern-frontend/src/routes/workflows/editor/panels/schedulePanel/WorkflowSchedulePanel.tsx
index 6edc1354f..f3678137c 100644
--- a/skyvern-frontend/src/routes/workflows/editor/panels/schedulePanel/WorkflowSchedulePanel.tsx
+++ b/skyvern-frontend/src/routes/workflows/editor/panels/schedulePanel/WorkflowSchedulePanel.tsx
@@ -14,10 +14,12 @@ import {
useToggleScheduleMutation,
useDeleteScheduleMutation,
} from "@/routes/workflows/hooks/useScheduleMutations";
+import { useWorkflowQuery } from "@/routes/workflows/hooks/useWorkflowQuery";
import { ScheduleCard } from "./ScheduleCard";
import { CreateScheduleDialog } from "./CreateScheduleDialog";
import { ReloadIcon } from "@radix-ui/react-icons";
import { useState } from "react";
+import { useParams } from "react-router-dom";
function WorkflowSchedulePanel() {
const {
@@ -34,11 +36,16 @@ function WorkflowSchedulePanel() {
scheduleId: string | null;
}>({ open: false, scheduleId: null });
+ const { workflowPermanentId } = useParams();
+ const { data: workflow } = useWorkflowQuery({ workflowPermanentId });
+ const workflowParameters = workflow?.workflow_definition.parameters ?? [];
+
const handleCreate = (
cronExpression: string,
timezone: string,
name: string,
description: string,
+ parameters: Record<string, unknown> | null,
callbacks: { onSuccess: () => void },
) => {
createSchedule.mutate(
@@ -48,6 +55,7 @@ function WorkflowSchedulePanel() {
enabled: true,
...(name && { name }),
...(description && { description }),
+ ...(parameters && { parameters }),
},
{ onSuccess: callbacks.onSuccess },
);
@@ -75,6 +83,7 @@ function WorkflowSchedulePanel() {
{schedules && schedules.length > 0 ? ` (${schedules.length})` : ""}
</h3>
<CreateScheduleDialog
+ workflowParameters={workflowParameters}
onSubmit={handleCreate}
isPending={createSchedule.isPending}
/>
diff --git a/skyvern-frontend/src/routes/workflows/hooks/useScheduleParameterState.test.ts b/skyvern-frontend/src/routes/workflows/hooks/useScheduleParameterState.test.ts
new file mode 100644
index 000000000..7c29f4bbe
--- /dev/null
+++ b/skyvern-frontend/src/routes/workflows/hooks/useScheduleParameterState.test.ts
@@ -0,0 +1,151 @@
+import { describe, expect, test } from "vitest";
+import type {
+ Parameter,
+ WorkflowParameter,
+} from "@/routes/workflows/types/workflowTypes";
+import {
+ applyScheduleParameterChange,
+ createScheduleParameterState,
+ getScheduleParameterValidationResult,
+} from "./useScheduleParameterState";
+
+function makeWorkflowParam(
+ partial: Partial<WorkflowParameter> & {
+ key: string;
+ workflow_parameter_type: WorkflowParameter["workflow_parameter_type"];
+ },
+): WorkflowParameter {
+ return {
+ parameter_type: "workflow",
+ key: partial.key,
+ description: null,
+ workflow_parameter_type: partial.workflow_parameter_type,
+ default_value: partial.default_value ?? null,
+ workflow_parameter_id: "wp_test",
+ workflow_id: "w_test",
+ created_at: "2026-01-01T00:00:00Z",
+ modified_at: "2026-01-01T00:00:00Z",
+ deleted_at: null,
+ } as WorkflowParameter;
+}
+
+describe("createScheduleParameterState", () => {
+ test("builds values from workflow defaults when no stored values exist", () => {
+ const workflowParameters: ReadonlyArray<Parameter> = [
+ makeWorkflowParam({
+ key: "name",
+ workflow_parameter_type: "string",
+ }),
+ makeWorkflowParam({
+ key: "enabled",
+ workflow_parameter_type: "boolean",
+ default_value: "true",
+ }),
+ ];
+
+ expect(createScheduleParameterState(workflowParameters, null)).toEqual({
+ values: {
+ name: "",
+ enabled: true,
+ },
+ errors: {},
+ });
+ });
+
+ test("prefers stored values over workflow defaults", () => {
+ const workflowParameters: ReadonlyArray<Parameter> = [
+ makeWorkflowParam({
+ key: "payload",
+ workflow_parameter_type: "json",
+ default_value: { foo: "default" },
+ }),
+ makeWorkflowParam({
+ key: "count",
+ workflow_parameter_type: "integer",
+ default_value: 1,
+ }),
+ ];
+
+ expect(
+ createScheduleParameterState(workflowParameters, {
+ payload: '{"foo":"custom"}',
+ count: 5,
+ }),
+ ).toEqual({
+ values: {
+ payload: '{"foo":"custom"}',
+ count: 5,
+ },
+ errors: {},
+ });
+ });
+});
+
+describe("applyScheduleParameterChange", () => {
+ test("updates the parameter value and clears only that parameter's error", () => {
+ const nextState = applyScheduleParameterChange(
+ {
+ values: {
+ source: "",
+ untouched: 1,
+ },
+ errors: {
+ source: "Required",
+ untouched: "Required",
+ },
+ },
+ "source",
+ "https://example.com",
+ );
+
+ expect(nextState).toEqual({
+ values: {
+ source: "https://example.com",
+ untouched: 1,
+ },
+ errors: {
+ untouched: "Required",
+ },
+ });
+ });
+});
+
+describe("getScheduleParameterValidationResult", () => {
+ test("returns the validation errors and invalid status", () => {
+ const workflowParameters: ReadonlyArray<Parameter> = [
+ makeWorkflowParam({
+ key: "credential",
+ workflow_parameter_type: "credential_id",
+ }),
+ ];
+
+ expect(
+ getScheduleParameterValidationResult(workflowParameters, {
+ credential: "",
+ }),
+ ).toEqual({
+ errors: {
+ credential: "Required",
+ },
+ isValid: false,
+ });
+ });
+
+ test("returns an empty error map when all required parameters are present", () => {
+ const workflowParameters: ReadonlyArray<Parameter> = [
+ makeWorkflowParam({
+ key: "threshold",
+ workflow_parameter_type: "float",
+ }),
+ ];
+
+ expect(
+ getScheduleParameterValidationResult(workflowParameters, {
+ threshold: 3.14,
+ }),
+ ).toEqual({
+ errors: {},
+ isValid: true,
+ });
+ });
+});
diff --git a/skyvern-frontend/src/routes/workflows/hooks/useScheduleParameterState.ts b/skyvern-frontend/src/routes/workflows/hooks/useScheduleParameterState.ts
new file mode 100644
index 000000000..cc607a572
--- /dev/null
+++ b/skyvern-frontend/src/routes/workflows/hooks/useScheduleParameterState.ts
@@ -0,0 +1,124 @@
+import { useCallback, useRef, useState } from "react";
+import type { Parameter } from "@/routes/workflows/types/workflowTypes";
+import {
+ buildInitialParameterValues,
+ validateScheduleParameters,
+} from "@/routes/workflows/components/scheduleParameters";
+
+type ScheduleParameterValues = Record<string, unknown>;
+type ScheduleParameterErrors = Record<string, string | undefined>;
+type ScheduleParameterState = {
+ values: ScheduleParameterValues;
+ errors: ScheduleParameterErrors;
+};
+
+function createScheduleParameterState(
+ workflowParameters: ReadonlyArray<Parameter>,
+ storedValues: Record<string, unknown> | null = null,
+): ScheduleParameterState {
+ return {
+ values: buildInitialParameterValues(workflowParameters, storedValues),
+ errors: {},
+ };
+}
+
+function clearScheduleParameterError(
+ errors: ScheduleParameterErrors,
+ key: string,
+): ScheduleParameterErrors {
+ if (!errors[key]) {
+ return errors;
+ }
+
+ const nextErrors = { ...errors };
+ delete nextErrors[key];
+ return nextErrors;
+}
+
+function applyScheduleParameterChange(
+ state: ScheduleParameterState,
+ key: string,
+ value: unknown,
+): ScheduleParameterState {
+ return {
+ values: { ...state.values, [key]: value },
+ errors: clearScheduleParameterError(state.errors, key),
+ };
+}
+
+function getScheduleParameterValidationResult(
+ workflowParameters: ReadonlyArray<Parameter>,
+ values: ScheduleParameterValues,
+): { errors: ScheduleParameterErrors; isValid: boolean } {
+ const errors = validateScheduleParameters(workflowParameters, values);
+ return {
+ errors,
+ isValid: Object.keys(errors).length === 0,
+ };
+}
+
+function useScheduleParameterState(
+ workflowParameters: ReadonlyArray<Parameter>,
+ storedValues: Record<string, unknown> | null = null,
+) {
+ const [values, setValues] = useState<ScheduleParameterValues>(() =>
+ buildInitialParameterValues(workflowParameters, storedValues),
+ );
+ const [errors, setErrors] = useState<ScheduleParameterErrors>({});
+ const valuesRef = useRef(values);
+ valuesRef.current = values;
+
+ const handleChange = useCallback((key: string, value: unknown) => {
+ setValues((prevValues) => {
+ const next = { ...prevValues, [key]: value };
+ valuesRef.current = next;
+ return next;
+ });
+ setErrors((prevErrors) => clearScheduleParameterError(prevErrors, key));
+ }, []);
+
+ const validate = useCallback(() => {
+ const result = getScheduleParameterValidationResult(
+ workflowParameters,
+ valuesRef.current,
+ );
+ setErrors(result.errors);
+ return result.isValid;
+ }, [workflowParameters]);
+
+ const reset = useCallback(
+ (nextStoredValues: Record<string, unknown> | null = storedValues) => {
+ const nextState = createScheduleParameterState(
+ workflowParameters,
+ nextStoredValues,
+ );
+ valuesRef.current = nextState.values;
+ setValues(nextState.values);
+ setErrors(nextState.errors);
+ },
+ [storedValues, workflowParameters],
+ );
+
+ const clear = useCallback(() => {
+ valuesRef.current = {};
+ setValues({});
+ setErrors({});
+ }, []);
+
+ return {
+ values,
+ errors,
+ handleChange,
+ validate,
+ reset,
+ clear,
+ };
+}
+
+export {
+ applyScheduleParameterChange,
+ clearScheduleParameterError,
+ createScheduleParameterState,
+ getScheduleParameterValidationResult,
+ useScheduleParameterState,
+};