diff --git a/.github/workflows/framework.yaml b/.github/workflows/framework.yaml
index 5de51cca7cad..bdf4db719f16 100644
--- a/.github/workflows/framework.yaml
+++ b/.github/workflows/framework.yaml
@@ -26,6 +26,7 @@ jobs:
     strategy:
       matrix:
         python-version: ['3.7']
+        use-legacy-api: ['0', '1']
     services:
       postgres:
         image: postgres:13
@@ -66,7 +67,7 @@ jobs:
           path: 'galaxy root/.venv'
           key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-framework
       - name: Run tests
-        run: ./run_tests.sh --coverage --framework
+        run: GALAXY_TEST_USE_LEGACY_TOOL_API="${{ matrix.use-legacy-api }}" ./run_tests.sh --coverage --framework
         working-directory: 'galaxy root'
       - uses: codecov/codecov-action@v3
         with:
diff --git a/.gitignore b/.gitignore
index fd3864c71cd2..7950718e63a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -154,6 +154,7 @@ doc/build
 doc/schema.md
 doc/source/admin/config_logging_default_yaml.rst
 doc/source/dev/schema.md
+doc/source/dev/plantuml.jar
 client/docs/dist
 
 # Webpack stats
diff --git a/client/src/components/Tool/ToolForm.vue b/client/src/components/Tool/ToolForm.vue
index cf1a0935485c..057fc7943b08 100644
--- a/client/src/components/Tool/ToolForm.vue
+++ b/client/src/components/Tool/ToolForm.vue
@@ -50,7 +50,6 @@
                             @onChange="onChange"
                             @onValidation="onValidation" />
                     </div>
-
                     <div
                         v-if="emailAllowed(config, currentUser) || remapAllowed || reuseAllowed(currentUser)"
                         class="mt-2 mb-4">
@@ -81,7 +80,7 @@
                 <template v-slot:header-buttons>
                     <ButtonSpinner
                         id="execute"
-                        title="Run Tool"
+                        title="runButtonTitle"
                         class="btn-sm"
                         :wait="showExecuting"
                         :tooltip="tooltip"
@@ -89,7 +88,7 @@
                 </template>
                 <template v-slot:buttons>
                     <ButtonSpinner
-                        title="Run Tool"
+                        title="runButtonTitle"
                         class="mt-3 mb-3"
                         :wait="showExecuting"
                         :tooltip="tooltip"
@@ -101,13 +100,15 @@
 </template>
 
 <script>
+import { getAppRoot } from "onload/loadConfig";
+import axios from "axios";
 import { getGalaxyInstance } from "app";
 import { useUserStore } from "@/stores/userStore";
 import { useHistoryStore } from "@/stores/historyStore";
 import { useHistoryItemsStore } from "stores/history/historyItemsStore";
 import { useJobStore } from "stores/jobStore";
 import { mapState, mapActions } from "pinia";
-import { getToolFormData, updateToolFormData, submitJob } from "./services";
+import { getToolFormData, getToolInputs, updateToolFormData, submitJob, submitToolRequest } from "./services";
 import { allowCachedJobs } from "./utilities";
 import { refreshContentsWrapper } from "utils/data";
 import ToolCard from "./ToolCard";
@@ -119,6 +120,7 @@ import FormElement from "components/Form/FormElement";
 import ToolEntryPoints from "components/ToolEntryPoints/ToolEntryPoints";
 import ToolRecommendation from "../ToolRecommendation";
 import Heading from "components/Common/Heading";
+import { structuredInputs } from "./structured";
 
 export default {
     components: {
@@ -178,6 +180,8 @@ export default {
             validationScrollTo: null,
             currentVersion: this.version,
             preferredObjectStoreId: null,
+            toolInputs: null,
+            submissionStateMessage: null,
         };
     },
     computed: {
@@ -216,6 +220,17 @@ export default {
         initialized() {
             return this.formData !== undefined;
         },
+        runButtonTitle() {
+            if (this.showExecuting) {
+                if (this.submissionStateMessage) {
+                    return this.submissionStateMessage;
+                } else {
+                    return "Run Tool";
+                }
+            } else {
+                return "Run Tool";
+            }
+        },
     },
     watch: {
         currentHistoryId() {
@@ -266,10 +281,37 @@ export default {
         onChangeVersion(newVersion) {
             this.requestTool(newVersion);
         },
+        waitOnRequest(response, requestContent, config, prevRoute) {
+            const toolRequestId = response.tool_request_id;
+            const handleRequestState = (toolRequestStateResponse) => {
+                const state = toolRequestStateResponse.data;
+                console.log(`state is ${state}`);
+                if (["new"].indexOf(state) !== -1) {
+                    setTimeout(doRequestCheck, 1000);
+                } else if (state == "failed") {
+                    this.handleError(null, requestContent);
+                } else {
+                    refreshContentsWrapper();
+                    this.showForm = false;
+                    this.showSuccess = true;
+                    this.handleSubmissionComplete(config, prevRoute);
+                }
+            };
+            const doRequestCheck = () => {
+                axios
+                    .get(`${getAppRoot()}api/tool_requests/${toolRequestId}/state`)
+                    .then(handleRequestState)
+                    .catch((e) => this.handleError(e, requestContent));
+            };
+            setTimeout(doRequestCheck, 1000);
+        },
         requestTool(newVersion) {
             this.currentVersion = newVersion || this.currentVersion;
             this.disabled = true;
             console.debug("ToolForm - Requesting tool.", this.id);
+            getToolInputs(this.id, this.currentVersion).then((data) => {
+                this.toolInputs = data;
+            });
             return getToolFormData(this.id, this.currentVersion, this.job_id, this.history_id)
                 .then((data) => {
                     this.formConfig = data;
@@ -294,87 +336,129 @@ export default {
         onUpdatePreferredObjectStoreId(preferredObjectStoreId) {
             this.preferredObjectStoreId = preferredObjectStoreId;
         },
+        handleSubmissionComplete(config, prevRoute) {
+            const changeRoute = prevRoute === this.$route.fullPath;
+            if (changeRoute) {
+                this.$router.push(`/jobs/submission/success`);
+            } else {
+                if ([true, "true"].includes(config.enable_tool_recommendations)) {
+                    this.showRecommendation = true;
+                }
+                document.querySelector(".center-panel").scrollTop = 0;
+            }
+        },
+        handleError(e, errorContent) {
+            this.errorMessage = e?.response?.data?.err_msg;
+            this.showExecuting = false;
+            this.submissionStateMessage = null;
+            let genericError = true;
+            const errorData = e && e.response && e.response.data && e.response.data.err_data;
+            if (errorData) {
+                const errorEntries = Object.entries(errorData);
+                if (errorEntries.length > 0) {
+                    this.validationScrollTo = errorEntries[0];
+                    genericError = false;
+                }
+            }
+            if (genericError) {
+                this.showError = true;
+                this.errorTitle = "Job submission failed.";
+                this.errorContent = errorContent;
+            }
+        },
         onExecute(config, historyId) {
             if (this.validationInternal) {
                 this.validationScrollTo = this.validationInternal.slice();
                 return;
             }
             this.showExecuting = true;
-            const jobDef = {
-                history_id: historyId,
-                tool_id: this.formConfig.id,
-                tool_version: this.formConfig.version,
-                inputs: {
-                    ...this.formData,
-                },
+            this.submissionStateMessage = "Preparing Request";
+            const inputs = {
+                ...this.formData,
             };
-            if (this.useEmail) {
-                jobDef.inputs["send_email_notification"] = true;
-            }
-            if (this.useJobRemapping) {
-                jobDef.inputs["rerun_remap_job_id"] = this.job_id;
-            }
-            if (this.useCachedJobs) {
-                jobDef.inputs["use_cached_job"] = true;
+            const toolId = this.formConfig.id;
+            const toolVersion = this.formConfig.version;
+            let validatedInputs = null;
+            try {
+                validatedInputs = structuredInputs(inputs, this.toolInputs);
+            } catch {
+                // failed validation, just use legacy API
             }
-            if (this.preferredObjectStoreId) {
-                jobDef.preferred_object_store_id = this.preferredObjectStoreId;
-            }
-            console.debug("toolForm::onExecute()", jobDef);
             const prevRoute = this.$route.fullPath;
-            submitJob(jobDef).then(
-                (jobResponse) => {
-                    this.showExecuting = false;
-                    let changeRoute = false;
-                    refreshContentsWrapper();
-                    if (jobResponse.produces_entry_points) {
-                        this.showEntryPoints = true;
-                        this.entryPoints = jobResponse.jobs;
-                    }
-                    const nJobs = jobResponse && jobResponse.jobs ? jobResponse.jobs.length : 0;
-                    if (nJobs > 0) {
-                        this.showForm = false;
-                        const toolName = this.toolName;
-                        this.saveLatestResponse({
-                            jobDef,
-                            jobResponse,
-                            toolName,
-                        });
-                        changeRoute = prevRoute === this.$route.fullPath;
-                    } else {
-                        this.showError = true;
-                        this.showForm = true;
-                        this.errorTitle = "Job submission rejected.";
-                        this.errorContent = jobResponse;
+            if (validatedInputs) {
+                const toolRequest = {
+                    history_id: historyId,
+                    tool_id: toolId,
+                    tool_version: toolVersion,
+                    inputs: validatedInputs,
+                };
+                if (this.useCachedJobs) {
+                    toolRequest.use_cached_jobs = true;
+                }
+                if (this.preferredObjectStoreId) {
+                    toolRequest.preferred_object_store_id = this.preferredObjectStoreId;
+                }
+                this.submissionStateMessage = "Sending Request";
+                submitToolRequest(toolRequest).then(
+                    (jobResponse) => {
+                        this.submissionStateMessage = "Processing Request";
+                        console.log(jobResponse);
+                        this.waitOnRequest(jobResponse, toolRequest, config, prevRoute);
+                    },
+                    (e) => {
+                        this.handleError(e, toolRequest);
                     }
-                    if (changeRoute) {
-                        this.$router.push(`/jobs/submission/success`);
-                    } else {
-                        if ([true, "true"].includes(config.enable_tool_recommendations)) {
-                            this.showRecommendation = true;
+                );
+            } else {
+                const jobDef = {
+                    history_id: historyId,
+                    tool_id: toolId,
+                    tool_version: toolVersion,
+                    inputs: inputs,
+                };
+                if (this.useEmail) {
+                    jobDef.inputs["send_email_notification"] = true;
+                }
+                if (this.useJobRemapping) {
+                    jobDef.inputs["rerun_remap_job_id"] = this.job_id;
+                }
+                if (this.useCachedJobs) {
+                    jobDef.inputs["use_cached_job"] = true;
+                }
+                if (this.preferredObjectStoreId) {
+                    jobDef.preferred_object_store_id = this.preferredObjectStoreId;
+                }
+                console.debug("toolForm::onExecute()", jobDef);
+                submitJob(jobDef).then(
+                    (jobResponse) => {
+                        this.showExecuting = false;
+                        refreshContentsWrapper();
+                        if (jobResponse.produces_entry_points) {
+                            this.showEntryPoints = true;
+                            this.entryPoints = jobResponse.jobs;
                         }
-                        document.querySelector("#center").scrollTop = 0;
-                    }
-                },
-                (e) => {
-                    this.errorMessage = e?.response?.data?.err_msg;
-                    this.showExecuting = false;
-                    let genericError = true;
-                    const errorData = e && e.response && e.response.data && e.response.data.err_data;
-                    if (errorData) {
-                        const errorEntries = Object.entries(errorData);
-                        if (errorEntries.length > 0) {
-                            this.validationScrollTo = errorEntries[0];
-                            genericError = false;
+                        const nJobs = jobResponse && jobResponse.jobs ? jobResponse.jobs.length : 0;
+                        if (nJobs > 0) {
+                            this.showForm = false;
+                            const toolName = this.toolName;
+                            this.saveLatestResponse({
+                                jobDef,
+                                jobResponse,
+                                toolName,
+                            });
+                        } else {
+                            this.showError = true;
+                            this.showForm = true;
+                            this.errorTitle = "Job submission rejected.";
+                            this.errorContent = jobResponse;
                         }
+                        this.handleSubmissionComplete(config, prevRoute);
+                    },
+                    (e) => {
+                        this.handleError(e, jobDef);
                     }
-                    if (genericError) {
-                        this.showError = true;
-                        this.errorTitle = "Job submission failed.";
-                        this.errorContent = jobDef;
-                    }
-                }
-            );
+                );
+            }
         },
     },
 };
diff --git a/client/src/components/Tool/ToolSuccess.vue b/client/src/components/Tool/ToolSuccess.vue
index dc848c0b41d4..1929ec04038e 100644
--- a/client/src/components/Tool/ToolSuccess.vue
+++ b/client/src/components/Tool/ToolSuccess.vue
@@ -13,6 +13,7 @@ const jobStore = useJobStore();
 const router = useRouter();
 
 const jobDef = computed(() => responseVal.value.jobDef);
+const usedToolRequest = computed(() => responseVal.value.usedToolRequest);
 const jobResponse = computed(() => responseVal.value.jobResponse);
 const responseVal = computed(() => jobStore.getLatestResponse);
 const showRecommendation = computed(() => config.value.enable_tool_recommendations);
@@ -32,7 +33,7 @@ onMounted(() => {
         <div v-if="jobResponse.produces_entry_points">
             <ToolEntryPoints v-for="job in jobResponse.jobs" :key="job.id" :job-id="job.id" />
         </div>
-        <ToolSuccessMessage :job-response="jobResponse" :tool-name="toolName" />
+        <ToolSuccessMessage :job-response="jobResponse" :tool-name="toolName" :used-tool-request="usedToolRequest"/>
         <Webhook type="tool" :tool-id="jobDef.tool_id" />
         <ToolRecommendation v-if="showRecommendation" :tool-id="jobDef.tool_id" />
     </section>
diff --git a/client/src/components/Tool/ToolSuccessMessage.vue b/client/src/components/Tool/ToolSuccessMessage.vue
index e5b9faf0a090..867af32c659d 100644
--- a/client/src/components/Tool/ToolSuccessMessage.vue
+++ b/client/src/components/Tool/ToolSuccessMessage.vue
@@ -1,14 +1,28 @@
 <template>
     <div class="donemessagelarge">
-        <p>
-            Started tool <b>{{ toolName }}</b> and successfully added {{ nJobsText }} to the queue.
-        </p>
-        <p>It produces {{ nOutputsText }}:</p>
-        <ul>
-            <li v-for="item of jobResponse.outputs" :key="item.hid">
-                <b>{{ item.hid }}: {{ item.name }}</b>
-            </li>
-        </ul>
+        <div v-if="usedToolRequest">
+            You used the fancy new API... something new will be here.
+            <img
+                src="https://www.animatedimages.org/data/media/695/animated-under-construction-image-0055.gif"
+                alt="90s style under construction" />
+        </div>
+        <div v-else>
+            <p>
+                Started tool <b>{{ toolName }}</b> and successfully added {{ nJobsText }} to the queue.
+            </p>
+            <p>The tool uses {{ nInputsText }}:</p>
+            <ul>
+                <li v-for="item of inputs" :key="item.hid">
+                    <b>{{ item.hid }}: {{ item.name }}</b>
+                </li>
+            </ul>
+            <p>It produces {{ nOutputsText }}:</p>
+            <ul>
+                <li v-for="item of jobResponse.outputs" :key="item.hid">
+                    <b>{{ item.hid }}: {{ item.name }}</b>
+                </li>
+            </ul>
+        </div>
         <p>
             You can check the status of queued jobs and view the resulting data by refreshing the History panel. When
             the job has been run the status will change from 'running' to 'finished' if completed successfully or
@@ -28,6 +42,10 @@ export default {
             type: String,
             required: true,
         },
+        usedToolRequest: {
+            type: Boolean,
+            required: true,
+        },
     },
     computed: {
         nOutputs() {
diff --git a/client/src/components/Tool/parameterModels.ts b/client/src/components/Tool/parameterModels.ts
new file mode 100644
index 000000000000..d85cc14e2b17
--- /dev/null
+++ b/client/src/components/Tool/parameterModels.ts
@@ -0,0 +1,305 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+/* This file was automatically generated from pydantic models by running pydantic2ts.
+/* Do not modify it by hand - just update the pydantic models and then re-run the script
+*/
+
+export type ToolParameterModel =
+    | TextParameterModel
+    | IntegerParameterModel
+    | FloatParameterModel
+    | BooleanParameterModel
+    | HiddenParameterModel
+    | SelectParameterModel
+    | DataParameterModel
+    | DataCollectionParameterModel
+    | DirectoryUriParameterModel
+    | RulesParameterModel
+    | ColorParameterModel
+    | ConditionalParameterModel
+    | RepeatParameterModel
+    | CwlIntegerParameterModel
+    | CwlFloatParameterModel
+    | CwlStringParameterModel
+    | CwlBooleanParameterModel
+    | CwlNullParameterModel
+    | CwlFileParameterModel
+    | CwlDirectoryParameterModel
+    | CwlUnionParameterModel;
+
+export interface BaseGalaxyToolParameterModelDefinition {
+    name: string;
+    parameter_type: string;
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+}
+export interface BaseToolParameterModelDefinition {
+    name: string;
+    parameter_type: string;
+}
+export interface BooleanParameterModel {
+    name: string;
+    parameter_type?: "gx_boolean";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    value?: boolean;
+    truevalue?: string;
+    falsevalue?: string;
+}
+export interface ColorParameterModel {
+    name: string;
+    parameter_type?: "gx_color";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+}
+export interface ConditionalParameterModel {
+    name: string;
+    parameter_type?: "gx_conditional";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    test_parameter: BooleanParameterModel | SelectParameterModel;
+    whens: ConditionalWhen[];
+}
+export interface SelectParameterModel {
+    name: string;
+    parameter_type?: "gx_select";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    options?: LabelValue[];
+    multiple: boolean;
+}
+export interface LabelValue {
+    label: string;
+    value: string;
+}
+export interface ConditionalWhen {
+    discriminator: boolean | string;
+    parameters: ToolParameterModel[];
+}
+export interface TextParameterModel {
+    name: string;
+    parameter_type?: "gx_text";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    area?: boolean;
+    value?: string;
+    default_options?: LabelValue[];
+}
+export interface IntegerParameterModel {
+    name: string;
+    parameter_type?: "gx_integer";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional: boolean;
+    is_dynamic?: boolean;
+    value?: number;
+    min?: number;
+    max?: number;
+}
+export interface FloatParameterModel {
+    name: string;
+    parameter_type?: "gx_float";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    value?: number;
+    min?: number;
+    max?: number;
+}
+export interface HiddenParameterModel {
+    name: string;
+    parameter_type?: "gx_hidden";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+}
+export interface DataParameterModel {
+    name: string;
+    parameter_type?: "gx_data";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    extensions?: string[];
+    multiple?: boolean;
+    min?: number;
+    max?: number;
+}
+export interface DataCollectionParameterModel {
+    name: string;
+    parameter_type?: "gx_data_collection";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    collection_type?: string;
+    extensions?: string[];
+}
+export interface DirectoryUriParameterModel {
+    name: string;
+    parameter_type: "gx_directory_uri";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    value?: string;
+}
+export interface RulesParameterModel {
+    name: string;
+    parameter_type?: "gx_rules";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+}
+export interface RepeatParameterModel {
+    name: string;
+    parameter_type?: "gx_repeat";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+    parameters: ToolParameterModel[];
+}
+export interface CwlIntegerParameterModel {
+    name: string;
+    parameter_type?: "cwl_integer";
+}
+export interface CwlFloatParameterModel {
+    name: string;
+    parameter_type?: "cwl_float";
+}
+export interface CwlStringParameterModel {
+    name: string;
+    parameter_type?: "cwl_string";
+}
+export interface CwlBooleanParameterModel {
+    name: string;
+    parameter_type?: "cwl_boolean";
+}
+export interface CwlNullParameterModel {
+    name: string;
+    parameter_type?: "cwl_null";
+}
+export interface CwlFileParameterModel {
+    name: string;
+    parameter_type?: "cwl_file";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+}
+export interface CwlDirectoryParameterModel {
+    name: string;
+    parameter_type?: "cwl_directory";
+    hidden?: boolean;
+    label?: string;
+    help?: string;
+    argument?: string;
+    refresh_on_change?: boolean;
+    optional?: boolean;
+    is_dynamic?: boolean;
+}
+export interface CwlUnionParameterModel {
+    name: string;
+    parameter_type?: "cwl_union";
+    parameters: ToolParameterModel[];
+}
+export interface DataCollectionRequest {
+    src: "hdca";
+    id: string;
+}
+export interface DataCollectionRequestInternal {
+    src: "hdca";
+    id: number;
+}
+export interface DataRequest {
+    src: "hda" | "ldda";
+    id: string;
+}
+export interface DataRequestInteranl {
+    src: "hda" | "ldda";
+    id: number;
+}
+export interface MultiDataInstance {
+    src: "hda" | "ldda" | "hdca";
+    id: string;
+}
+export interface MultiDataInstanceInternal {
+    src: "hda" | "ldda" | "hdca";
+    id: number;
+}
+export interface RulesMapping {
+    type: string;
+    columns: number[];
+}
+export interface RulesModel {
+    rules: {
+        [k: string]: unknown;
+    }[];
+    mappings: RulesMapping[];
+}
+export interface StrictModel {}
+export interface ToolParameterBundleModel {
+    input_models: ToolParameterModel[];
+}
diff --git a/client/src/components/Tool/parameter_models.yml b/client/src/components/Tool/parameter_models.yml
new file mode 100644
index 000000000000..e4cb6e8cbf0f
--- /dev/null
+++ b/client/src/components/Tool/parameter_models.yml
@@ -0,0 +1,529 @@
+# auto generated file for JavaScript testing, do not modify manually
+# -----
+# PYTHONPATH="lib" python test/unit/tool_util/test_parameter_specification.py
+# -----
+cwl_boolean:
+  name: parameter
+  parameter_type: cwl_boolean
+cwl_boolean_optional:
+  name: parameter
+  parameter_type: cwl_union
+  parameters:
+  - name: parameter
+    parameter_type: cwl_null
+  - name: parameter
+    parameter_type: cwl_boolean
+cwl_directory:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: false
+  parameter_type: cwl_directory
+  refresh_on_change: false
+cwl_file:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: false
+  parameter_type: cwl_file
+  refresh_on_change: false
+cwl_float:
+  name: parameter
+  parameter_type: cwl_float
+cwl_float_optional:
+  name: parameter
+  parameter_type: cwl_union
+  parameters:
+  - name: parameter
+    parameter_type: cwl_null
+  - name: parameter
+    parameter_type: cwl_float
+cwl_int:
+  name: parameter
+  parameter_type: cwl_integer
+cwl_int_optional:
+  name: parameter
+  parameter_type: cwl_union
+  parameters:
+  - name: parameter
+    parameter_type: cwl_null
+  - name: parameter
+    parameter_type: cwl_integer
+cwl_string:
+  name: parameter
+  parameter_type: cwl_string
+cwl_string_optional:
+  name: parameter
+  parameter_type: cwl_union
+  parameters:
+  - name: parameter
+    parameter_type: cwl_null
+  - name: parameter
+    parameter_type: cwl_string
+gx_boolean:
+  argument: null
+  falsevalue: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: false
+  parameter_type: gx_boolean
+  refresh_on_change: false
+  truevalue: null
+  value: false
+gx_color:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: false
+  parameter_type: gx_color
+  refresh_on_change: false
+gx_conditional_boolean:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: conditional_parameter
+  optional: false
+  parameter_type: gx_conditional
+  refresh_on_change: false
+  test_parameter:
+    argument: null
+    falsevalue: null
+    help: null
+    hidden: false
+    is_dynamic: false
+    label: null
+    name: test_parameter
+    optional: false
+    parameter_type: gx_boolean
+    refresh_on_change: false
+    truevalue: null
+    value: false
+  whens:
+  - discriminator: true
+    parameters:
+    - argument: null
+      help: null
+      hidden: false
+      is_dynamic: false
+      label: null
+      max: null
+      min: null
+      name: integer_parameter
+      optional: false
+      parameter_type: gx_integer
+      refresh_on_change: false
+      value: null
+  - discriminator: false
+    parameters:
+    - argument: null
+      falsevalue: null
+      help: null
+      hidden: false
+      is_dynamic: false
+      label: null
+      name: boolean_parameter
+      optional: false
+      parameter_type: gx_boolean
+      refresh_on_change: false
+      truevalue: null
+      value: false
+gx_conditional_conditional_boolean:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: outer_conditional_parameter
+  optional: false
+  parameter_type: gx_conditional
+  refresh_on_change: false
+  test_parameter:
+    argument: null
+    falsevalue: null
+    help: null
+    hidden: false
+    is_dynamic: false
+    label: null
+    name: outer_test_parameter
+    optional: false
+    parameter_type: gx_boolean
+    refresh_on_change: false
+    truevalue: null
+    value: false
+  whens:
+  - discriminator: true
+    parameters:
+    - argument: null
+      help: null
+      hidden: false
+      is_dynamic: false
+      label: null
+      name: inner_conditional_parameter
+      optional: false
+      parameter_type: gx_conditional
+      refresh_on_change: false
+      test_parameter:
+        argument: null
+        falsevalue: null
+        help: null
+        hidden: false
+        is_dynamic: false
+        label: null
+        name: inner_test_parameter
+        optional: false
+        parameter_type: gx_boolean
+        refresh_on_change: false
+        truevalue: null
+        value: false
+      whens:
+      - discriminator: true
+        parameters:
+        - argument: null
+          help: null
+          hidden: false
+          is_dynamic: false
+          label: null
+          max: null
+          min: null
+          name: integer_parameter
+          optional: false
+          parameter_type: gx_integer
+          refresh_on_change: false
+          value: null
+      - discriminator: false
+        parameters:
+        - argument: null
+          falsevalue: null
+          help: null
+          hidden: false
+          is_dynamic: false
+          label: null
+          name: boolean_parameter
+          optional: false
+          parameter_type: gx_boolean
+          refresh_on_change: false
+          truevalue: null
+          value: false
+  - discriminator: false
+    parameters:
+    - argument: null
+      falsevalue: null
+      help: null
+      hidden: false
+      is_dynamic: false
+      label: null
+      name: boolean_parameter
+      optional: false
+      parameter_type: gx_boolean
+      refresh_on_change: false
+      truevalue: null
+      value: false
+gx_data:
+  argument: null
+  extensions:
+  - data
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  max: null
+  min: null
+  multiple: false
+  name: parameter
+  optional: false
+  parameter_type: gx_data
+  refresh_on_change: false
+gx_data_collection:
+  argument: null
+  collection_type: null
+  extensions:
+  - data
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: false
+  parameter_type: gx_data_collection
+  refresh_on_change: false
+gx_data_collection_optional:
+  argument: null
+  collection_type: null
+  extensions:
+  - data
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: true
+  parameter_type: gx_data_collection
+  refresh_on_change: false
+gx_data_multiple:
+  argument: null
+  extensions:
+  - data
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  max: null
+  min: null
+  multiple: true
+  name: parameter
+  optional: false
+  parameter_type: gx_data
+  refresh_on_change: false
+gx_data_multiple_optional:
+  argument: null
+  extensions:
+  - data
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  max: null
+  min: null
+  multiple: true
+  name: parameter
+  optional: true
+  parameter_type: gx_data
+  refresh_on_change: false
+gx_data_optional:
+  argument: null
+  extensions:
+  - data
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  max: null
+  min: null
+  multiple: false
+  name: parameter
+  optional: true
+  parameter_type: gx_data
+  refresh_on_change: false
+gx_float:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  max: null
+  min: null
+  name: parameter
+  optional: false
+  parameter_type: gx_float
+  refresh_on_change: false
+  value: null
+gx_float_optional:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  max: null
+  min: null
+  name: parameter
+  optional: true
+  parameter_type: gx_float
+  refresh_on_change: false
+  value: null
+gx_hidden:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: false
+  parameter_type: gx_hidden
+  refresh_on_change: false
+gx_hidden_optional:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: true
+  parameter_type: gx_hidden
+  refresh_on_change: false
+gx_int:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  max: null
+  min: null
+  name: parameter
+  optional: false
+  parameter_type: gx_integer
+  refresh_on_change: false
+  value: null
+gx_int_optional:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  max: null
+  min: null
+  name: parameter
+  optional: true
+  parameter_type: gx_integer
+  refresh_on_change: false
+  value: null
+gx_repeat_boolean:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: false
+  parameter_type: gx_repeat
+  parameters:
+  - argument: null
+    falsevalue: null
+    help: null
+    hidden: false
+    is_dynamic: false
+    label: null
+    name: boolean_parameter
+    optional: false
+    parameter_type: gx_boolean
+    refresh_on_change: false
+    truevalue: null
+    value: false
+  refresh_on_change: false
+gx_select:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  multiple: false
+  name: parameter
+  optional: false
+  options:
+  - label: Ex1
+    value: --ex1
+  - label: Ex2
+    value: ex2
+  - label: Ex3
+    value: --ex3
+  - label: Ex4
+    value: --ex4
+  - label: Ex5
+    value: ex5
+  parameter_type: gx_select
+  refresh_on_change: false
+gx_select_multiple:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  multiple: true
+  name: parameter
+  optional: false
+  options:
+  - label: Ex1
+    value: --ex1
+  - label: Ex2
+    value: ex2
+  - label: Ex3
+    value: --ex3
+  - label: Ex4
+    value: --ex4
+  - label: Ex5
+    value: ex5
+  parameter_type: gx_select
+  refresh_on_change: false
+gx_select_multiple_optional:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  multiple: true
+  name: parameter
+  optional: true
+  options:
+  - label: Ex1
+    value: --ex1
+  - label: Ex2
+    value: ex2
+  - label: Ex3
+    value: --ex3
+  - label: Ex4
+    value: --ex4
+  - label: Ex5
+    value: ex5
+  parameter_type: gx_select
+  refresh_on_change: false
+gx_select_optional:
+  argument: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  multiple: false
+  name: parameter
+  optional: true
+  options:
+  - label: Ex1
+    value: --ex1
+  - label: Ex2
+    value: ex2
+  - label: Ex3
+    value: --ex3
+  - label: Ex4
+    value: --ex4
+  - label: Ex5
+    value: ex5
+  parameter_type: gx_select
+  refresh_on_change: false
+gx_text:
+  area: false
+  argument: null
+  default_options: []
+  default_value: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: false
+  parameter_type: gx_text
+  refresh_on_change: false
+gx_text_optional:
+  area: false
+  argument: null
+  default_options: []
+  default_value: null
+  help: null
+  hidden: false
+  is_dynamic: false
+  label: null
+  name: parameter
+  optional: true
+  parameter_type: gx_text
+  refresh_on_change: false
diff --git a/client/src/components/Tool/parameter_specification.yml b/client/src/components/Tool/parameter_specification.yml
new file mode 120000
index 000000000000..0a9f7915c276
--- /dev/null
+++ b/client/src/components/Tool/parameter_specification.yml
@@ -0,0 +1 @@
+../../../../test/unit/tool_util/parameter_specification.yml
\ No newline at end of file
diff --git a/client/src/components/Tool/services.js b/client/src/components/Tool/services.js
index 04f23ffab597..5b13d484291e 100644
--- a/client/src/components/Tool/services.js
+++ b/client/src/components/Tool/services.js
@@ -18,6 +18,21 @@ export async function updateToolFormData(tool_id, tool_version, history_id, inpu
     }
 }
 
+export async function getToolInputs(tool_id, tool_version) {
+    let url = "";
+    url = `${getAppRoot()}api/tools/${tool_id}/inputs`;
+    if (tool_version) {
+        url += `?tool_version=${tool_version}`;
+    }
+    // request tool data
+    try {
+        const { data } = await axios.get(url);
+        return data;
+    } catch (e) {
+        rethrowSimple(e);
+    }
+}
+
 /** Tools data request helper **/
 export async function getToolFormData(tool_id, tool_version, job_id, history_id) {
     let url = "";
@@ -59,3 +74,9 @@ export async function submitJob(jobDetails) {
     const { data } = await axios.post(url, jobDetails);
     return data;
 }
+
+export async function submitToolRequest(toolRequest) {
+    const url = `${getAppRoot()}api/jobs`;
+    const { data } = await axios.post(url, toolRequest);
+    return data;
+}
diff --git a/client/src/components/Tool/structured.test.ts b/client/src/components/Tool/structured.test.ts
new file mode 100644
index 000000000000..38faf1c9797c
--- /dev/null
+++ b/client/src/components/Tool/structured.test.ts
@@ -0,0 +1,78 @@
+import { structuredInputs, validate } from "./structured";
+import { TextParameterModel, ToolParameterModel } from "./parameterModels";
+
+describe("structured.js", () => {
+    it("should parse galaxy integer parameters", () => {
+        expect(true).toBe(true);
+        const si = structuredInputs({ parameter: "5" }, [
+            { name: "parameter", parameter_type: "gx_integer", optional: false },
+        ]);
+        expect(si["parameter"]).toBe(5);
+    });
+});
+
+import SPEC_PARAMETERS from "./parameter_models.yml";
+import SPEC_TESTS from "./parameter_specification.yml";
+
+class FileTestCases {
+    request_invalid: Array<any>;
+    request_valid: Array<any>;
+}
+
+function itShouldValidateParameters(file, parameters) {
+    for (const [index, parameter] of parameters.entries()) {
+        itShouldValidateParameter(file, index, parameter);
+    }
+}
+
+function itShouldInvalidateParameters(file, parameters) {
+    for (const [index, parameter] of parameters.entries()) {
+        itShouldInvalidateParameter(file, index, parameter);
+    }
+}
+
+function toToolParameterModel(jsonObject): ToolParameterModel {
+    const modal: TextParameterModel = jsonObject;
+    return modal;
+}
+
+function parameterModelsForFile(filename: string): Array<ToolParameterModel> {
+    const parameterModel = SPEC_PARAMETERS[filename];
+    const parameterObject: ToolParameterModel = toToolParameterModel(parameterModel);
+    const inputs = [parameterObject];
+    return inputs;
+}
+
+function itShouldValidateParameter(file, index, parameterTestCase) {
+    let doc = " for file [" + file + "] and valid parameter combination [" + index + "]";
+    if (parameterTestCase._doc) {
+        doc = " - " + parameterTestCase._doc;
+    }
+    it("should validate example parameter request (from parameter_spec.yml)" + doc, () => {
+        const result = validate(parameterTestCase, parameterModelsForFile(file));
+        expect(result).toBe(null);
+    });
+}
+
+function itShouldInvalidateParameter(file, index, parameterTestCase) {
+    let doc = " for file [" + file + "] and invalid parameter combination [" + index + "]";
+    if (parameterTestCase._doc) {
+        doc = " - " + parameterTestCase._doc;
+    }
+    it("should fail validation of example parameter request (from parameter_spec.yml)" + doc, () => {
+        const result = validate(parameterTestCase, parameterModelsForFile(file));
+        expect(result).not.toBe(null);
+    });
+}
+
+describe("Tool Parameter Specification", () => {
+    for (const [file, combos] of Object.entries(SPEC_TESTS)) {
+        const testCases: FileTestCases = Object.assign(new FileTestCases(), combos);
+        if (testCases.request_valid) {
+            itShouldValidateParameters(file, testCases.request_valid);
+        }
+        if (testCases.request_invalid) {
+            itShouldInvalidateParameters(file, testCases.request_invalid);
+        }
+    }
+});
diff --git a/client/src/components/Tool/structured.ts b/client/src/components/Tool/structured.ts
new file mode 100644
index 000000000000..ea4a2c565245
--- /dev/null
+++ b/client/src/components/Tool/structured.ts
@@ -0,0 +1,378 @@
+import {
+    BooleanParameterModel,
+    ColorParameterModel,
+    ConditionalParameterModel,
+    CwlBooleanParameterModel,
+    CwlDirectoryParameterModel,
+    CwlFileParameterModel,
+    CwlFloatParameterModel,
+    CwlIntegerParameterModel,
+    CwlNullParameterModel,
+    CwlStringParameterModel,
+    CwlUnionParameterModel,
+    DataCollectionParameterModel,
+    DataParameterModel,
+    FloatParameterModel,
+    HiddenParameterModel,
+    IntegerParameterModel,
+    RepeatParameterModel,
+    SelectParameterModel,
+    TextParameterModel,
+    ToolParameterModel,
+} from "./parameterModels";
+
+export function structuredInputs(formInputs: object, toolInputs: Array<ToolParameterModel>): object {
+    const structuredInputs = {};
+    for (const toolInput of toolInputs) {
+        const inputKey = toolInput.name;
+        structuredInputs[inputKey] = parseInt(formInputs[inputKey]);
+    }
+    const validationResult = validateParameters(structuredInputs, toolInputs);
+    if (validationResult.length !== 0) {
+        console.log(`Failed structured input validation with... '${validationResult}'`);
+        throw "Failed parameter validation";
+    }
+    return structuredInputs;
+}
+
+function extendValidationResults(results: Array<string>, withResults: Array<string>) {
+    withResults.forEach((obj) => {
+        results.push(obj);
+    });
+}
+
+function isFloat(v: any) {
+    return typeof v == "number";
+}
+
+function isString(v: any) {
+    return typeof v == "string";
+}
+
+function isGxInteger(model: ToolParameterModel): model is IntegerParameterModel {
+    return model.parameter_type == "gx_integer";
+}
+
+function isGxFloat(model: ToolParameterModel): model is FloatParameterModel {
+    return model.parameter_type == "gx_float";
+}
+
+function isGxText(model: ToolParameterModel): model is TextParameterModel {
+    return model.parameter_type == "gx_text";
+}
+
+function isGxBoolean(model: ToolParameterModel): model is BooleanParameterModel {
+    return model.parameter_type == "gx_boolean";
+}
+
+function isGxHidden(model: ToolParameterModel): model is HiddenParameterModel {
+    return model.parameter_type == "gx_hidden";
+}
+
+function isGxSelect(model: ToolParameterModel): model is SelectParameterModel {
+    return model.parameter_type == "gx_select";
+}
+
+function isGxColor(model: ToolParameterModel): model is ColorParameterModel {
+    return model.parameter_type == "gx_color";
+}
+
+function isGxData(model: ToolParameterModel): model is DataParameterModel {
+    return model.parameter_type == "gx_data";
+}
+
+function isGxDataCollection(model: ToolParameterModel): model is DataCollectionParameterModel {
+    return model.parameter_type == "gx_data_collection";
+}
+
+function isGxRepeat(model: ToolParameterModel): model is RepeatParameterModel {
+    return model.parameter_type == "gx_repeat";
+}
+
+function isGxConditional(model: ToolParameterModel): model is ConditionalParameterModel {
+    return model.parameter_type == "gx_conditional";
+}
+
+function isCwlInteger(model: ToolParameterModel): model is CwlIntegerParameterModel {
+    return model.parameter_type == "cwl_integer";
+}
+
+function isCwlDirectory(model: ToolParameterModel): model is CwlDirectoryParameterModel {
+    return model.parameter_type == "cwl_directory";
+}
+
+function isCwlFile(model: ToolParameterModel): model is CwlFileParameterModel {
+    return model.parameter_type == "cwl_file";
+}
+
+function isCwlUnion(model: ToolParameterModel): model is CwlUnionParameterModel {
+    return model.parameter_type == "cwl_union";
+}
+
+function isCwlNull(model: ToolParameterModel): model is CwlNullParameterModel {
+    return model.parameter_type == "cwl_null";
+}
+
+function isCwlBoolean(model: ToolParameterModel): model is CwlBooleanParameterModel {
+    return model.parameter_type == "cwl_boolean";
+}
+
+function isCwlString(model: ToolParameterModel): model is CwlStringParameterModel {
+    return model.parameter_type == "cwl_string";
+}
+
+function isCwlFloat(model: ToolParameterModel): model is CwlFloatParameterModel {
+    return model.parameter_type == "cwl_float";
+}
+
+const isBool = (v) => {
+    return typeof v == "boolean";
+};
+
+function isObjectWithKeys(inputObject: any, requiredKeys: Array<string>): boolean {
+    if (!inputObject) {
+        return false;
+    }
+    if (typeof inputObject != "object") {
+        return false;
+    }
+    for (const inputKey of Object.keys(inputObject)) {
+        if (requiredKeys.indexOf(inputKey) == -1) {
+            return false;
+        }
+    }
+    for (const requiredKey of requiredKeys) {
+        if (!(requiredKey in inputObject)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function isSrcReferenceObject(v, srcTypes: Array<string>) {
+    return isObjectWithKeys(v, ["src", "id"]) && srcTypes.indexOf(v.src) >= 0 && isString(v.id);
+}
+
+function isArrayOf(inputObject: any, typeCheck): boolean {
+    if (!Array.isArray(inputObject)) {
+        return false;
+    }
+    for (const el of inputObject) {
+        if (!typeCheck(el)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const isDataDict = (v) => {
+    return isSrcReferenceObject(v, ["hda", "ldda"]);
+};
+
+const isBatch = (v, valueChecker) => {
+    if (!isObjectWithKeys(v, ["__class__", "values"]) || v["__class__"] != "Batch") {
+        return false;
+    }
+    const values = v.values;
+    return isArrayOf(values, valueChecker);
+};
+
+function simpleCwlTypeChecker(parameterModel: ToolParameterModel) {
+    let checkType = null;
+    if (isCwlInteger(parameterModel)) {
+        checkType = Number.isInteger;
+    } else if (isCwlDirectory(parameterModel)) {
+        checkType = isDataDict;
+    } else if (isCwlFile(parameterModel)) {
+        checkType = isDataDict;
+    } else if (isCwlNull(parameterModel)) {
+        checkType = (v) => {
+            return v == null;
+        };
+    } else if (isCwlBoolean(parameterModel)) {
+        checkType = isBool;
+    } else if (isCwlString(parameterModel)) {
+        checkType = isString;
+    } else if (isCwlFloat(parameterModel)) {
+        checkType = isFloat;
+    } else {
+        throw "Unknown simple CWL type encountered.";
+    }
+    return checkType;
+}
+
+function checkCwlUnionType(parameterModel: CwlUnionParameterModel, inputValue) {
+    for (const unionedModel of parameterModel.parameters) {
+        if (simpleCwlTypeChecker(unionedModel)(inputValue)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function validateParameter(inputKey: string, inputValue, parameterModel: ToolParameterModel) {
+    const results = [];
+    let checkType = null;
+
+    function handleOptional(typeCheck, parameter) {
+        if (parameter.optional) {
+            return (v) => {
+                return v === null || typeCheck(v);
+            };
+        } else {
+            return typeCheck;
+        }
+    }
+
+    if (isGxInteger(parameterModel)) {
+        checkType = handleOptional(Number.isInteger, parameterModel);
+    } else if (isGxFloat(parameterModel)) {
+        checkType = handleOptional(isFloat, parameterModel);
+    } else if (isGxText(parameterModel)) {
+        checkType = handleOptional(isString, parameterModel);
+    } else if (isGxBoolean(parameterModel)) {
+        checkType = handleOptional(isBool, parameterModel);
+    } else if (isGxHidden(parameterModel)) {
+        checkType = handleOptional(isString, parameterModel);
+    } else if (isGxColor(parameterModel)) {
+        const isColorString = (v) => {
+            return isString(v) && /^#[0-9A-F]{6}$/i.test(v);
+        };
+        checkType = handleOptional(isColorString, parameterModel);
+    } else if (isGxData(parameterModel)) {
+        const isMultiDataDict = (v) => {
+            return isSrcReferenceObject(v, ["hda", "ldda", "hdca"]);
+        };
+        const isArrayOfDataDict = (v) => {
+            return isArrayOf(v, isMultiDataDict);
+        };
+        const isBatchData = (v) => {
+            return isBatch(v, isMultiDataDict);
+        };
+        let checkRaw;
+        if (parameterModel.multiple) {
+            checkRaw = handleOptional((v) => {
+                return isMultiDataDict(v) || isArrayOfDataDict(v);
+            }, parameterModel);
+        } else {
+            checkRaw = isDataDict;
+        }
+        checkType = (v) => {
+            return checkRaw(v) || isBatchData(v);
+        };
+        checkType = handleOptional(checkType, parameterModel);
+    } else if (isGxSelect(parameterModel)) {
+        let isElement;
+        if (parameterModel.options != null) {
+            const optionValues = parameterModel.options.map((lv) => {
+                return lv.value;
+            });
+            const isOneOfOptions = (v) => {
+                return isString(v) && optionValues.indexOf(v) !== -1;
+            };
+            isElement = isOneOfOptions;
+        } else {
+            isElement = isString;
+        }
+        if (parameterModel.multiple) {
+            checkType = (v) => {
+                return isArrayOf(v, isElement);
+            };
+        } else {
+            checkType = isElement;
+        }
+        checkType = handleOptional(checkType, parameterModel);
+    } else if (isGxDataCollection(parameterModel)) {
+        const isDataCollectionDict = (v) => {
+            return isSrcReferenceObject(v, ["hdca"]);
+        };
+        checkType = handleOptional(isDataCollectionDict, parameterModel);
+    } else if (isCwlInteger(parameterModel)) {
+        checkType = simpleCwlTypeChecker(parameterModel);
+    } else if (isCwlDirectory(parameterModel)) {
+        checkType = simpleCwlTypeChecker(parameterModel);
+    } else if (isCwlFile(parameterModel)) {
+        checkType = simpleCwlTypeChecker(parameterModel);
+    } else if (isCwlUnion(parameterModel)) {
+        checkType = (v) => {
+            return checkCwlUnionType(parameterModel, v);
+        };
+    } else if (isCwlBoolean(parameterModel)) {
+        checkType = simpleCwlTypeChecker(parameterModel);
+    } else if (isCwlString(parameterModel)) {
+        checkType = simpleCwlTypeChecker(parameterModel);
+    } else if (isCwlFloat(parameterModel)) {
+        checkType = simpleCwlTypeChecker(parameterModel);
+    } else if (isGxRepeat(parameterModel)) {
+        if (!Array.isArray(inputValue)) {
+            results.push(`Parameter ${inputKey} is not an array of values.`);
+        } else {
+            for (const inputs of inputValue) {
+                const instanceResults = validateParameters(inputs, parameterModel.parameters);
+                extendValidationResults(results, instanceResults);
+            }
+        }
+    } else if (isGxConditional(parameterModel)) {
+        const testParameter = parameterModel.test_parameter;
+        const testParameterOptional = testParameter.optional;
+        const whens = parameterModel.whens;
+        const testParameterName = testParameter.name;
+        const testParameterValue = inputValue[testParameterName];
+        // validateParameter(testParameterName, testParameterValue, testParameter);
+        let testParameterValueFoundInWhen = false;
+        for (const when of whens) {
+            const inputKey = when.discriminator;
+            if (inputKey === testParameterValue) {
+                testParameterValueFoundInWhen = true;
+                const whenParameters = when.parameters.concat([testParameter]);
+                const whenResults = validateParameters(inputValue, whenParameters);
+                extendValidationResults(results, whenResults);
+                break;
+            }
+        }
+        if (!testParameterValueFoundInWhen && !testParameterOptional) {
+            results.push(`Non optional parameter ${testParameterName} was not found in inputs.`);
+        }
+    }
+    if (checkType && !checkType(inputValue)) {
+        results.push(`Parameter ${inputKey} is of invalid type.`);
+    }
+    return results;
+}
+
+function validateParameters(structuredInputs: object, parameterModels: Array<ToolParameterModel>): Array<string> {
+    const results = [];
+    const keysEncountered = [];
+    const parameterModelsByName = {};
+    parameterModels.forEach((v) => {
+        parameterModelsByName[v.name] = v;
+    });
+    for (const inputKey of Object.keys(structuredInputs)) {
+        keysEncountered.push(inputKey);
+        if (!(inputKey in parameterModelsByName)) {
+            results.push(`Unknown parameter ${inputKey} encountered.`);
+            continue;
+        }
+        const inputValue = structuredInputs[inputKey];
+        const parameterModel = parameterModelsByName[inputKey];
+        const parameterResults = validateParameter(inputKey, inputValue, parameterModel);
+        extendValidationResults(results, parameterResults);
+    }
+    for (const parameterModel of parameterModels) {
+        const inputKey = parameterModel.name;
+        if (keysEncountered.indexOf(inputKey) !== -1) {
+            continue;
+        }
+        const toolInput = parameterModelsByName[inputKey];
+        if (toolInput.optional === true) {
+            continue;
+        }
+        results.push(`Non optional parameter ${inputKey} was not found in inputs.`);
+    }
+    return results;
+}
+
+export function validate(structuredInputs: object, toolInputs: Array<ToolParameterModel>) {
+    const results = validateParameters(structuredInputs, toolInputs);
+    return results.length == 0 ? null : results;
+}
diff --git a/client/src/stores/jobStore.ts b/client/src/stores/jobStore.ts
index 3745563b3a75..c479ff2a0e42 100644
--- a/client/src/stores/jobStore.ts
+++ b/client/src/stores/jobStore.ts
@@ -23,6 +23,7 @@ interface ResponseVal {
     jobDef: JobDef;
     jobResponse: JobResponse;
     toolName: string;
+    usedToolRequest: boolean;
 }
 
 export const useJobStore = defineStore("jobStore", {
diff --git a/doc/source/dev/image.Makefile b/doc/source/dev/image.Makefile
new file mode 100644
index 000000000000..75cb5e1910e4
--- /dev/null
+++ b/doc/source/dev/image.Makefile
@@ -0,0 +1,11 @@
+MINDMAPS := $(wildcard *.mindmap.yml)
+INPUTS := $(wildcard *.plantuml.txt)
+OUTPUTS := $(INPUTS:.txt=.svg)
+
+all: plantuml.jar $(MINDMAPS) $(OUTPUTS)
+
+$(OUTPUTS): $(INPUTS) $(MINDMAPS)
+	java -jar plantuml.jar -c plantuml_options.txt -tsvg $(INPUTS)
+
+plantuml.jar:
+	wget http://jaist.dl.sourceforge.net/project/plantuml/plantuml.jar || curl --output plantuml.jar http://jaist.dl.sourceforge.net/project/plantuml/plantuml.jar
diff --git a/doc/source/dev/plantuml_options.txt b/doc/source/dev/plantuml_options.txt
new file mode 100644
index 000000000000..70424ef26736
--- /dev/null
+++ b/doc/source/dev/plantuml_options.txt
@@ -0,0 +1,51 @@
+' skinparam handwritten true
+' skinparam roundcorner 20
+
+skinparam class {
+    ArrowFontColor DarkOrange
+    BackgroundColor #FFEFD5
+    ArrowColor Orange
+    BorderColor DarkOrange
+}
+
+skinparam object {
+    ArrowFontColor DarkOrange
+    BackgroundColor #FFEFD5
+    BackgroundColor #FFEFD5
+    ArrowColor Orange
+    BorderColor DarkOrange
+}
+
+skinparam ComponentBackgroundColor #FFEFD5
+skinparam ComponentBorderColor DarkOrange
+
+skinparam DatabaseBackgroundColor #FFEFD5
+skinparam DatabaseBorderColor DarkOrange
+
+skinparam StorageBackgroundColor #FFEFD5
+skinparam StorageBorderColor DarkOrange
+
+skinparam QueueBackgroundColor #FFEFD5
+skinparam QueueBorderColor DarkOrange
+
+skinparam note {
+    BackgroundColor #FFEFD5
+    BorderColor #BF5700
+}
+
+skinparam sequence {
+    ArrowColor Orange
+    ArrowFontColor DarkOrange
+    ActorBorderColor DarkOrange
+    ActorBackgroundColor #FFEFD5
+
+    ParticipantBorderColor DarkOrange
+    ParticipantBackgroundColor #FFEFD5
+
+    LifeLineBorderColor DarkOrange
+    LifeLineBackgroundColor #FFEFD5
+
+    DividerBorderColor DarkOrange
+    GroupBorderColor DarkOrange
+}
+
diff --git a/doc/source/dev/plantuml_style.txt b/doc/source/dev/plantuml_style.txt
new file mode 100644
index 000000000000..18911d622b75
--- /dev/null
+++ b/doc/source/dev/plantuml_style.txt
@@ -0,0 +1,9 @@
+<style>
+mindmapDiagram {
+    node {
+        BackgroundColor #FFEFD5
+        BorderColor DarkOrange
+        LineColor Orange
+    }
+}
+</style>
diff --git a/doc/source/dev/tool_state.md b/doc/source/dev/tool_state.md
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/doc/source/dev/tool_state_api.plantuml.txt b/doc/source/dev/tool_state_api.plantuml.txt
new file mode 100644
index 000000000000..060b4c5bdb9e
--- /dev/null
+++ b/doc/source/dev/tool_state_api.plantuml.txt
@@ -0,0 +1,17 @@
+@startuml
+'!include plantuml_options.txt
+participant "API Request" as apireq
+boundary    "Jobs API"    as api
+participant     "Job Service" as service
+database    Database    as database
+queue       TaskQueue   as queue
+apireq -> api : HTTP JSON
+api -> service : To boundary
+service -> service : Build RequestToolState
+service -> service : Validate RequestToolState (pydantic)
+service -> service : decode() RequestToolState \ninto RequestInternalToolState
+service -> database : Serialize RequestInternalToolState
+service -> queue : Queue QueueJobs with reference to\npersisted RequestInternalToolState
+service -> api : JobCreateResponse\n (pydantic model)
+api -> apireq : JobCreateResponse\n (as json)
+@enduml
diff --git a/doc/source/dev/tool_state_state_classes.plantuml.txt b/doc/source/dev/tool_state_state_classes.plantuml.txt
new file mode 100644
index 000000000000..612c13d8e683
--- /dev/null
+++ b/doc/source/dev/tool_state_state_classes.plantuml.txt
@@ -0,0 +1,41 @@
+@startuml
+!include plantuml_options.txt
+
+package galaxy.tool_util.parameters.state {
+
+class ToolState {
+state_representation: str
+input_state: Dict[str, Any]
++ validate(input_models: ToolParameterBundle)
++ {abstract} _to_base_model(input_models: ToolParameterBundle): Optional[Type[BaseModel]]
+}
+
+class RequestToolState {
+state_representation = "request"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]
+}
+note bottom: Object references of the form \n{src: "hda", id: <encoded_id>}.\n Allow mapping/reduce constructs.
+
+class RequestInternalToolState {
+state_representation = "request_internal"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]
+}
+note bottom: Object references of the form \n{src: "hda", id: <decoded_id>}.\n Allow mapping/reduce constructs.
+
+class JobInternalToolState {
+state_representation = "job_internal"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]
+
+}
+note bottom: Object references of the form \n{src: "hda", id: <decoded_id>}.\n Mapping constructs expanded out.\n (Defaults are inserted?)
+
+ToolState <|-- RequestToolState
+ToolState <|-- RequestInternalToolState
+ToolState <|-- JobInternalToolState
+
+RequestToolState - RequestInternalToolState : decode >
+
+RequestInternalToolState o-- JobInternalToolState : expand >
+
+}
+@enduml
\ No newline at end of file
diff --git a/lib/galaxy/app.py b/lib/galaxy/app.py
index 9351167634e0..de676d66e196 100644
--- a/lib/galaxy/app.py
+++ b/lib/galaxy/app.py
@@ -579,6 +579,10 @@ def __init__(self, configure_logging=True, use_converters=True, use_display_appl
         self._register_singleton(Registry, self.datatypes_registry)
         galaxy.model.set_datatypes_registry(self.datatypes_registry)
         self.configure_sentry_client()
+        # Load dbkey / genome build manager
+        self._configure_genome_builds(data_table_name="__dbkeys__", load_old_style=True)
+        # Tool Data Tables
+        self._configure_tool_data_tables(from_shed_config=False)
 
         self._configure_tool_shed_registry()
         self._register_singleton(tool_shed_registry.Registry, self.tool_shed_registry)
@@ -636,11 +640,6 @@ def __init__(self, **kwargs) -> None:
         )
         self.api_keys_manager = self._register_singleton(ApiKeyManager)
 
-        # Tool Data Tables
-        self._configure_tool_data_tables(from_shed_config=False)
-        # Load dbkey / genome build manager
-        self._configure_genome_builds(data_table_name="__dbkeys__", load_old_style=True)
-
         # Genomes
         self.genomes = self._register_singleton(Genomes)
         # Data providers registry.
diff --git a/lib/galaxy/celery/tasks.py b/lib/galaxy/celery/tasks.py
index f25a81b7cefc..d52c3d1d24a6 100644
--- a/lib/galaxy/celery/tasks.py
+++ b/lib/galaxy/celery/tasks.py
@@ -28,6 +28,7 @@
     DatasetManager,
 )
 from galaxy.managers.hdas import HDAManager
+from galaxy.managers.jobs import JobSubmitter
 from galaxy.managers.lddas import LDDAManager
 from galaxy.managers.markdown_util import generate_branded_pdf
 from galaxy.managers.model_stores import ModelStoreManager
@@ -49,6 +50,7 @@
     MaterializeDatasetInstanceTaskRequest,
     PrepareDatasetCollectionDownload,
     PurgeDatasetsTaskRequest,
+    QueueJobs,
     SetupHistoryExportJob,
     WriteHistoryContentTo,
     WriteHistoryTo,
@@ -70,9 +72,9 @@ def setup_data_table_manager(app):
 
 
 @lru_cache()
-def cached_create_tool_from_representation(app, raw_tool_source):
+def cached_create_tool_from_representation(app, raw_tool_source, tool_dir=""):
     return create_tool_from_representation(
-        app=app, raw_tool_source=raw_tool_source, tool_dir="", tool_source_class="XmlToolSource"
+        app=app, raw_tool_source=raw_tool_source, tool_dir=tool_dir, tool_source_class="XmlToolSource"
     )
 
 
@@ -296,6 +298,17 @@ def fetch_data(
     return abort_when_job_stops(_fetch_data, session=sa_session, job_id=job_id, setup_return=setup_return)
 
 
+@galaxy_task(action="queuing up submitted jobs")
+def queue_jobs(request: QueueJobs, app: MinimalManagerApp, job_submitter: JobSubmitter):
+    tool = cached_create_tool_from_representation(
+        app, request.tool_source.raw_tool_source, tool_dir=request.tool_source.tool_dir
+    )
+    job_submitter.queue_jobs(
+        tool,
+        request,
+    )
+
+
 @galaxy_task(ignore_result=True, action="setting up export history job")
 def export_history(
     model_store_manager: ModelStoreManager,
diff --git a/lib/galaxy/managers/jobs.py b/lib/galaxy/managers/jobs.py
index 3254396fcf78..0704155eb746 100644
--- a/lib/galaxy/managers/jobs.py
+++ b/lib/galaxy/managers/jobs.py
@@ -34,10 +34,13 @@
 from galaxy.managers.collections import DatasetCollectionManager
 from galaxy.managers.datasets import DatasetManager
 from galaxy.managers.hdas import HDAManager
+from galaxy.managers.histories import HistoryManager
 from galaxy.managers.lddas import LDDAManager
+from galaxy.managers.users import UserManager
 from galaxy.model import (
     Job,
     JobParameter,
+    ToolRequest,
 )
 from galaxy.model.base import transaction
 from galaxy.model.index_filter_util import (
@@ -49,8 +52,13 @@
     JobIndexQueryPayload,
     JobIndexSortByEnum,
 )
+from galaxy.schema.tasks import QueueJobs
 from galaxy.security.idencoding import IdEncodingHelper
-from galaxy.structured_app import StructuredApp
+from galaxy.structured_app import (
+    MinimalManagerApp,
+    StructuredApp,
+)
+from galaxy.tools import Tool
 from galaxy.util import (
     defaultdict,
     ExecutionTimer,
@@ -61,6 +69,7 @@
     parse_filters_structured,
     RawTextTerm,
 )
+from galaxy.work.context import WorkRequestContext
 
 log = logging.getLogger(__name__)
 
@@ -134,6 +143,7 @@ def build_and_apply_filters(query, objects, filter_func):
         history_id = payload.history_id
         workflow_id = payload.workflow_id
         invocation_id = payload.invocation_id
+        tool_request_id = payload.tool_request_id
         if history_id is not None:
             query = query.filter(model.Job.history_id == history_id)
         if workflow_id or invocation_id:
@@ -160,6 +170,8 @@ def build_and_apply_filters(query, objects, filter_func):
                 == wfi_step.c.implicit_collection_jobs_id,
             )
             query = query1.union(query2)
+        elif tool_request_id is not None:
+            query = query.filter(model.Job.tool_request_id == tool_request_id)
 
         search = payload.search
         if search:
@@ -1040,3 +1052,42 @@ def summarize_job_outputs(job: model.Job, tool, params, security):
                 }
             )
     return outputs
+
+
+class JobSubmitter:
+    def __init__(
+        self,
+        history_manager: HistoryManager,
+        user_manager: UserManager,
+        app: MinimalManagerApp,
+    ):
+        self.history_manager = history_manager
+        self.user_manager = user_manager
+        self.app = app
+
+    def queue_jobs(self, tool: Tool, request: QueueJobs) -> None:
+        user = self.user_manager.by_id(request.user.user_id)
+        sa_session = self.app.model.context
+        tool_request = sa_session.query(ToolRequest).get(request.tool_request_id)
+        try:
+            target_history = tool_request.history
+            use_cached_jobs = request.use_cached_jobs
+            trans = WorkRequestContext(
+                self.app,
+                user,
+                history=target_history,
+            )
+            tool.handle_input_2(
+                trans,
+                tool_request,
+                history=target_history,
+                use_cached_job=use_cached_jobs,
+            )
+            tool_request.state = ToolRequest.states.SUBMITTED
+            sa_session.add(tool_request)
+            sa_session.flush()
+        except Exception as e:
+            tool_request.state = ToolRequest.states.FAILED
+            tool_request.state_message = str(e)
+            sa_session.add(tool_request)
+            sa_session.flush()
diff --git a/lib/galaxy/model/__init__.py b/lib/galaxy/model/__init__.py
index c19ec9770bcf..a3b97aa79196 100644
--- a/lib/galaxy/model/__init__.py
+++ b/lib/galaxy/model/__init__.py
@@ -1193,6 +1193,33 @@ def __init__(self, user, token=None):
         self.expiration_time = now() + timedelta(hours=24)
 
 
+class ToolSource(Base, Dictifiable, RepresentById):
+    __tablename__ = "tool_source"
+
+    id = Column(Integer, primary_key=True)
+    hash = Column(Unicode(255))
+    source = Column(JSONType)
+
+
+class ToolRequest(Base, Dictifiable, RepresentById):
+    __tablename__ = "tool_request"
+
+    id = Column(Integer, primary_key=True)
+    tool_source_id = Column(Integer, ForeignKey("tool_source.id"), index=True)
+    history_id = Column(Integer, ForeignKey("history.id"), index=True)
+    request = Column(JSONType)
+    state = Column(TrimmedString(32), index=True)
+    state_message = Column(JSONType, index=True)
+
+    tool_source = relationship("ToolSource")
+    history = relationship("History", back_populates="tool_requests")
+
+    class states(str, Enum):
+        NEW = "new"
+        SUBMITTED = "submitted"
+        FAILED = "failed"
+
+
 class DynamicTool(Base, Dictifiable, RepresentById):
     __tablename__ = "dynamic_tool"
 
@@ -1319,7 +1346,9 @@ class Job(Base, JobLike, UsesCreateAndUpdateTime, Dictifiable, Serializable):
     handler = Column(TrimmedString(255), index=True)
     preferred_object_store_id = Column(String(255), nullable=True)
     object_store_id_overrides = Column(JSONType)
+    tool_request_id = Column(Integer, ForeignKey("tool_request.id"))
 
+    tool_request = relationship("ToolRequest")
     user = relationship("User")
     galaxy_session = relationship("GalaxySession")
     history = relationship("History", back_populates="jobs")
@@ -2952,6 +2981,7 @@ class History(Base, HasTags, Dictifiable, UsesAnnotations, HasName, Serializable
     galaxy_sessions = relationship("GalaxySessionToHistoryAssociation", back_populates="history")
     workflow_invocations = relationship("WorkflowInvocation", back_populates="history")
     user = relationship("User", back_populates="histories")
+    tool_requests = relationship("ToolRequest", back_populates="history")
     jobs = relationship("Job", back_populates="history")
 
     update_time = column_property(
diff --git a/lib/galaxy/model/migrations/alembic/versions_gxy/7ffd33d5d144_implement_structured_tool_state.py b/lib/galaxy/model/migrations/alembic/versions_gxy/7ffd33d5d144_implement_structured_tool_state.py
new file mode 100644
index 000000000000..22100a27baaf
--- /dev/null
+++ b/lib/galaxy/model/migrations/alembic/versions_gxy/7ffd33d5d144_implement_structured_tool_state.py
@@ -0,0 +1,47 @@
+"""implement structured tool state
+
+Revision ID: 7ffd33d5d144
+Revises: c39f1de47a04
+Create Date: 2022-11-09 15:53:11.451185
+
+"""
+from alembic import op
+from sqlalchemy import (
+    Column,
+    ForeignKey,
+    Integer,
+    String,
+)
+
+from galaxy.model.custom_types import JSONType
+
+# revision identifiers, used by Alembic.
+revision = "7ffd33d5d144"
+down_revision = "c39f1de47a04"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        "tool_source",
+        Column("id", Integer, primary_key=True),
+        Column("hash", String(255), index=True),
+        Column("source", JSONType),
+    )
+    op.create_table(
+        "tool_request",
+        Column("id", Integer, primary_key=True),
+        Column("request", JSONType),
+        Column("state", String(32)),
+        Column("state_message", JSONType),
+        Column("tool_source_id", Integer, ForeignKey("tool_sources.id"), index=True),
+        Column("history_id", Integer, ForeignKey("history.id"), index=True),
+    )
+    op.add_column("job", Column("tool_request_id", Integer, ForeignKey("tool_source.id"), index=True))
+
+
+def downgrade():
+    op.drop_table("tool_request")
+    op.drop_table("tool_source")
+    op.drop_column("job", "tool_request_id")
diff --git a/lib/galaxy/schema/schema.py b/lib/galaxy/schema/schema.py
index 3ecfb60e3043..63ca95bb32f7 100644
--- a/lib/galaxy/schema/schema.py
+++ b/lib/galaxy/schema/schema.py
@@ -1225,6 +1225,7 @@ class JobIndexQueryPayload(Model):
     history_id: Optional[DecodedDatabaseIdField] = None
     workflow_id: Optional[DecodedDatabaseIdField] = None
     invocation_id: Optional[DecodedDatabaseIdField] = None
+    tool_request_id: Optional[DecodedDatabaseIdField] = None
     order_by: JobIndexSortByEnum = JobIndexSortByEnum.update_time
     search: Optional[str] = None
     limit: int = 500
@@ -3388,6 +3389,16 @@ class AsyncTaskResultSummary(Model):
     )
 
 
+ToolRequestIdField = Field(title="ID", description="Encoded ID of the role")
+
+
+class ToolRequestModel(Model):
+    id: DecodedDatabaseIdField = ToolRequestIdField
+    request: Dict[str, Any]
+    state: str
+    state_message: Optional[str]
+
+
 class AsyncFile(Model):
     storage_request_id: UUID
     task: AsyncTaskResultSummary
diff --git a/lib/galaxy/schema/tasks.py b/lib/galaxy/schema/tasks.py
index dab80ba87935..2add263de288 100644
--- a/lib/galaxy/schema/tasks.py
+++ b/lib/galaxy/schema/tasks.py
@@ -121,3 +121,15 @@ class ComputeDatasetHashTaskRequest(BaseModel):
 
 class PurgeDatasetsTaskRequest(BaseModel):
     dataset_ids: List[int]
+
+
+class ToolSource(BaseModel):
+    raw_tool_source: str
+    tool_dir: str
+
+
+class QueueJobs(BaseModel):
+    tool_source: ToolSource
+    tool_request_id: int  # links to request ("incoming") and history
+    user: RequestUser  # TODO: test anonymous users through this submission path
+    use_cached_jobs: bool
diff --git a/lib/galaxy/tool_util/cwl/parser.py b/lib/galaxy/tool_util/cwl/parser.py
index 2dc573ec9300..41f93bcf1d80 100644
--- a/lib/galaxy/tool_util/cwl/parser.py
+++ b/lib/galaxy/tool_util/cwl/parser.py
@@ -144,6 +144,10 @@ def galaxy_id(self) -> str:
             tool_id = tool_id[1:]
         return tool_id
 
+    @abstractmethod
+    def input_fields(self) -> list:
+        """Return InputInstance objects describing mapping to Galaxy inputs."""
+
     @abstractmethod
     def input_instances(self):
         """Return InputInstance objects describing mapping to Galaxy inputs."""
@@ -236,7 +240,7 @@ def label(self):
         else:
             return ""
 
-    def input_fields(self):
+    def input_fields(self) -> list:
         input_records_schema = self._eval_schema(self._tool.inputs_record_schema)
         if input_records_schema["type"] != "record":
             raise Exception("Unhandled CWL tool input structure")
diff --git a/lib/galaxy/tool_util/parameters/__init__.py b/lib/galaxy/tool_util/parameters/__init__.py
new file mode 100644
index 000000000000..a937708e60da
--- /dev/null
+++ b/lib/galaxy/tool_util/parameters/__init__.py
@@ -0,0 +1,93 @@
+from .convert import (
+    decode,
+    encode,
+)
+from .factory import (
+    from_input_source,
+    input_models_for_pages,
+    input_models_from_json,
+)
+from .models import (
+    BooleanParameterModel,
+    ColorParameterModel,
+    ConditionalParameterModel,
+    ConditionalWhen,
+    CwlBooleanParameterModel,
+    CwlDirectoryParameterModel,
+    CwlFileParameterModel,
+    CwlFloatParameterModel,
+    CwlIntegerParameterModel,
+    CwlNullParameterModel,
+    CwlStringParameterModel,
+    CwlUnionParameterModel,
+    DataCollectionParameterModel,
+    DataParameterModel,
+    FloatParameterModel,
+    HiddenParameterModel,
+    IntegerParameterModel,
+    LabelValue,
+    RepeatParameterModel,
+    RulesParameterModel,
+    SelectParameterModel,
+    TextParameterModel,
+    ToolParameterBundle,
+    ToolParameterBundleModel,
+    ToolParameterModel,
+    ToolParameterT,
+    validate_against_model,
+    validate_internal_request,
+    validate_request,
+    validate_test_case,
+)
+from .state import (
+    JobInternalToolState,
+    RequestInternalToolState,
+    RequestToolState,
+    TestCaseToolState,
+    ToolState,
+)
+from .visitor import visit_input_values
+
+__all__ = (
+    "from_input_source",
+    "input_models_for_pages",
+    "input_models_from_json",
+    "JobInternalToolState",
+    "ToolParameterBundle",
+    "ToolParameterBundleModel",
+    "ToolParameterModel",
+    "IntegerParameterModel",
+    "BooleanParameterModel",
+    "CwlFileParameterModel",
+    "CwlFloatParameterModel",
+    "CwlIntegerParameterModel",
+    "CwlStringParameterModel",
+    "CwlNullParameterModel",
+    "CwlUnionParameterModel",
+    "CwlBooleanParameterModel",
+    "CwlDirectoryParameterModel",
+    "TextParameterModel",
+    "FloatParameterModel",
+    "HiddenParameterModel",
+    "ColorParameterModel",
+    "RulesParameterModel",
+    "DataParameterModel",
+    "DataCollectionParameterModel",
+    "LabelValue",
+    "SelectParameterModel",
+    "ConditionalParameterModel",
+    "ConditionalWhen",
+    "RepeatParameterModel",
+    "validate_against_model",
+    "validate_internal_request",
+    "validate_request",
+    "validate_test_case",
+    "ToolState",
+    "TestCaseToolState",
+    "ToolParameterT",
+    "RequestToolState",
+    "RequestInternalToolState",
+    "visit_input_values",
+    "decode",
+    "encode",
+)
diff --git a/lib/galaxy/tool_util/parameters/_types.py b/lib/galaxy/tool_util/parameters/_types.py
new file mode 100644
index 000000000000..e7a26c26a167
--- /dev/null
+++ b/lib/galaxy/tool_util/parameters/_types.py
@@ -0,0 +1,55 @@
+"""Type utilities for building pydantic models for tool parameters.
+
+Lots of mypy exceptions in here - this code is all well tested and the exceptions
+are fine otherwise because we're using the typing system to interact with pydantic
+and build runtime models not to use mypy to type check static code.
+"""
+
+from typing import (
+    Any,
+    cast,
+    Generic,
+    List,
+    Optional,
+    Type,
+    Union,
+)
+
+# https://stackoverflow.com/questions/56832881/check-if-a-field-is-typing-optional
+# Python >= 3.8
+try:
+    from typing import (
+        get_args,  # type: ignore[attr-defined]
+        get_origin,  # type: ignore[attr-defined]
+    )
+# Compatibility
+except ImportError:
+
+    def get_args(tp: Any) -> tuple:
+        return getattr(tp, "__args__", ()) if tp is not Generic else Generic  # type: ignore[return-value,assignment]
+
+    def get_origin(tp: Any) -> Optional[Any]:
+        return getattr(tp, "__origin__", None)
+
+
+def optional_if_needed(type: Type, is_optional: bool) -> Type:
+    return_type: Type = type
+    if is_optional:
+        return_type = Optional[type]  # type: ignore[assignment]
+    return return_type
+
+
+def union_type(args: List[Type]) -> Type:
+    return Union[tuple(args)]  # type: ignore[return-value]
+
+
+def list_type(arg: Type) -> Type:
+    return List[arg]  # type: ignore[valid-type]
+
+
+def cast_as_type(arg) -> Type:
+    return cast(Type, arg)
+
+
+def is_optional(field) -> bool:
+    return get_origin(field) is Union and type(None) in get_args(field)
diff --git a/lib/galaxy/tool_util/parameters/case.py b/lib/galaxy/tool_util/parameters/case.py
new file mode 100644
index 000000000000..036c2866a9c9
--- /dev/null
+++ b/lib/galaxy/tool_util/parameters/case.py
@@ -0,0 +1,70 @@
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Dict,
+    List,
+)
+
+from .models import (
+    DataCollectionParameterModel,
+    DataParameterModel,
+    FloatParameterModel,
+    IntegerParameterModel,
+    parameters_by_name,
+    ToolParameterBundle,
+    ToolParameterT,
+)
+from .state import TestCaseToolState
+
+
+@dataclass
+class TestCaseStateAndWarnings:
+    tool_state: TestCaseToolState
+    warnings: List[str]
+
+
+def legacy_from_string(parameter: ToolParameterT, value: str, warnings: List[str], profile: str) -> Any:
+    """Convert string values in XML test cases into typed variants.
+
+    This should only be used when parsing XML test cases into a TestCaseToolState object.
+    We have to maintain backward compatibility on these for older Galaxy tool profile versions.
+    """
+    is_string = isinstance(value, str)
+    result_value: Any = value
+    if is_string and isinstance(parameter, (IntegerParameterModel,)):
+        warnings.append(
+            f"Implicitly converted {parameter.name} to an integer from a string value, please use 'value_json' to define this test input parameter value instead."
+        )
+        result_value = int(value)
+    elif is_string and isinstance(parameter, (FloatParameterModel,)):
+        warnings.append(
+            f"Implicitly converted {parameter.name} to a floating point number from a string value, please use 'value_json' to define this test input parameter value instead."
+        )
+        result_value = float(value)
+    return result_value
+
+
+def test_case_state(
+    test_dict: Dict[str, Any], tool_parameter_bundle: ToolParameterBundle, profile: str
+) -> TestCaseStateAndWarnings:
+    warnings: List[str] = []
+    inputs = test_dict["inputs"]
+    state = {}
+    by_name = parameters_by_name(tool_parameter_bundle)
+    for input in inputs:
+        input_name = input["name"]
+        if input_name not in by_name:
+            raise Exception(f"Cannot find tool parameter for {input_name}")
+        tool_parameter_model = by_name[input_name]
+        input_value = input["value"]
+        input_value = legacy_from_string(tool_parameter_model, input_value, warnings, profile)
+        if isinstance(tool_parameter_model, (DataParameterModel,)):
+            pass
+        elif isinstance(tool_parameter_model, (DataCollectionParameterModel,)):
+            pass
+
+        state[input_name] = input_value
+
+    tool_state = TestCaseToolState(state)
+    tool_state.validate(tool_parameter_bundle)
+    return TestCaseStateAndWarnings(tool_state, warnings)
diff --git a/lib/galaxy/tool_util/parameters/convert.py b/lib/galaxy/tool_util/parameters/convert.py
new file mode 100644
index 000000000000..23ff762cae12
--- /dev/null
+++ b/lib/galaxy/tool_util/parameters/convert.py
@@ -0,0 +1,72 @@
+"""Utilities for converting between request states.
+"""
+from typing import (
+    Any,
+    Callable,
+)
+
+from .models import (
+    ToolParameterBundle,
+    ToolParameterT,
+)
+from .state import (
+    RequestInternalToolState,
+    RequestToolState,
+)
+from .visitor import (
+    visit_input_values,
+    VISITOR_NO_REPLACEMENT,
+)
+
+
+def decode(
+    external_state: RequestToolState, input_models: ToolParameterBundle, decode_id: Callable[[str], int]
+) -> RequestInternalToolState:
+    """Prepare an external representation of tool state (request) for storing in the database (request_internal)."""
+
+    external_state.validate(input_models)
+
+    def decode_callback(parameter: ToolParameterT, value: Any):
+        if parameter.parameter_type == "gx_data":
+            assert isinstance(value, dict), str(value)
+            assert "id" in value
+            decoded_dict = value.copy()
+            decoded_dict["id"] = decode_id(value["id"])
+            return decoded_dict
+        else:
+            return VISITOR_NO_REPLACEMENT
+
+    internal_state_dict = visit_input_values(
+        input_models,
+        external_state,
+        decode_callback,
+    )
+
+    internal_request_state = RequestInternalToolState(internal_state_dict)
+    internal_request_state.validate(input_models)
+    return internal_request_state
+
+
+def encode(
+    external_state: RequestInternalToolState, input_models: ToolParameterBundle, encode_id: Callable[[int], str]
+) -> RequestToolState:
+    """Prepare an external representation of tool state (request) for storing in the database (request_internal)."""
+
+    def encode_callback(parameter: ToolParameterT, value: Any):
+        if parameter.parameter_type == "gx_data":
+            assert isinstance(value, dict), str(value)
+            assert "id" in value
+            encoded_dict = value.copy()
+            encoded_dict["id"] = encode_id(value["id"])
+            return encoded_dict
+        else:
+            return VISITOR_NO_REPLACEMENT
+
+    request_state_dict = visit_input_values(
+        input_models,
+        external_state,
+        encode_callback,
+    )
+    request_state = RequestToolState(request_state_dict)
+    request_state.validate(input_models)
+    return request_state
diff --git a/lib/galaxy/tool_util/parameters/factory.py b/lib/galaxy/tool_util/parameters/factory.py
new file mode 100644
index 000000000000..777ffe2b46fa
--- /dev/null
+++ b/lib/galaxy/tool_util/parameters/factory.py
@@ -0,0 +1,271 @@
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+)
+
+from galaxy.tool_util.parser.cwl import CwlInputSource
+from galaxy.tool_util.parser.interface import (
+    InputSource,
+    PageSource,
+    PagesSource,
+)
+from .models import (
+    BooleanParameterModel,
+    ColorParameterModel,
+    ConditionalParameterModel,
+    ConditionalWhen,
+    CwlBooleanParameterModel,
+    CwlDirectoryParameterModel,
+    CwlFileParameterModel,
+    CwlFloatParameterModel,
+    CwlIntegerParameterModel,
+    CwlNullParameterModel,
+    CwlStringParameterModel,
+    CwlUnionParameterModel,
+    DataCollectionParameterModel,
+    DataParameterModel,
+    FloatParameterModel,
+    HiddenParameterModel,
+    IntegerParameterModel,
+    LabelValue,
+    RepeatParameterModel,
+    RulesParameterModel,
+    SelectParameterModel,
+    TextParameterModel,
+    ToolParameterBundle,
+    ToolParameterBundleModel,
+    ToolParameterT,
+)
+
+
+class ParameterDefinitionError(Exception):
+    pass
+
+
+def get_color_value(input_source: InputSource) -> str:
+    return input_source.get("value", "#000000")
+
+
+def _from_input_source_galaxy(input_source: InputSource) -> ToolParameterT:
+    input_type = input_source.parse_input_type()
+    if input_type == "param":
+        param_type = input_source.get("type")
+        if param_type == "integer":
+            optional = input_source.parse_optional()
+            value = input_source.get("value")
+            int_value: Optional[int]
+            if value:
+                int_value = int(value)
+            elif optional:
+                int_value = None
+            else:
+                raise ParameterDefinitionError()
+            return IntegerParameterModel(name=input_source.parse_name(), optional=optional, value=int_value)
+        elif param_type == "boolean":
+            nullable = input_source.parse_optional()
+            checked = input_source.get_bool("checked", None if nullable else False)
+            return BooleanParameterModel(
+                name=input_source.parse_name(),
+                optional=nullable,
+                value=checked,
+            )
+        elif param_type == "text":
+            optional = input_source.parse_optional()
+            return TextParameterModel(
+                name=input_source.parse_name(),
+                optional=optional,
+            )
+        elif param_type == "float":
+            optional = input_source.parse_optional()
+            value = input_source.get("value")
+            float_value: Optional[float]
+            if value:
+                float_value = float(value)
+            elif optional:
+                float_value = None
+            else:
+                raise ParameterDefinitionError()
+            return FloatParameterModel(
+                name=input_source.parse_name(),
+                optional=optional,
+                value=float_value,
+            )
+        elif param_type == "hidden":
+            optional = input_source.parse_optional()
+            return HiddenParameterModel(
+                name=input_source.parse_name(),
+                optional=optional,
+            )
+        elif param_type == "color":
+            optional = input_source.parse_optional()
+            return ColorParameterModel(
+                name=input_source.parse_name(),
+                optional=optional,
+                value=get_color_value(input_source),
+            )
+        elif param_type == "rules":
+            return RulesParameterModel(
+                name=input_source.parse_name(),
+            )
+        elif param_type == "data":
+            optional = input_source.parse_optional()
+            multiple = input_source.get_bool("multiple", False)
+            return DataParameterModel(
+                name=input_source.parse_name(),
+                optional=optional,
+                multiple=multiple,
+            )
+        elif param_type == "data_collection":
+            optional = input_source.parse_optional()
+            return DataCollectionParameterModel(
+                name=input_source.parse_name(),
+                optional=optional,
+            )
+        elif param_type == "select":
+            # Function... example in devteam cummeRbund.
+            optional = input_source.parse_optional()
+            dynamic_options = input_source.get("dynamic_options", None)
+            dynamic_options_elem = input_source.parse_dynamic_options_elem()
+            multiple = input_source.get_bool("multiple", False)
+            is_static = dynamic_options is None and dynamic_options_elem is None
+            options: Optional[List[LabelValue]] = None
+            if is_static:
+                options = []
+                for (option_label, option_value, selected) in input_source.parse_static_options():
+                    options.append(LabelValue(label=option_label, value=option_value, selected=selected))
+            return SelectParameterModel(
+                name=input_source.parse_name(),
+                optional=optional,
+                options=options,
+                multiple=multiple,
+            )
+        else:
+            raise Exception(f"Unknown Galaxy parameter type {param_type}")
+    elif input_type == "conditional":
+        test_param_input_source = input_source.parse_test_input_source()
+        test_parameter = _from_input_source_galaxy(test_param_input_source)
+        whens = []
+        default_value = object()
+        if isinstance(test_parameter, BooleanParameterModel):
+            default_value = test_parameter.value
+        # TODO: handle select parameter model...
+        for (value, case_inputs_sources) in input_source.parse_when_input_sources():
+            if isinstance(test_parameter, BooleanParameterModel):
+                # TODO: investigate truevalue/falsevalue when...
+                from galaxy.util import string_as_bool
+
+                typed_value = string_as_bool(value)
+            else:
+                typed_value = value
+
+            tool_parameter_models = input_models_for_page(case_inputs_sources)
+            is_default_when = False
+            if typed_value == default_value:
+                is_default_when = True
+            whens.append(
+                ConditionalWhen(discriminator=value, parameters=tool_parameter_models, is_default_when=is_default_when)
+            )
+        return ConditionalParameterModel(
+            name=input_source.parse_name(),
+            test_parameter=test_parameter,
+            whens=whens,
+        )
+    elif input_type == "repeat":
+        # TODO: min/max
+        name = input_source.get("name")
+        # title = input_source.get("title")
+        # help = input_source.get("help", None)
+        instance_sources = input_source.parse_nested_inputs_source()
+        instance_tool_parameter_models = input_models_for_page(instance_sources)
+        return RepeatParameterModel(
+            name=name,
+            parameters=instance_tool_parameter_models,
+        )
+    else:
+        raise Exception(
+            f"Cannot generate tool parameter model for supplied tool source - unknown input_type {input_type}"
+        )
+
+
+def _simple_cwl_type_to_model(simple_type: str, input_source: CwlInputSource):
+    if simple_type == "int":
+        return CwlIntegerParameterModel(
+            name=input_source.parse_name(),
+        )
+    elif simple_type == "float":
+        return CwlFloatParameterModel(
+            name=input_source.parse_name(),
+        )
+    elif simple_type == "null":
+        return CwlNullParameterModel(
+            name=input_source.parse_name(),
+        )
+    elif simple_type == "string":
+        return CwlStringParameterModel(
+            name=input_source.parse_name(),
+        )
+    elif simple_type == "boolean":
+        return CwlBooleanParameterModel(
+            name=input_source.parse_name(),
+        )
+    elif simple_type == "org.w3id.cwl.cwl.File":
+        return CwlFileParameterModel(
+            name=input_source.parse_name(),
+        )
+    elif simple_type == "org.w3id.cwl.cwl.Directory":
+        return CwlDirectoryParameterModel(
+            name=input_source.parse_name(),
+        )
+    raise NotImplementedError(
+        f"Cannot generate tool parameter model for this CWL artifact yet - contains unknown type {simple_type}."
+    )
+
+
+def _from_input_source_cwl(input_source: CwlInputSource) -> ToolParameterT:
+    schema_salad_field = input_source.field
+    if schema_salad_field is None:
+        raise NotImplementedError("Cannot generate tool parameter model for this CWL artifact yet.")
+    if "type" not in schema_salad_field:
+        raise NotImplementedError("Cannot generate tool parameter model for this CWL artifact yet.")
+    schema_salad_type = schema_salad_field["type"]
+    if isinstance(schema_salad_type, str):
+        return _simple_cwl_type_to_model(schema_salad_type, input_source)
+    elif isinstance(schema_salad_type, list):
+        return CwlUnionParameterModel(
+            name=input_source.parse_name(),
+            parameters=[_simple_cwl_type_to_model(t, input_source) for t in schema_salad_type],
+        )
+    else:
+        raise NotImplementedError("Cannot generate tool parameter model for this CWL artifact yet.")
+
+
+def input_models_from_json(json: List[Dict[str, Any]]) -> ToolParameterBundle:
+    return ToolParameterBundleModel(input_models=json)
+
+
+def input_models_for_pages(pages: PagesSource) -> List[ToolParameterT]:
+    input_models = []
+    if pages.inputs_defined:
+        for page_source in pages.page_sources:
+            input_models.extend(input_models_for_page(page_source))
+
+    return input_models
+
+
+def input_models_for_page(page_source: PageSource) -> List[ToolParameterT]:
+    input_models = []
+    for input_source in page_source.parse_input_sources():
+        tool_parameter_model = from_input_source(input_source)
+        input_models.append(tool_parameter_model)
+    return input_models
+
+
+def from_input_source(input_source: InputSource) -> ToolParameterT:
+    tool_parameter: ToolParameterT
+    if isinstance(input_source, CwlInputSource):
+        tool_parameter = _from_input_source_cwl(input_source)
+    else:
+        tool_parameter = _from_input_source_galaxy(input_source)
+    return tool_parameter
diff --git a/lib/galaxy/tool_util/parameters/models.py b/lib/galaxy/tool_util/parameters/models.py
new file mode 100644
index 000000000000..4762df49ec5f
--- /dev/null
+++ b/lib/galaxy/tool_util/parameters/models.py
@@ -0,0 +1,878 @@
+# attempt to model requires_value...
+# conditional can descend...
+from abc import abstractmethod
+from typing import (
+    Any,
+    cast,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    NamedTuple,
+    Optional,
+    Type,
+    Union,
+)
+
+from pydantic import (
+    BaseConfig,
+    BaseModel,
+    create_model,
+    Extra,
+    Field,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+    validator,
+)
+from pydantic.error_wrappers import ValidationError
+from typing_extensions import (
+    Literal,
+    Protocol,
+)
+
+from galaxy.exceptions import RequestParameterInvalidException
+from ._types import (
+    cast_as_type,
+    is_optional,
+    list_type,
+    optional_if_needed,
+    union_type,
+)
+
+# TODO:
+# - implement job vs request...
+# - drill down
+# - implement data_ref on rules and implement some cross model validation
+# - Optional conditionals... work through that?
+# - Sections - fight that battle again...
+
+# + request: Return info needed to build request pydantic model at runtime.
+# + request_internal: This is a pydantic model to validate what Galaxy expects to find in the database,
+# in particular dataset and collection references should be decoded integers.
+StateRepresentationT = Literal["request", "request_internal", "job_internal", "test_case"]
+
+
+# could be made more specific - validators need to be classmethod
+ValidatorDictT = Dict[str, "classmethod[Any]"]
+
+
+class DynamicModelInformation(NamedTuple):
+    name: str
+    definition: tuple
+    validators: ValidatorDictT
+
+
+class StrictModel(BaseModel):
+    class Config:
+        extra = Extra.forbid
+
+
+def allow_batching(job_template: DynamicModelInformation, batch_type: Optional[Type] = None) -> DynamicModelInformation:
+    job_py_type: Type = job_template.definition[0]
+    default_value = job_template.definition[1]
+    batch_type = batch_type or job_py_type
+
+    class BatchRequest(StrictModel):
+        meta_class: Literal["Batch"] = Field(..., alias="__class__")
+        values: List[batch_type]  # type: ignore[valid-type]
+
+    request_type = union_type([job_py_type, BatchRequest])
+
+    return DynamicModelInformation(
+        job_template.name,
+        (request_type, default_value),
+        {},  # should we modify these somehow?
+    )
+
+
+class Validators:
+    def validate_not_none(cls, v):
+        assert v is not None, "null is an invalid value for attribute"
+        return v
+
+
+class ParamModel(Protocol):
+    @property
+    def name(self) -> str:
+        ...
+
+    @property
+    def request_requires_value(self) -> bool:
+        # if this is a non-optional type and no default is defined - an
+        # input value MUST be specified.
+        ...
+
+
+def dynamic_model_information_from_py_type(param_model: ParamModel, py_type: Type):
+    name = param_model.name
+    initialize = ... if param_model.request_requires_value else None
+    py_type_is_optional = is_optional(py_type)
+    if not py_type_is_optional and not param_model.request_requires_value:
+        validators = {"not_null": validator(name, allow_reuse=True)(Validators.validate_not_none)}
+    else:
+        validators = {}
+
+    return DynamicModelInformation(
+        name,
+        (py_type, initialize),
+        validators,
+    )
+
+
+# We probably need incoming (parameter def) and outgoing (parameter value as transmitted) models,
+# where value in the incoming model means "default value" and value in the outgoing model is the actual
+# value a user has set. (incoming/outgoing from the client perspective).
+class BaseToolParameterModelDefinition(BaseModel):
+    name: str
+    parameter_type: str
+
+    @abstractmethod
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        """Return info needed to build Pydantic model at runtime for validation."""
+
+
+class BaseGalaxyToolParameterModelDefinition(BaseToolParameterModelDefinition):
+    hidden: bool = False
+    label: Optional[str] = None
+    help: Optional[str] = None
+    argument: Optional[str]
+    refresh_on_change: bool = False
+    is_dynamic = False
+    optional: bool = False
+
+
+class LabelValue(BaseModel):
+    label: str
+    value: str
+    selected: bool
+
+
+class TextParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_text"] = "gx_text"
+    area: bool = False
+    default_value: Optional[str] = Field(alias="value")
+    default_options: List[LabelValue] = []
+
+    @property
+    def py_type(self) -> Type:
+        return optional_if_needed(StrictStr, self.optional)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def request_requires_value(self) -> bool:
+        return False
+
+
+class IntegerParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_integer"] = "gx_integer"
+    optional: bool
+    value: Optional[int]
+    min: Optional[int]
+    max: Optional[int]
+
+    @property
+    def py_type(self) -> Type:
+        return optional_if_needed(StrictInt, self.optional)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def request_requires_value(self) -> bool:
+        return False
+
+
+class FloatParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_float"] = "gx_float"
+    value: Optional[float]
+    min: Optional[float]
+    max: Optional[float]
+
+    @property
+    def py_type(self) -> Type:
+        return optional_if_needed(union_type([StrictInt, StrictFloat]), self.optional)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def request_requires_value(self) -> bool:
+        return False
+
+
+DataSrcT = Literal["hda", "ldda"]
+MultiDataSrcT = Literal["hda", "ldda", "hdca"]
+CollectionStrT = Literal["hdca"]
+
+TestCaseDataSrcT = Literal["File"]
+
+
+class DataRequest(StrictModel):
+    src: DataSrcT
+    id: StrictStr
+
+
+class BatchDataInstance(StrictModel):
+    src: MultiDataSrcT
+    id: StrictStr
+
+
+class MultiDataInstance(StrictModel):
+    src: MultiDataSrcT
+    id: StrictStr
+
+
+MultiDataRequest: Type = union_type([MultiDataInstance, List[MultiDataInstance]])
+
+
+class DataRequestInternal(StrictModel):
+    src: DataSrcT
+    id: StrictInt
+
+
+class BatchDataInstanceInternal(StrictModel):
+    src: MultiDataSrcT
+    id: StrictInt
+
+
+class MultiDataInstanceInternal(StrictModel):
+    src: MultiDataSrcT
+    id: StrictInt
+
+
+class DataTestCaseValue(StrictModel):
+    src: TestCaseDataSrcT = Field("class")
+    path: str
+
+
+class MultipleDataTestCaseValue(StrictModel):
+    __root__: List[DataTestCaseValue]
+
+
+MultiDataRequestInternal: Type = union_type([MultiDataInstanceInternal, List[MultiDataInstanceInternal]])
+
+
+class DataParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_data"] = "gx_data"
+    extensions: List[str] = ["data"]
+    multiple: bool = False
+    min: Optional[int]
+    max: Optional[int]
+
+    @property
+    def py_type(self) -> Type:
+        base_model: Type
+        if self.multiple:
+            base_model = MultiDataRequest
+        else:
+            base_model = DataRequest
+        return optional_if_needed(base_model, self.optional)
+
+    @property
+    def py_type_internal(self) -> Type:
+        base_model: Type
+        if self.multiple:
+            base_model = MultiDataRequestInternal
+        else:
+            base_model = DataRequestInternal
+        return optional_if_needed(base_model, self.optional)
+
+    @property
+    def py_type_test_case(self) -> Type:
+        base_model: Type
+        if self.multiple:
+            base_model = MultiDataRequestInternal
+        else:
+            base_model = DataTestCaseValue
+        return optional_if_needed(base_model, self.optional)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        if state_representation == "request":
+            return allow_batching(dynamic_model_information_from_py_type(self, self.py_type), BatchDataInstance)
+        elif state_representation == "request_internal":
+            return allow_batching(
+                dynamic_model_information_from_py_type(self, self.py_type_internal), BatchDataInstanceInternal
+            )
+        elif state_representation == "job_internal":
+            return dynamic_model_information_from_py_type(self, self.py_type_internal)
+        elif state_representation == "test_case":
+            return dynamic_model_information_from_py_type(self, self.py_type_test_case)
+
+    @property
+    def request_requires_value(self) -> bool:
+        return not self.optional
+
+
+class DataCollectionRequest(StrictModel):
+    src: CollectionStrT
+    id: StrictStr
+
+
+class DataCollectionRequestInternal(StrictModel):
+    src: CollectionStrT
+    id: StrictInt
+
+
+class DataCollectionParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_data_collection"] = "gx_data_collection"
+    collection_type: Optional[str]
+    extensions: List[str] = ["data"]
+
+    @property
+    def py_type(self) -> Type:
+        return optional_if_needed(DataCollectionRequest, self.optional)
+
+    @property
+    def py_type_internal(self) -> Type:
+        return optional_if_needed(DataCollectionRequestInternal, self.optional)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        if state_representation == "request":
+            return allow_batching(dynamic_model_information_from_py_type(self, self.py_type))
+        elif state_representation == "request_internal":
+            return allow_batching(dynamic_model_information_from_py_type(self, self.py_type_internal))
+        else:
+            raise NotImplementedError("...")
+
+    @property
+    def request_requires_value(self) -> bool:
+        return not self.optional
+
+
+class HiddenParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_hidden"] = "gx_hidden"
+
+    @property
+    def py_type(self) -> Type:
+        return optional_if_needed(StrictStr, self.optional)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def request_requires_value(self) -> bool:
+        return not self.optional
+
+
+def ensure_color_valid(value: Optional[Any]):
+    if value is None:
+        return
+    if not isinstance(value, str):
+        raise TypeError(f"Invalid color value type {value.__class__} encountered.")
+    value_str: str = value
+    message = f"Invalid color value string format {value_str} encountered."
+    if len(value_str) != 7:
+        raise ValueError(message + "0")
+    if value_str[0] != "#":
+        raise ValueError(message + "1")
+    for byte_str in value_str[1:]:
+        if byte_str not in "0123456789abcdef":
+            raise ValueError(message + "2")
+
+
+class ColorParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_color"] = "gx_color"
+    value: Optional[str]
+
+    @property
+    def py_type(self) -> Type:
+        return optional_if_needed(StrictStr, self.optional)
+
+    @classmethod
+    def validate_color_str(c, value: str) -> str:
+        ensure_color_valid(value)
+        return value
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        validators = {"color_format": validator(self.name, allow_reuse=True)(ColorParameterModel.validate_color_str)}
+        return DynamicModelInformation(
+            self.name,
+            (self.py_type, ...),
+            validators,
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return False
+
+
+class BooleanParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_boolean"] = "gx_boolean"
+    value: Optional[bool] = False
+    truevalue: Optional[str]
+    falsevalue: Optional[str]
+
+    @property
+    def py_type(self) -> Type:
+        return optional_if_needed(StrictBool, self.optional)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def request_requires_value(self) -> bool:
+        # these parameters always have an implicit default - either None if
+        # if it is optional or 'checked' if not (itself defaulting to False).
+        return False
+
+
+class DirectoryUriParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_directory_uri"]
+    value: Optional[str]
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True
+
+
+class RulesMapping(StrictModel):
+    type: str
+    columns: List[StrictInt]
+
+
+class RulesModel(StrictModel):
+    rules: List[Dict[str, Any]]
+    mappings: List[RulesMapping]
+
+
+class RulesParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_rules"] = "gx_rules"
+
+    @property
+    def py_type(self) -> Type:
+        return RulesModel
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True
+
+
+class SelectParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_select"] = "gx_select"
+    options: Optional[List[LabelValue]] = None
+    multiple: bool
+
+    @property
+    def py_type(self) -> Type:
+        if self.options is not None:
+            literal_options: List[Type] = [cast_as_type(Literal[o.value]) for o in self.options]
+            py_type = union_type(literal_options)
+        else:
+            py_type = StrictStr
+        if self.multiple:
+            py_type = list_type(py_type)
+        return optional_if_needed(py_type, self.optional)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def has_selected_static_option(self):
+        return self.options is not None and any([o.selected for o in self.options])
+
+    @property
+    def request_requires_value(self) -> bool:
+        return not self.optional and not self.has_selected_static_option
+
+
+DiscriminatorType = Union[bool, str]
+
+
+class ConditionalWhen(StrictModel):
+    discriminator: DiscriminatorType
+    parameters: List["ToolParameterT"]
+    is_default_when: bool
+
+
+class ConditionalParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_conditional"] = "gx_conditional"
+    test_parameter: Union[BooleanParameterModel, SelectParameterModel]
+    whens: List[ConditionalWhen]
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        test_param_name = self.test_parameter.name
+        test_info = self.test_parameter.pydantic_template(state_representation)
+        extra_validators = test_info.validators
+        test_parameter_requires_value = self.test_parameter.request_requires_value
+        when_types: List[Type[BaseModel]] = []
+        default_type = None
+        for when in self.whens:
+            discriminator = when.discriminator
+            parameters = when.parameters
+            if test_parameter_requires_value:
+                initialize_test = ...
+            else:
+                initialize_test = None
+            extra_kwd = {test_param_name: (Literal[discriminator], initialize_test)}
+            when_types.append(
+                create_field_model(
+                    parameters,
+                    f"When_{test_param_name}_{discriminator}",
+                    state_representation,
+                    extra_kwd=extra_kwd,
+                    extra_validators=extra_validators,
+                )
+            )
+            if when.is_default_when:
+                extra_kwd = {}
+                default_type = create_field_model(
+                    parameters,
+                    f"When_{test_param_name}___absent",
+                    state_representation,
+                    extra_kwd=extra_kwd,
+                    extra_validators={},
+                )
+
+        cond_type = union_type(when_types)
+
+        class ConditionalType(BaseModel):
+            __root__: cond_type = Field(..., discriminator=test_param_name)  # type: ignore[valid-type]
+
+        if default_type is not None:
+            # Cannot find a way in Pydantic version 1.0 to have None/null or "parameter missing"
+            # as a discriminator value - so we build a whole second model for that type missing
+            # is is default_type.
+            py_type = union_type([ConditionalType, default_type])
+            # TODO: need to figure out how request_requires_value on default_type so we
+            # know how initial here.
+            initialize_cond = None
+        else:
+            py_type = ConditionalType
+            initialize_cond = ...
+
+        return DynamicModelInformation(
+            self.name,
+            (py_type, initialize_cond),
+            {},
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return False  # TODO
+
+
+class RepeatParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["gx_repeat"] = "gx_repeat"
+    parameters: List["ToolParameterT"]
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        # Maybe validators for min and max...
+        instance_class: Type[BaseModel] = create_field_model(
+            self.parameters, f"Repeat_{self.name}", state_representation
+        )
+
+        class RepeatType(BaseModel):
+            __root__: List[instance_class]  # type: ignore[valid-type]
+
+        return DynamicModelInformation(
+            self.name,
+            (RepeatType, ...),
+            {},
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True  # TODO:
+
+
+LiteralNone: Type = Literal[None]  # type: ignore[assignment]
+
+
+class CwlNullParameterModel(BaseToolParameterModelDefinition):
+    parameter_type: Literal["cwl_null"] = "cwl_null"
+
+    @property
+    def py_type(self) -> Type:
+        return LiteralNone
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return DynamicModelInformation(
+            self.name,
+            (self.py_type, ...),
+            {},
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return False
+
+
+class CwlStringParameterModel(BaseToolParameterModelDefinition):
+    parameter_type: Literal["cwl_string"] = "cwl_string"
+
+    @property
+    def py_type(self) -> Type:
+        return StrictStr
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return DynamicModelInformation(
+            self.name,
+            (self.py_type, ...),
+            {},
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True
+
+
+class CwlIntegerParameterModel(BaseToolParameterModelDefinition):
+    parameter_type: Literal["cwl_integer"] = "cwl_integer"
+
+    @property
+    def py_type(self) -> Type:
+        return StrictInt
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return DynamicModelInformation(
+            self.name,
+            (self.py_type, ...),
+            {},
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True
+
+
+class CwlFloatParameterModel(BaseToolParameterModelDefinition):
+    parameter_type: Literal["cwl_float"] = "cwl_float"
+
+    @property
+    def py_type(self) -> Type:
+        return union_type([StrictFloat, StrictInt])
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return DynamicModelInformation(
+            self.name,
+            (self.py_type, ...),
+            {},
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True
+
+
+class CwlBooleanParameterModel(BaseToolParameterModelDefinition):
+    parameter_type: Literal["cwl_boolean"] = "cwl_boolean"
+
+    @property
+    def py_type(self) -> Type:
+        return StrictBool
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return DynamicModelInformation(
+            self.name,
+            (self.py_type, ...),
+            {},
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True
+
+
+class CwlUnionParameterModel(BaseToolParameterModelDefinition):
+    parameter_type: Literal["cwl_union"] = "cwl_union"
+    parameters: List["CwlParameterT"]
+
+    @property
+    def py_type(self) -> Type:
+        union_of_cwl_types: List[Type] = []
+        for parameter in self.parameters:
+            union_of_cwl_types.append(parameter.py_type)
+        return union_type(union_of_cwl_types)
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+
+        return DynamicModelInformation(
+            self.name,
+            (self.py_type, ...),
+            {},
+        )
+
+    @property
+    def request_requires_value(self) -> bool:
+        return False  # TODO:
+
+
+class CwlFileParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["cwl_file"] = "cwl_file"
+
+    @property
+    def py_type(self) -> Type:
+        return DataRequest
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True
+
+
+class CwlDirectoryParameterModel(BaseGalaxyToolParameterModelDefinition):
+    parameter_type: Literal["cwl_directory"] = "cwl_directory"
+
+    @property
+    def py_type(self) -> Type:
+        return DataRequest
+
+    def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        return dynamic_model_information_from_py_type(self, self.py_type)
+
+    @property
+    def request_requires_value(self) -> bool:
+        return True
+
+
+CwlParameterT = Union[
+    CwlIntegerParameterModel,
+    CwlFloatParameterModel,
+    CwlStringParameterModel,
+    CwlBooleanParameterModel,
+    CwlNullParameterModel,
+    CwlFileParameterModel,
+    CwlDirectoryParameterModel,
+    CwlUnionParameterModel,
+]
+
+GalaxyParameterT = Union[
+    TextParameterModel,
+    IntegerParameterModel,
+    FloatParameterModel,
+    BooleanParameterModel,
+    HiddenParameterModel,
+    SelectParameterModel,
+    DataParameterModel,
+    DataCollectionParameterModel,
+    DirectoryUriParameterModel,
+    RulesParameterModel,
+    ColorParameterModel,
+    ConditionalParameterModel,
+    RepeatParameterModel,
+]
+
+ToolParameterT = Union[
+    CwlParameterT,
+    GalaxyParameterT,
+]
+
+
+class ToolParameterModel(BaseModel):
+    __root__: ToolParameterT = Field(..., discriminator="parameter_type")
+
+
+ConditionalWhen.update_forward_refs()
+ConditionalParameterModel.update_forward_refs()
+RepeatParameterModel.update_forward_refs()
+CwlUnionParameterModel.update_forward_refs()
+
+
+class ToolParameterBundle(Protocol):
+    """An object having a dictionary of input models (i.e. a 'Tool')"""
+
+    # TODO: rename to parameters to align with ConditionalWhen and Repeat.
+    input_models: List[ToolParameterT]
+
+
+class ToolParameterBundleModel(BaseModel):
+
+    input_models: List[ToolParameterT]
+
+
+def parameters_by_name(tool_parameter_bundle: ToolParameterBundle) -> Dict[str, ToolParameterT]:
+    as_dict = {}
+    for input_model in simple_input_models(tool_parameter_bundle.input_models):
+        as_dict[input_model.name] = input_model
+    return as_dict
+
+
+def to_simple_model(input_parameter: Union[ToolParameterModel, ToolParameterT]) -> ToolParameterT:
+    if input_parameter.__class__ == ToolParameterModel:
+        assert isinstance(input_parameter, ToolParameterModel)
+        return cast(ToolParameterT, input_parameter.__root__)
+    else:
+        return cast(ToolParameterT, input_parameter)
+
+
+def simple_input_models(
+    input_models: Union[List[ToolParameterModel], List[ToolParameterT]]
+) -> Iterable[ToolParameterT]:
+    return [to_simple_model(m) for m in input_models]
+
+
+def create_model_strict(*args, **kwd) -> Type[BaseModel]:
+    class Config(BaseConfig):
+        extra = Extra.forbid
+
+    return create_model(*args, __config__=Config, **kwd)
+
+
+def create_request_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
+    return create_field_model(tool.input_models, name, "request")
+
+
+def create_request_internal_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
+    return create_field_model(tool.input_models, name, "request_internal")
+
+
+def create_test_case_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
+    return create_field_model(tool.input_models, name, "test_case")
+
+
+def create_field_model(
+    tool_parameter_models: Union[List[ToolParameterModel], List[ToolParameterT]],
+    name: str,
+    state_representation: StateRepresentationT,
+    extra_kwd: Optional[Mapping[str, tuple]] = None,
+    extra_validators: Optional[ValidatorDictT] = None,
+):
+    kwd: Dict[str, tuple] = {}
+    if extra_kwd:
+        kwd.update(extra_kwd)
+    model_validators = (extra_validators or {}).copy()
+
+    for input_model in tool_parameter_models:
+        input_model = to_simple_model(input_model)
+        input_name = input_model.name
+        pydantic_request_template = input_model.pydantic_template(state_representation)
+        kwd[input_name] = pydantic_request_template.definition
+        input_validators = pydantic_request_template.validators
+        for validator_name, validator_callable in input_validators.items():
+            model_validators[f"{input_name}_{validator_name}"] = validator_callable
+
+    pydantic_model = create_model_strict(name, __validators__=model_validators, **kwd)
+    return pydantic_model
+
+
+def validate_against_model(pydantic_model: Type[BaseModel], parameter_state: Dict[str, Any]) -> None:
+    try:
+        pydantic_model(**parameter_state)
+    except ValidationError as e:
+        # TODO: Improve this or maybe add a handler for this in the FastAPI exception
+        # handler.
+        raise RequestParameterInvalidException(str(e))
+
+
+def validate_request(tool: ToolParameterBundle, request: Dict[str, Any]) -> None:
+    pydantic_model = create_request_model(tool)
+    validate_against_model(pydantic_model, request)
+
+
+def validate_internal_request(tool: ToolParameterBundle, request: Dict[str, Any]) -> None:
+    pydantic_model = create_request_internal_model(tool)
+    validate_against_model(pydantic_model, request)
+
+
+def validate_test_case(tool: ToolParameterBundle, request: Dict[str, Any]) -> None:
+    pydantic_model = create_test_case_model(tool)
+    validate_against_model(pydantic_model, request)
diff --git a/lib/galaxy/tool_util/parameters/state.py b/lib/galaxy/tool_util/parameters/state.py
new file mode 100644
index 000000000000..1a4bf6b1acb4
--- /dev/null
+++ b/lib/galaxy/tool_util/parameters/state.py
@@ -0,0 +1,77 @@
+from abc import (
+    ABC,
+    abstractmethod,
+)
+from typing import (
+    Any,
+    Dict,
+    Optional,
+    Type,
+)
+
+from pydantic import BaseModel
+from typing_extensions import Literal
+
+from .models import (
+    create_request_internal_model,
+    create_request_model,
+    StateRepresentationT,
+    ToolParameterBundle,
+    validate_against_model,
+)
+
+
+class ToolState(ABC):
+    input_state: Dict[str, Any]
+
+    def __init__(self, input_state: Dict[str, Any]):
+        self.input_state = input_state
+
+    def _validate(self, pydantic_model: Type[BaseModel]) -> None:
+        validate_against_model(pydantic_model, self.input_state)
+
+    def validate(self, input_models: ToolParameterBundle) -> None:
+        base_model = self._to_base_model(input_models)
+        if base_model is None:
+            raise NotImplementedError(
+                f"Validating tool state against state representation {self.state_representation} is not implemented."
+            )
+        self._validate(base_model)
+
+    @property
+    @abstractmethod
+    def state_representation(self) -> StateRepresentationT:
+        """Get state representation of the inputs."""
+
+    def _to_base_model(self, input_models: ToolParameterBundle) -> Optional[Type[BaseModel]]:
+        return None
+
+
+class RequestToolState(ToolState):
+    state_representation: Literal["request"] = "request"
+
+    def _to_base_model(self, input_models: ToolParameterBundle) -> Type[BaseModel]:
+        return create_request_model(input_models)
+
+
+class RequestInternalToolState(ToolState):
+    state_representation: Literal["request_internal"] = "request_internal"
+
+    def _to_base_model(self, input_models: ToolParameterBundle) -> Type[BaseModel]:
+        return create_request_internal_model(input_models)
+
+
+class JobInternalToolState(ToolState):
+    state_representation: Literal["job_internal"] = "job_internal"
+
+    def _to_base_model(self, input_models: ToolParameterBundle) -> Type[BaseModel]:
+        # implement a job model...
+        return create_request_internal_model(input_models)
+
+
+class TestCaseToolState(ToolState):
+    state_representation: Literal["test_case"] = "test_case"
+
+    def _to_base_model(self, input_models: ToolParameterBundle) -> Type[BaseModel]:
+        # implement a test case model...
+        return create_request_internal_model(input_models)
diff --git a/lib/galaxy/tool_util/parameters/visitor.py b/lib/galaxy/tool_util/parameters/visitor.py
new file mode 100644
index 000000000000..7b68afa4a0aa
--- /dev/null
+++ b/lib/galaxy/tool_util/parameters/visitor.py
@@ -0,0 +1,56 @@
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+)
+
+from typing_extensions import Protocol
+
+from .models import (
+    simple_input_models,
+    ToolParameterBundle,
+    ToolParameterT,
+)
+from .state import ToolState
+
+VISITOR_NO_REPLACEMENT = object()
+VISITOR_UNDEFINED = object()
+
+
+class Callback(Protocol):
+    def __call__(self, parameter: ToolParameterT, value: Any):
+        pass
+
+
+def visit_input_values(
+    input_models: ToolParameterBundle,
+    tool_state: ToolState,
+    callback: Callback,
+    no_replacement_value=VISITOR_NO_REPLACEMENT,
+) -> Dict[str, Any]:
+    return _visit_input_values(
+        simple_input_models(input_models.input_models),
+        tool_state.input_state,
+        callback=callback,
+        no_replacement_value=no_replacement_value,
+    )
+
+
+def _visit_input_values(
+    input_models: Iterable[ToolParameterT],
+    input_values: Dict[str, Any],
+    callback: Callback,
+    no_replacement_value=VISITOR_NO_REPLACEMENT,
+) -> Dict[str, Any]:
+    new_input_values = {}
+    for model in input_models:
+        name = model.name
+        input_value = input_values.get(name, VISITOR_UNDEFINED)
+        replacement = callback(model, input_value)
+        if replacement != no_replacement_value:
+            new_input_values[name] = replacement
+        elif replacement is VISITOR_UNDEFINED:
+            pass
+        else:
+            new_input_values[name] = input_value
+    return new_input_values
diff --git a/lib/galaxy/tool_util/parser/cwl.py b/lib/galaxy/tool_util/parser/cwl.py
index 1647c39aa701..45a4634ae82f 100644
--- a/lib/galaxy/tool_util/parser/cwl.py
+++ b/lib/galaxy/tool_util/parser/cwl.py
@@ -179,18 +179,41 @@ def to_string(self):
         return json.dumps(self.tool_proxy.to_persistent_representation())
 
 
+class CwlInputSource(YamlInputSource):
+    def __init__(self, as_dict, as_field):
+        super().__init__(as_dict)
+        self._field = as_field
+
+    @property
+    def field(self):
+        return self._field
+
+
 class CwlPageSource(PageSource):
     def __init__(self, tool_proxy):
         cwl_instances = tool_proxy.input_instances()
-        self._input_list = list(map(self._to_input_source, cwl_instances))
+        input_fields = tool_proxy.input_fields()
+        input_list = []
+        for cwl_instance in cwl_instances:
+            name = cwl_instance.name
+            input_field = None
+            for field in input_fields:
+                if field["name"] == name:
+                    input_field = field
+            input_list.append(CwlInputSource(cwl_instance.to_dict(), input_field))
+
+        self._input_list = input_list
 
     def _to_input_source(self, input_instance):
         as_dict = input_instance.to_dict()
-        return YamlInputSource(as_dict)
+        return CwlInputSource(as_dict)
 
     def parse_input_sources(self):
         return self._input_list
 
+    def input_fields(self):
+        return self._input_fields
+
 
 __all__ = (
     "CwlToolSource",
diff --git a/lib/galaxy/tool_util/parser/interface.py b/lib/galaxy/tool_util/parser/interface.py
index aba4142edb46..7ce8dcde7665 100644
--- a/lib/galaxy/tool_util/parser/interface.py
+++ b/lib/galaxy/tool_util/parser/interface.py
@@ -401,10 +401,10 @@ def parse_optional(self, default=None):
         return self.get_bool("optional", default)
 
     def parse_dynamic_options_elem(self):
-        """Return an XML elemnt describing dynamic options."""
+        """Return an XML element describing dynamic options."""
         return None
 
-    def parse_static_options(self):
+    def parse_static_options(self) -> List[Tuple[str, str, bool]]:
         """Return list of static options if this is a select type without
         defining a dynamic options.
         """
diff --git a/lib/galaxy/tool_util/parser/xml.py b/lib/galaxy/tool_util/parser/xml.py
index 60c6b935a251..685c651c0812 100644
--- a/lib/galaxy/tool_util/parser/xml.py
+++ b/lib/galaxy/tool_util/parser/xml.py
@@ -9,6 +9,7 @@
     Iterable,
     List,
     Optional,
+    Tuple,
 )
 
 from packaging.version import Version
@@ -1205,7 +1206,7 @@ def parse_dynamic_options_elem(self):
         options_elem = self.input_elem.find("options")
         return options_elem
 
-    def parse_static_options(self):
+    def parse_static_options(self) -> List[Tuple[str, str, bool]]:
         """
         >>> from galaxy.util import parse_xml_string_to_etree
         >>> xml = '<param><option value="a">A</option><option value="b">B</option></param>'
diff --git a/lib/galaxy/tool_util/parser/yaml.py b/lib/galaxy/tool_util/parser/yaml.py
index 64c8381b0e37..4f213cd7fdeb 100644
--- a/lib/galaxy/tool_util/parser/yaml.py
+++ b/lib/galaxy/tool_util/parser/yaml.py
@@ -2,6 +2,7 @@
 from typing import (
     Dict,
     List,
+    Tuple,
 )
 
 import packaging.version
@@ -348,7 +349,7 @@ def parse_when_input_sources(self):
             sources.append((value, case_page_source))
         return sources
 
-    def parse_static_options(self):
+    def parse_static_options(self) -> List[Tuple[str, str, bool]]:
         static_options = list()
         input_dict = self.input_dict
         for option in input_dict.get("options", {}):
diff --git a/lib/galaxy/tool_util/unittest_utils/parameters.py b/lib/galaxy/tool_util/unittest_utils/parameters.py
new file mode 100644
index 000000000000..d3be68b7cca2
--- /dev/null
+++ b/lib/galaxy/tool_util/unittest_utils/parameters.py
@@ -0,0 +1,46 @@
+import os
+from typing import List
+
+from galaxy.tool_util.parameters import (
+    from_input_source,
+    ToolParameterBundle,
+    ToolParameterT,
+)
+from galaxy.tool_util.parser.factory import get_tool_source
+from galaxy.util import galaxy_directory
+
+
+class ParameterBundle(ToolParameterBundle):
+    input_models: List[ToolParameterT]
+
+    def __init__(self, parameter: ToolParameterT):
+        self.input_models = [parameter]
+
+
+def parameter_bundle(parameter: ToolParameterT) -> ParameterBundle:
+    return ParameterBundle(parameter)
+
+
+def parameter_bundle_for_file(filename: str) -> ParameterBundle:
+    return parameter_bundle(tool_parameter(filename))
+
+
+def tool_parameter(filename: str) -> ToolParameterT:
+    return from_input_source(parameter_source(filename))
+
+
+def parameter_source(filename: str):
+    tool_source = parameter_tool_source(filename)
+    input_sources = tool_source.parse_input_pages().page_sources[0].parse_input_sources()
+    assert len(input_sources) == 1
+    return input_sources[0]
+
+
+def parameter_tool_source(basename: str):
+    path_prefix = os.path.join(galaxy_directory(), "test/functional/tools/parameters", basename)
+    if os.path.exists(f"{path_prefix}.xml"):
+        path = f"{path_prefix}.xml"
+    else:
+        path = f"{path_prefix}.cwl"
+    tool_source = get_tool_source(path, macro_paths=[])
+    return tool_source
diff --git a/lib/galaxy/tool_util/verify/interactor.py b/lib/galaxy/tool_util/verify/interactor.py
index 0a9f8fdc145e..cc5792331786 100644
--- a/lib/galaxy/tool_util/verify/interactor.py
+++ b/lib/galaxy/tool_util/verify/interactor.py
@@ -37,6 +37,10 @@
 )
 
 from galaxy import util
+from galaxy.tool_util.parameters import (
+    input_models_from_json,
+    ToolParameterBundle,
+)
 from galaxy.tool_util.parser.interface import (
     AssertionList,
     TestCollectionDef,
@@ -226,6 +230,15 @@ def get_tests_summary(self):
         assert response.status_code == 200, f"Non 200 response from tool tests available API. [{response.content}]"
         return response.json()
 
+    def get_tool_inputs(self, tool_id: str, tool_version: Optional[str] = None) -> ToolParameterBundle:
+        url = f"tools/{tool_id}/inputs"
+        params = {"tool_version": tool_version} if tool_version else None
+        response = self._get(url, data=params)
+        assert response.status_code == 200, f"Non 200 response from tool inputs API. [{response.content}]"
+        raw_inputs_array = response.json()
+        tool_parameter_bundle = input_models_from_json(raw_inputs_array)
+        return tool_parameter_bundle
+
     def get_tool_tests_model(self, tool_id: str, tool_version: Optional[str] = None) -> "ToolTestCaseList":
         url = f"tools/{tool_id}/test_data"
         params = {"tool_version": tool_version} if tool_version else None
@@ -392,9 +405,22 @@ def compare(val, expected):
     def wait_for_job(self, job_id, history_id=None, maxseconds=DEFAULT_TOOL_TEST_WAIT):
         self.wait_for(lambda: self.__job_ready(job_id, history_id), maxseconds=maxseconds)
 
+    def wait_on_tool_request(self, tool_request_id: str):
+        def state():
+            state_response = self._get(f"tool_requests/{tool_request_id}/state")
+            state_response.raise_for_status()
+            return state_response.json()
+
+        def is_ready():
+            is_complete = state() in ["submitted", "failed"]
+            return True if is_complete else None
+
+        self.wait_for(is_ready, "waiting for tool request to submit")
+        return state() == "submitted"
+
     def wait_for(self, func, what="tool test run", **kwd):
         walltime_exceeded = int(kwd.get("maxseconds", DEFAULT_TOOL_TEST_WAIT))
-        wait_on(func, what, walltime_exceeded)
+        return wait_on(func, what, walltime_exceeded)
 
     def get_job_stdio(self, job_id):
         job_stdio = self.__get_job_stdio(job_id).json()
@@ -585,8 +611,9 @@ def stage_data_async(
             else:
                 file_content = self.test_data_download(tool_id, fname, is_output=False, tool_version=tool_version)
                 files = {"files_0|file_data": file_content}
+        # upload1 will always be the legacy API...
         submit_response_object = self.__submit_tool(
-            history_id, "upload1", tool_input, extra_data={"type": "upload_dataset"}, files=files
+            history_id, "upload1", tool_input, extra_data={"type": "upload_dataset"}, files=files, use_legacy_api=True
         )
         submit_response = ensure_tool_run_response_okay(submit_response_object, f"upload dataset {name}")
         assert (
@@ -611,38 +638,45 @@ def _ensure_valid_location_in(self, test_data: dict) -> Optional[str]:
             raise ValueError(f"Invalid `location` URL: `{location}`")
         return location
 
-    def run_tool(self, testdef, history_id, resource_parameters=None) -> RunToolResponse:
+    def run_tool(self, testdef, history_id, resource_parameters=None, use_legacy_api=True) -> RunToolResponse:
         # We need to handle the case where we've uploaded a valid compressed file since the upload
         # tool will have uncompressed it on the fly.
         resource_parameters = resource_parameters or {}
-        inputs_tree = testdef.inputs.copy()
-        for key, value in inputs_tree.items():
-            values = [value] if not isinstance(value, list) else value
-            new_values = []
-            for value in values:
-                if isinstance(value, TestCollectionDef):
-                    hdca_id = self._create_collection(history_id, value)
-                    new_values = [dict(src="hdca", id=hdca_id)]
-                elif value in self.uploads:
-                    new_values.append(self.uploads[value])
-                else:
-                    new_values.append(value)
-            inputs_tree[key] = new_values
-
-        if resource_parameters:
-            inputs_tree["__job_resource|__job_resource__select"] = "yes"
-            for key, value in resource_parameters.items():
-                inputs_tree[f"__job_resource|{key}"] = value
-
-        # HACK: Flatten single-value lists. Required when using expand_grouping
-        for key, value in inputs_tree.items():
-            if isinstance(value, list) and len(value) == 1:
-                inputs_tree[key] = value[0]
+        if use_legacy_api:
+            inputs_tree = testdef.inputs.copy()
+            for key, value in inputs_tree.items():
+                values = [value] if not isinstance(value, list) else value
+                new_values = []
+                for value in values:
+                    if isinstance(value, TestCollectionDef):
+                        hdca_id = self._create_collection(history_id, value)
+                        new_values = [dict(src="hdca", id=hdca_id)]
+                    elif value in self.uploads:
+                        new_values.append(self.uploads[value])
+                    else:
+                        new_values.append(value)
+                inputs_tree[key] = new_values
+
+            if resource_parameters:
+                inputs_tree["__job_resource|__job_resource__select"] = "yes"
+                for key, value in resource_parameters.items():
+                    inputs_tree[f"__job_resource|{key}"] = value
+
+            # HACK: Flatten single-value lists. Required when using expand_grouping
+            for key, value in inputs_tree.items():
+                if isinstance(value, list) and len(value) == 1:
+                    inputs_tree[key] = value[0]
+        else:
+            pass
 
         submit_response = None
         for _ in range(DEFAULT_TOOL_TEST_WAIT):
             submit_response = self.__submit_tool(
-                history_id, tool_id=testdef.tool_id, tool_input=inputs_tree, tool_version=testdef.tool_version
+                history_id,
+                tool_id=testdef.tool_id,
+                tool_input=inputs_tree,
+                tool_version=testdef.tool_version,
+                use_legacy_api=use_legacy_api,
             )
             if _are_tool_inputs_not_ready(submit_response):
                 print("Tool inputs not ready yet")
@@ -651,12 +685,30 @@ def run_tool(self, testdef, history_id, resource_parameters=None) -> RunToolResp
             else:
                 break
         submit_response_object = ensure_tool_run_response_okay(submit_response, "execute tool", inputs_tree)
+        if not use_legacy_api:
+            tool_request_id = submit_response_object["tool_request_id"]
+            self.wait_on_tool_request(tool_request_id)
+            jobs = self.jobs_for_tool_request(tool_request_id)
+            outputs = OutputsDict()
+            output_collections = {}
+            assert len(jobs) == 1
+            job_id = jobs[0]["id"]
+            job_outputs = self.job_outputs(job_id)
+            for job_output in job_outputs:
+                if "dataset" in job_output:
+                    outputs[job_output["name"]] = job_output["dataset"]
+                else:
+                    output_collections[job_output["name"]] = job_output["dataset_collection_instance"]
+        else:
+            outputs = self.__dictify_outputs(submit_response_object)
+            output_collections = self.__dictify_output_collections(submit_response_object)
+            jobs = submit_response_object["jobs"]
         try:
             return RunToolResponse(
                 inputs=inputs_tree,
-                outputs=self.__dictify_outputs(submit_response_object),
-                output_collections=self.__dictify_output_collections(submit_response_object),
-                jobs=submit_response_object["jobs"],
+                outputs=outputs,
+                output_collections=output_collections,
+                jobs=jobs,
             )
         except KeyError:
             message = (
@@ -794,14 +846,24 @@ def format_for_summary(self, blob, empty_message, prefix="|  "):
         contents = "\n".join(f"{prefix}{line.strip()}" for line in io.StringIO(blob).readlines() if line.rstrip("\n\r"))
         return contents or f"{prefix}*{empty_message}*"
 
-    def _dataset_provenance(self, history_id, id):
+    def _dataset_provenance(self, history_id: str, id: str):
         provenance = self._get(f"histories/{history_id}/contents/{id}/provenance").json()
         return provenance
 
-    def _dataset_info(self, history_id, id):
+    def _dataset_info(self, history_id: str, id: str):
         dataset_json = self._get(f"histories/{history_id}/contents/{id}").json()
         return dataset_json
 
+    def jobs_for_tool_request(self, tool_request_id: str) -> List[Dict[str, Any]]:
+        job_list_response = self._get("jobs", data={"tool_request_id": tool_request_id})
+        job_list_response.raise_for_status()
+        return job_list_response.json()
+
+    def job_outputs(self, job_id: str) -> List[Dict[str, Any]]:
+        outputs = self._get(f"jobs/{job_id}/outputs")
+        outputs.raise_for_status()
+        return outputs.json()
+
     def __contents(self, history_id):
         history_contents_response = self._get(f"histories/{history_id}/contents")
         history_contents_response.raise_for_status()
@@ -818,12 +880,26 @@ def _state_ready(self, job_id, error_msg):
             )
         return None
 
-    def __submit_tool(self, history_id, tool_id, tool_input, extra_data=None, files=None, tool_version=None):
+    def __submit_tool(
+        self, history_id, tool_id, tool_input, extra_data=None, files=None, tool_version=None, use_legacy_api=True
+    ):
         extra_data = extra_data or {}
-        data = dict(
-            history_id=history_id, tool_id=tool_id, inputs=dumps(tool_input), tool_version=tool_version, **extra_data
-        )
-        return self._post("tools", files=files, data=data)
+        if use_legacy_api:
+            data = dict(
+                history_id=history_id,
+                tool_id=tool_id,
+                inputs=dumps(tool_input),
+                tool_version=tool_version,
+                **extra_data,
+            )
+            return self._post("tools", files=files, data=data)
+        else:
+            assert files is None
+            data = dict(
+                history_id=history_id, tool_id=tool_id, inputs=tool_input, tool_version=tool_version, **extra_data
+            )
+            submit_tool_request_response = self._post("jobs", data=data, json=True)
+            return submit_tool_request_response
 
     def ensure_user_with_email(self, email, password=None):
         admin_key = self.master_api_key
@@ -1328,6 +1404,7 @@ def verify_tool(
     register_job_data: Optional[JobDataCallbackT] = None,
     test_index: int = 0,
     tool_version: Optional[str] = None,
+    use_legacy_api: bool = True,
     quiet: bool = False,
     test_history: Optional[str] = None,
     no_history_cleanup: bool = False,
@@ -1378,6 +1455,9 @@ def verify_tool(
         return
 
     tool_test_dict.setdefault("maxseconds", maxseconds)
+    if not use_legacy_api:
+        structured_inputs = galaxy_interactor.get_tool_inputs(tool_id, tool_version=tool_version)
+        assert structured_inputs
     testdef = ToolTestDescription(cast(ToolTestDict, tool_test_dict))
     _handle_def_errors(testdef)
 
@@ -1413,7 +1493,9 @@ def verify_tool(
             input_staging_exception = e
             raise
         try:
-            tool_response = galaxy_interactor.run_tool(testdef, test_history, resource_parameters=resource_parameters)
+            tool_response = galaxy_interactor.run_tool(
+                testdef, test_history, resource_parameters=resource_parameters, use_legacy_api=use_legacy_api
+            )
             data_list, jobs, tool_inputs = tool_response.outputs, tool_response.jobs, tool_response.inputs
             data_collection_list = tool_response.output_collections
         except RunToolException as e:
diff --git a/lib/galaxy/tools/__init__.py b/lib/galaxy/tools/__init__.py
index 22ee4cb1088c..f85c2cae23b2 100644
--- a/lib/galaxy/tools/__init__.py
+++ b/lib/galaxy/tools/__init__.py
@@ -12,6 +12,7 @@
 from collections.abc import MutableMapping
 from pathlib import Path
 from typing import (
+    Any,
     cast,
     Dict,
     List,
@@ -40,7 +41,9 @@
 )
 from galaxy.job_execution import output_collect
 from galaxy.metadata import get_metadata_compute_strategy
+from galaxy.model import ToolRequest
 from galaxy.model.base import transaction
+from galaxy.model.dataset_collections import matching
 from galaxy.tool_shed.util.repository_util import get_installed_repository
 from galaxy.tool_shed.util.shed_util_common import set_image_paths
 from galaxy.tool_util.deps import (
@@ -60,6 +63,12 @@
     expand_ontology_data,
 )
 from galaxy.tool_util.output_checker import DETECTED_JOB_STATE
+from galaxy.tool_util.parameters import (
+    input_models_for_pages,
+    JobInternalToolState,
+    RequestInternalToolState,
+    ToolParameterBundle,
+)
 from galaxy.tool_util.parser import (
     get_tool_source,
     get_tool_source_from_representation,
@@ -133,7 +142,10 @@
     UploadDataset,
 )
 from galaxy.tools.parameters.input_translation import ToolInputTranslator
-from galaxy.tools.parameters.meta import expand_meta_parameters
+from galaxy.tools.parameters.meta import (
+    expand_meta_parameters,
+    expand_meta_parameters_2,
+)
 from galaxy.tools.parameters.wrapped_json import json_wrap
 from galaxy.tools.test import parse_tests
 from galaxy.util import (
@@ -169,7 +181,9 @@
 from galaxy.work.context import proxy_work_context_for_history
 from .execute import (
     execute as execute_job,
+    execute_2,
     MappingParameters,
+    MappingParameters2,
 )
 
 if TYPE_CHECKING:
@@ -705,7 +719,7 @@ class _Options(Bunch):
     refresh: str
 
 
-class Tool(Dictifiable):
+class Tool(Dictifiable, ToolParameterBundle):
     """
     Represents a computational tool that can be executed through Galaxy.
     """
@@ -1384,6 +1398,11 @@ def parse_inputs(self, tool_source: ToolSource):
         self.inputs: Dict[str, Union[Group, ToolParameter]] = {}
         pages = tool_source.parse_input_pages()
         enctypes: Set[str] = set()
+        try:
+            input_models = input_models_for_pages(pages)
+            self.input_models = input_models
+        except Exception:
+            pass
         if pages.inputs_defined:
             if hasattr(pages, "input_elem"):
                 input_elem = pages.input_elem
@@ -1778,6 +1797,50 @@ def visit_inputs(self, values, callback):
         if self.check_values:
             visit_input_values(self.inputs, values, callback)
 
+    def expand_incoming_2(self, trans, tool_request_internal_state: RequestInternalToolState, request_context):
+        if self.input_translator:
+            raise exceptions.RequestParameterInvalidException(
+                "Failure executing tool request with id '%s' (cannot validate inputs from this type of data source tool - please POST to /api/tools).",
+                self.id,
+            )
+
+        expanded_incomings: List[JobInternalToolState]
+        collection_info: Optional[matching.MatchingCollections]
+        expanded_incomings, collection_info = expand_meta_parameters_2(trans.app, self, tool_request_internal_state)
+
+        # Process incoming data
+        validation_timer = self.app.execution_timer_factory.get_timer(
+            "internals.galaxy.tools.validation",
+            "Validated and populated state for tool request",
+        )
+        all_errors = []
+        for expanded_incoming in expanded_incomings:
+            errors: Dict[str, str] = {}
+            if self.check_values:
+                # expand_incoming would use the params here... here we're
+                # only using populate_state to validate - so ignoring params
+                # after we're done.
+
+                params: Dict[str, Any] = {}
+                # values from `incoming`.
+                populate_state(
+                    request_context,
+                    self.inputs,
+                    expanded_incoming.input_state,
+                    params,
+                    errors,
+                    simple_errors=False,
+                    input_format="legacy",
+                )
+                # If the tool provides a `validate_input` hook, call it.
+                validate_input = self.get_hook("validate_input")
+                if validate_input:
+                    validate_input(request_context, errors, params, self.inputs)
+            all_errors.append(errors)
+
+        log.info(validation_timer)
+        return expanded_incomings, all_errors, collection_info
+
     def expand_incoming(self, trans, incoming, request_context, input_format="legacy"):
         rerun_remap_job_id = None
         if "rerun_remap_job_id" in incoming:
@@ -1853,6 +1916,33 @@ def expand_incoming(self, trans, incoming, request_context, input_format="legacy
         log.info(validation_timer)
         return all_params, all_errors, rerun_remap_job_id, collection_info
 
+    def handle_input_2(self, trans, tool_request: ToolRequest, history=None, use_cached_job=False):
+        # TODO: original 1 added preferred object store on rebase, need to add it here.
+        request_context = proxy_work_context_for_history(trans, history=history)
+        tool_request_state = RequestInternalToolState(tool_request.request)
+        all_params, all_errors, collection_info = self.expand_incoming_2(trans, tool_request_state, request_context)
+        # If there were errors, we stay on the same page and display them
+        self.handle_incoming_errors(all_errors)
+
+        rerun_remap_job_id = None  # TODO:
+        mapping_params = MappingParameters2(tool_request_state, all_params)
+        completed_jobs: Dict[int, Optional[model.Job]] = {}
+        for i, param in enumerate(all_params):
+            print(f"Do something with {param}")
+            # TODO: use cached jobs here...
+            completed_jobs[i] = None
+
+            execute_2(
+                request_context,
+                self,
+                mapping_params,
+                history=history,
+                tool_request=tool_request,
+                rerun_remap_job_id=rerun_remap_job_id,
+                collection_info=collection_info,
+                completed_jobs=completed_jobs,
+            )
+
     def handle_input(
         self,
         trans,
@@ -2049,6 +2139,8 @@ def execute(self, trans, incoming=None, set_output_hid=True, history=None, **kwa
         if incoming is None:
             incoming = {}
         try:
+            if isinstance(incoming, JobInternalToolState):
+                incoming = incoming.input_state
             return self.tool_action.execute(
                 self, trans, incoming=incoming, set_output_hid=set_output_hid, history=history, **kwargs
             )
diff --git a/lib/galaxy/tools/execute.py b/lib/galaxy/tools/execute.py
index c935aff13ecc..523ce39d2225 100644
--- a/lib/galaxy/tools/execute.py
+++ b/lib/galaxy/tools/execute.py
@@ -14,18 +14,24 @@
     List,
     NamedTuple,
     Optional,
+    Union,
 )
 
 from boltons.iterutils import remap
 
 from galaxy import model
 from galaxy.exceptions import ToolInputsNotOKException
+from galaxy.model import ToolRequest
 from galaxy.model.base import transaction
 from galaxy.model.dataset_collections.matching import MatchingCollections
 from galaxy.model.dataset_collections.structure import (
     get_structure,
     tool_output_to_structure,
 )
+from galaxy.tool_util.parameters.state import (
+    JobInternalToolState,
+    RequestInternalToolState,
+)
 from galaxy.tool_util.parser import ToolOutputCollectionPart
 from galaxy.tools.actions import (
     filter_output,
@@ -53,6 +59,45 @@ class MappingParameters(NamedTuple):
     param_combinations: List[Dict[str, Any]]
 
 
+class MappingParameters2(NamedTuple):
+    param_template: RequestInternalToolState
+    param_combinations: List[JobInternalToolState]
+
+
+def execute_2(
+    trans,
+    tool: "Tool",
+    mapping_params: MappingParameters2,
+    history: model.History,
+    tool_request: ToolRequest,
+    completed_jobs: Dict[int, Optional[model.Job]],
+    rerun_remap_job_id: Optional[int] = None,
+    collection_info: Optional[MatchingCollections] = None,
+    workflow_invocation_uuid: Optional[str] = None,
+    invocation_step: Optional[model.WorkflowInvocationStep] = None,
+    max_num_jobs: Optional[int] = None,
+    job_callback: Optional[Callable] = None,
+    workflow_resource_parameters: Optional[Dict[str, Any]] = None,
+    validate_outputs: bool = False,
+) -> "ExecutionTracker":
+    return _execute(
+        trans,
+        tool,
+        mapping_params,
+        history,
+        tool_request,
+        rerun_remap_job_id,
+        collection_info,
+        workflow_invocation_uuid,
+        invocation_step,
+        max_num_jobs,
+        job_callback,
+        completed_jobs,
+        workflow_resource_parameters,
+        validate_outputs,
+    )
+
+
 def execute(
     trans,
     tool: "Tool",
@@ -68,12 +113,46 @@ def execute(
     completed_jobs: Optional[Dict[int, Optional[model.Job]]] = None,
     workflow_resource_parameters: Optional[Dict[str, Any]] = None,
     validate_outputs: bool = False,
-):
+) -> "ExecutionTracker":
     """
     Execute a tool and return object containing summary (output data, number of
     failures, etc...).
     """
     completed_jobs = completed_jobs or {}
+    return _execute(
+        trans,
+        tool,
+        mapping_params,
+        history,
+        None,
+        rerun_remap_job_id,
+        collection_info,
+        workflow_invocation_uuid,
+        invocation_step,
+        max_num_jobs,
+        job_callback,
+        completed_jobs,
+        workflow_resource_parameters,
+        validate_outputs,
+    )
+
+
+def _execute(
+    trans,
+    tool: "Tool",
+    mapping_params: Union[MappingParameters, MappingParameters2],
+    history: model.History,
+    tool_request: Optional[model.ToolRequest],
+    rerun_remap_job_id: Optional[int],
+    collection_info: Optional[MatchingCollections],
+    workflow_invocation_uuid: Optional[str],
+    invocation_step: Optional[model.WorkflowInvocationStep],
+    max_num_jobs: Optional[int],
+    job_callback: Optional[Callable],
+    completed_jobs: Dict[int, Optional[model.Job]],
+    workflow_resource_parameters: Optional[Dict[str, Any]],
+    validate_outputs: bool,
+) -> "ExecutionTracker":
     if max_num_jobs is not None:
         assert invocation_step is not None
     if rerun_remap_job_id:
@@ -98,8 +177,14 @@ def execute_single_job(execution_slice, completed_job, skip=False):
             "internals.galaxy.tools.execute.job_single", SINGLE_EXECUTION_SUCCESS_MESSAGE
         )
         params = execution_slice.param_combination
-        if "__data_manager_mode" in mapping_params.param_template:
-            params["__data_manager_mode"] = mapping_params.param_template["__data_manager_mode"]
+        if isinstance(params, JobInternalToolState):
+            params = params.input_state
+        assert isinstance(params, dict)
+        request_state = mapping_params.param_template
+        if isinstance(request_state, RequestInternalToolState):
+            request_state = request_state.input_state
+        if "__data_manager_mode" in request_state:
+            params["__data_manager_mode"] = request_state["__data_manager_mode"]
         if workflow_invocation_uuid:
             params["__workflow_invocation_uuid__"] = workflow_invocation_uuid
         elif "__workflow_invocation_uuid__" in params:
@@ -128,6 +213,8 @@ def execute_single_job(execution_slice, completed_job, skip=False):
             skip=skip,
         )
         if job:
+            if tool_request:
+                job.tool_request = tool_request
             log.debug(job_timer.to_str(tool_id=tool.id, job_id=job.id))
             execution_tracker.record_success(execution_slice, job, result)
             # associate dataset instances with the job that creates them
@@ -224,6 +311,8 @@ def execute_single_job(execution_slice, completed_job, skip=False):
 
 
 class ExecutionSlice:
+    job_index: int
+
     def __init__(self, job_index, param_combination, dataset_collection_elements=None):
         self.job_index = job_index
         self.param_combination = param_combination
diff --git a/lib/galaxy/tools/parameters/basic.py b/lib/galaxy/tools/parameters/basic.py
index eda07c0503fd..e600e96ee3b3 100644
--- a/lib/galaxy/tools/parameters/basic.py
+++ b/lib/galaxy/tools/parameters/basic.py
@@ -31,6 +31,7 @@
     LibraryDatasetDatasetAssociation,
 )
 from galaxy.schema.fetch_data import FilesPayload
+from galaxy.tool_util.parameters.factory import get_color_value
 from galaxy.tool_util.parser import get_input_source as ensure_input_source
 from galaxy.util import (
     dbkeys,
@@ -637,6 +638,7 @@ def legal_values(self):
         return [self.truevalue, self.falsevalue]
 
 
+# Used only by upload1, deprecated.
 class FileToolParameter(ToolParameter):
     """
     Parameter that takes an uploaded file as a value.
@@ -832,7 +834,7 @@ class ColorToolParameter(ToolParameter):
     def __init__(self, tool, input_source):
         input_source = ensure_input_source(input_source)
         super().__init__(tool, input_source)
-        self.value = input_source.get("value", "#000000")
+        self.value = get_color_value(input_source)
         self.rgb = input_source.get_bool("rgb", False)
 
     def get_initial_value(self, trans, other_values):
diff --git a/lib/galaxy/tools/parameters/meta.py b/lib/galaxy/tools/parameters/meta.py
index a9f47ac0eae0..403aa214dad8 100644
--- a/lib/galaxy/tools/parameters/meta.py
+++ b/lib/galaxy/tools/parameters/meta.py
@@ -19,6 +19,11 @@
     matching,
     subcollections,
 )
+from galaxy.tool_util.parameters import (
+    JobInternalToolState,
+    RequestInternalToolState,
+    ToolParameterBundle,
+)
 from galaxy.util import permutations
 from . import visit_input_values
 
@@ -249,6 +254,48 @@ def classifier(input_key):
     return expanded_incomings, collection_info
 
 
+Expanded2T = Tuple[List[JobInternalToolState], Optional[matching.MatchingCollections]]
+
+
+def expand_meta_parameters_2(app, tool: ToolParameterBundle, incoming: RequestInternalToolState) -> Expanded2T:
+    # TODO: Tool State 2.0 Follow Up: rework this to only test permutation at actual input value roots.
+
+    def classifier(input_key):
+        value = incoming.input_state[input_key]
+        if isinstance(value, dict) and "values" in value:
+            # Explicit meta wrapper for inputs...
+            is_batch = value.get("__class__", "Batch")
+            is_linked = value.get("linked", True)
+            if is_batch and is_linked:
+                classification = permutations.input_classification.MATCHED
+            elif is_batch:
+                classification = permutations.input_classification.MULTIPLIED
+            else:
+                classification = permutations.input_classification.SINGLE
+            if __collection_multirun_parameter(value):
+                collection_value = value["values"][0]
+                values = __expand_collection_parameter_2(
+                    app, input_key, collection_value, collections_to_match, linked=is_linked
+                )
+            else:
+                values = value["values"]
+        else:
+            classification = permutations.input_classification.SINGLE
+            values = value
+        return classification, values
+
+    collections_to_match = matching.CollectionsToMatch()
+    expanded_incoming_dicts = permutations.expand_multi_inputs(incoming.input_state, classifier)
+    if collections_to_match.has_collections():
+        collection_info = app.dataset_collection_manager.match_collections(collections_to_match)
+    else:
+        collection_info = None
+    expanded_incomings = [JobInternalToolState(d) for d in expanded_incoming_dicts]
+    for expanded_state in expanded_incomings:
+        expanded_state.validate(tool)
+    return expanded_incomings, collection_info
+
+
 def __expand_collection_parameter(trans, input_key, incoming_val, collections_to_match, linked=False):
     # If subcollectin multirun of data_collection param - value will
     # be "hdca_id|subcollection_type" else it will just be hdca_id
@@ -279,8 +326,34 @@ def __expand_collection_parameter(trans, input_key, incoming_val, collections_to
         return hdas
 
 
+def __expand_collection_parameter_2(app, input_key, incoming_val, collections_to_match, linked=False):
+    # If subcollectin multirun of data_collection param - value will
+    # be "hdca_id|subcollection_type" else it will just be hdca_id
+    try:
+        src = incoming_val["src"]
+        if src != "hdca":
+            raise exceptions.ToolMetaParameterException(f"Invalid dataset collection source type {src}")
+        hdc_id = incoming_val["id"]
+        subcollection_type = incoming_val.get("map_over_type", None)
+    except TypeError:
+        hdc_id = incoming_val
+        subcollection_type = None
+    hdc = app.model.context.query(model.HistoryDatasetCollectionAssociation).get(hdc_id)
+    collections_to_match.add(input_key, hdc, subcollection_type=subcollection_type, linked=linked)
+    if subcollection_type is not None:
+        subcollection_elements = subcollections.split_dataset_collection_instance(hdc, subcollection_type)
+        return subcollection_elements
+    else:
+        hdas = []
+        for element in hdc.collection.dataset_elements:
+            hda = element.dataset_instance
+            hda.element_identifier = element.element_identifier
+            hdas.append(hda)
+        return hdas
+
+
 def __collection_multirun_parameter(value):
-    is_batch = value.get("batch", False)
+    is_batch = value.get("batch", False) or value.get("__class__", None) == "Batch"
     if not is_batch:
         return False
 
diff --git a/lib/galaxy/webapps/galaxy/api/histories.py b/lib/galaxy/webapps/galaxy/api/histories.py
index edeb029c4622..89bc931a19f8 100644
--- a/lib/galaxy/webapps/galaxy/api/histories.py
+++ b/lib/galaxy/webapps/galaxy/api/histories.py
@@ -51,6 +51,7 @@
     ShareWithStatus,
     SharingStatus,
     StoreExportPayload,
+    ToolRequestModel,
     WriteStoreToPayload,
 )
 from galaxy.schema.types import LatestLiteral
@@ -270,6 +271,17 @@ def citations(
     ) -> List[Any]:
         return self.service.citations(trans, history_id)
 
+    @router.get(
+        "/api/histories/{id}/tool_requests",
+        summary="Return all the tool requests for the tools submitted to this history.",
+    )
+    def tool_requests(
+        self,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+        id: DecodedDatabaseIdField = HistoryIDPathParam,
+    ) -> List[ToolRequestModel]:
+        return self.service.tool_requests(trans, id)
+
     @router.post(
         "/api/histories",
         summary="Creates a new history.",
diff --git a/lib/galaxy/webapps/galaxy/api/jobs.py b/lib/galaxy/webapps/galaxy/api/jobs.py
index 72a565b05ccd..50d172766af9 100644
--- a/lib/galaxy/webapps/galaxy/api/jobs.py
+++ b/lib/galaxy/webapps/galaxy/api/jobs.py
@@ -18,6 +18,7 @@
 )
 
 from fastapi import (
+    Body,
     Depends,
     Query,
 )
@@ -58,11 +59,14 @@
 )
 from galaxy.webapps.galaxy.api.common import query_parameter_as_list
 from galaxy.webapps.galaxy.services.jobs import (
+    JobCreateResponse,
     JobIndexPayload,
     JobIndexViewEnum,
+    JobRequest,
     JobsService,
 )
 from galaxy.work.context import WorkRequestContext
+from .tools import validate_not_protected
 
 log = logging.getLogger(__name__)
 
@@ -140,6 +144,12 @@
     description="Limit listing of jobs to those that match the specified workflow invocation ID. If none, jobs from any workflow invocation (or from no workflows) may be returned.",
 )
 
+ToolRequestIdQueryParam: Optional[DecodedDatabaseIdField] = Query(
+    default=None,
+    title="Tool Request ID",
+    description="Limit listing of jobs to those that were created from the supplied tool request ID. If none, jobs from any tool request (or from no workflows) may be returned.",
+)
+
 SortByQueryParam: JobIndexSortByEnum = Query(
     default=JobIndexSortByEnum.update_time,
     title="Sort By",
@@ -172,6 +182,13 @@
 class FastAPIJobs:
     service: JobsService = depends(JobsService)
 
+    @router.post("/api/jobs")
+    def create(
+        self, trans: ProvidesHistoryContext = DependsOnTrans, job_request: JobRequest = Body(...)
+    ) -> JobCreateResponse:
+        validate_not_protected(job_request.tool_id)
+        return self.service.create(trans, job_request)
+
     @router.get("/api/jobs/{id}")
     def show(
         self,
@@ -203,6 +220,7 @@ def index(
         history_id: Optional[DecodedDatabaseIdField] = HistoryIdQueryParam,
         workflow_id: Optional[DecodedDatabaseIdField] = WorkflowIdQueryParam,
         invocation_id: Optional[DecodedDatabaseIdField] = InvocationIdQueryParam,
+        tool_request_id: Optional[DecodedDatabaseIdField] = ToolRequestIdQueryParam,
         order_by: JobIndexSortByEnum = SortByQueryParam,
         search: Optional[str] = SearchQueryParam,
         limit: int = LimitQueryParam,
@@ -220,6 +238,7 @@ def index(
             history_id=history_id,
             workflow_id=workflow_id,
             invocation_id=invocation_id,
+            tool_request_id=tool_request_id,
             order_by=order_by,
             search=search,
             limit=limit,
@@ -289,7 +308,24 @@ def outputs(self, trans: ProvidesUserContext, id, **kwd) -> List[dict]:
         :returns:   list of dictionaries containing output dataset associations
         """
         job = self.__get_job(trans, id)
-        return self.__dictify_associations(trans, job.output_datasets, job.output_library_datasets)
+        rval = self.__dictify_associations(
+            trans,
+            job.output_datasets,
+            job.output_library_datasets,
+        )
+        for job_output_collection_association in job.output_dataset_collection_instances:
+            rval.append(
+                {
+                    "name": job_output_collection_association.name,
+                    "dataset_collection_instance": {
+                        "src": "hdca",
+                        "id": trans.security.encode_id(
+                            job_output_collection_association.dataset_collection_instance.id
+                        ),
+                    },
+                }
+            )
+        return rval
 
     @expose_api
     def delete(self, trans: ProvidesUserContext, id, **kwd):
@@ -451,11 +487,6 @@ def __get_job(self, trans, job_id=None, dataset_id=None, **kwd):
             dataset_instance = self.get_hda_or_ldda(trans, hda_ldda=hda_ldda, dataset_id=dataset_id)
             return dataset_instance.creating_job
 
-    @expose_api
-    def create(self, trans: ProvidesUserContext, payload, **kwd):
-        """See the create method in tools.py in order to submit a job."""
-        raise exceptions.NotImplemented("Please POST to /api/tools instead.")
-
     @expose_api
     def search(self, trans: ProvidesHistoryContext, payload: dict, **kwd):
         """
diff --git a/lib/galaxy/webapps/galaxy/api/tools.py b/lib/galaxy/webapps/galaxy/api/tools.py
index 072d64714f23..adef21a2ff51 100644
--- a/lib/galaxy/webapps/galaxy/api/tools.py
+++ b/lib/galaxy/webapps/galaxy/api/tools.py
@@ -12,6 +12,8 @@
 from fastapi import (
     Body,
     Depends,
+    Path,
+    Query,
     Request,
     UploadFile,
 )
@@ -27,10 +29,13 @@
 from galaxy.managers.context import ProvidesHistoryContext
 from galaxy.managers.hdas import HDAManager
 from galaxy.managers.histories import HistoryManager
+from galaxy.model import ToolRequest
 from galaxy.schema.fetch_data import (
     FetchDataFormPayload,
     FetchDataPayload,
 )
+from galaxy.schema.fields import DecodedDatabaseIdField
+from galaxy.tool_util.parameters import ToolParameterT
 from galaxy.tool_util.verify.interactor import (
     ToolTestCase,
     ToolTestCaseList,
@@ -46,7 +51,10 @@
 )
 from galaxy.webapps.base.controller import UsesVisualizationMixin
 from galaxy.webapps.base.webapp import GalaxyWebTransaction
-from galaxy.webapps.galaxy.services.tools import ToolsService
+from galaxy.webapps.galaxy.services.tools import (
+    ToolRunReference,
+    ToolsService,
+)
 from . import (
     APIContentTypeRoute,
     as_form,
@@ -78,6 +86,14 @@ class JsonApiRoute(APIContentTypeRoute):
 FetchDataForm = as_form(FetchDataFormPayload)
 
 
+ToolIDPathParam: str = Path(
+    ...,
+    title="Tool ID",
+    description="The tool ID for the lineage stored in Galaxy's toolbox.",
+)
+ToolVersionQueryParam: Optional[str] = Query(default=None, title="Tool Version", description="")
+
+
 @router.cbv
 class FetchTools:
     service: ToolsService = depends(ToolsService)
@@ -108,6 +124,30 @@ async def fetch_form(
                     files2.append(value)
         return self.service.create_fetch(trans, payload, files2)
 
+    @router.get(
+        "/api/tool_requests/{id}/state",
+        summary="Get tool request state.",
+    )
+    def tool_request_state(
+        self,
+        id: DecodedDatabaseIdField,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> str:
+        return trans.app.model.context.query(ToolRequest).get(id).state
+
+    @router.get(
+        "/api/tools/{tool_id}/inputs",
+        summary="Get tool inputs.",
+    )
+    def tool_inputs(
+        self,
+        tool_id: str = ToolIDPathParam,
+        tool_version: Optional[str] = ToolVersionQueryParam,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> List[ToolParameterT]:
+        tool_run_ref = ToolRunReference(tool_id=tool_id, tool_version=tool_version, tool_uuid=None)
+        return self.service.inputs(trans, tool_run_ref)
+
 
 class ToolsController(BaseGalaxyAPIController, UsesVisualizationMixin):
     """
@@ -559,16 +599,17 @@ def create(self, trans: GalaxyWebTransaction, payload, **kwd):
         :type input_format: str
         """
         tool_id = payload.get("tool_id")
-        tool_uuid = payload.get("tool_uuid")
-        if tool_id in PROTECTED_TOOLS:
-            raise exceptions.RequestParameterInvalidException(
-                f"Cannot execute tool [{tool_id}] directly, must use alternative endpoint."
-            )
-        if tool_id is None and tool_uuid is None:
-            raise exceptions.RequestParameterInvalidException("Must specify a valid tool_id to use this endpoint.")
+        validate_not_protected(tool_id)
         return self.service._create(trans, payload, **kwd)
 
 
+def validate_not_protected(tool_id: Optional[str]):
+    if tool_id in PROTECTED_TOOLS:
+        raise exceptions.RequestParameterInvalidException(
+            f"Cannot execute tool [{tool_id}] directly, must use alternative endpoint."
+        )
+
+
 def _kwd_or_payload(kwd: Dict[str, Any]) -> Dict[str, Any]:
     if "payload" in kwd:
         kwd = cast(Dict[str, Any], kwd.get("payload"))
diff --git a/lib/galaxy/webapps/galaxy/services/histories.py b/lib/galaxy/webapps/galaxy/services/histories.py
index e15301a0bf40..56439c05a544 100644
--- a/lib/galaxy/webapps/galaxy/services/histories.py
+++ b/lib/galaxy/webapps/galaxy/services/histories.py
@@ -40,6 +40,7 @@
 )
 from galaxy.managers.notification import NotificationManager
 from galaxy.managers.users import UserManager
+from galaxy.model import ToolRequest
 from galaxy.model.base import transaction
 from galaxy.model.store import payload_to_source_uri
 from galaxy.schema import (
@@ -64,6 +65,7 @@
     JobImportHistoryResponse,
     LabelValuePair,
     StoreExportPayload,
+    ToolRequestModel,
     WriteStoreToPayload,
 )
 from galaxy.schema.tasks import (
@@ -502,6 +504,23 @@ def published(
         ]
         return rval
 
+    def tool_requests(
+        self, trans: ProvidesHistoryContext, history_id: DecodedDatabaseIdField
+    ) -> List[ToolRequestModel]:
+        history = self.manager.get_accessible(history_id, trans.user, current_history=trans.history)
+        tool_requests = history.tool_requests
+
+        def to_model(tool_request: ToolRequest) -> ToolRequestModel:
+            as_dict = {
+                "id": DecodedDatabaseIdField.encode(tool_request.id),
+                "request": tool_request.request,
+                "state": tool_request.state,
+                "state_message": tool_request.state_message,
+            }
+            return ToolRequestModel.construct(**as_dict)
+
+        return [to_model(tr) for tr in tool_requests]
+
     def citations(self, trans: ProvidesHistoryContext, history_id: DecodedDatabaseIdField):
         """
         Return all the citations for the tools used to produce the datasets in
diff --git a/lib/galaxy/webapps/galaxy/services/jobs.py b/lib/galaxy/webapps/galaxy/services/jobs.py
index 98ac5bbb8f9e..db96f6fd85ec 100644
--- a/lib/galaxy/webapps/galaxy/services/jobs.py
+++ b/lib/galaxy/webapps/galaxy/services/jobs.py
@@ -1,22 +1,72 @@
+import logging
 from enum import Enum
 from typing import (
     Any,
     Dict,
+    Optional,
+)
+
+from pydantic import (
+    BaseModel,
+    Field,
 )
 
 from galaxy import (
     exceptions,
     model,
 )
+from galaxy.celery.tasks import queue_jobs
 from galaxy.managers import hdas
-from galaxy.managers.context import ProvidesUserContext
+from galaxy.managers.context import (
+    ProvidesHistoryContext,
+    ProvidesUserContext,
+)
+from galaxy.managers.histories import HistoryManager
 from galaxy.managers.jobs import (
     JobManager,
     JobSearch,
     view_show_job,
 )
-from galaxy.schema.fields import DecodedDatabaseIdField
-from galaxy.schema.schema import JobIndexQueryPayload
+from galaxy.model import ToolRequest
+from galaxy.schema.fields import (
+    DecodedDatabaseIdField,
+    EncodedDatabaseIdField,
+)
+from galaxy.schema.schema import (
+    AsyncTaskResultSummary,
+    JobIndexQueryPayload,
+)
+from galaxy.schema.tasks import (
+    QueueJobs,
+    ToolSource,
+)
+from galaxy.tool_util.parameters import (
+    decode,
+    RequestToolState,
+)
+from galaxy.webapps.galaxy.services.base import async_task_summary
+from .tools import (
+    ToolRunReference,
+    validate_tool_for_running,
+)
+
+log = logging.getLogger(__name__)
+
+
+class JobRequest(BaseModel):
+    tool_id: Optional[str] = Field(title="tool_id", description="TODO")
+    tool_uuid: Optional[str] = Field(title="tool_uuid", description="TODO")
+    tool_version: Optional[str] = Field(title="tool_version", description="TODO")
+    history_id: Optional[DecodedDatabaseIdField] = Field("history_id", description="TODO")
+    inputs: Optional[Dict[str, Any]] = Field(default_factory=lambda: {}, title="Inputs", description="TODO")
+    use_cached_jobs: Optional[bool] = Field(default=None, title="use_cached_jobs")
+    rerun_remap_job_id: Optional[DecodedDatabaseIdField] = Field("rerun_remap_job_id", description="TODO")
+    send_email_notification: bool = Field(default=False, title="Send Email Notification", description="TODO")
+
+
+class JobCreateResponse(BaseModel):
+    tool_request_id: EncodedDatabaseIdField
+    task_result: AsyncTaskResultSummary
 
 
 class JobIndexViewEnum(str, Enum):
@@ -32,16 +82,19 @@ class JobsService:
     job_manager: JobManager
     job_search: JobSearch
     hda_manager: hdas.HDAManager
+    history_manager: HistoryManager
 
     def __init__(
         self,
         job_manager: JobManager,
         job_search: JobSearch,
         hda_manager: hdas.HDAManager,
+        history_manager: HistoryManager,
     ):
         self.job_manager = job_manager
         self.job_search = job_search
         self.hda_manager = hda_manager
+        self.history_manager = history_manager
 
     def show(
         self,
@@ -77,3 +130,41 @@ def index(
             out.append(j)
 
         return out
+
+    def create(self, trans: ProvidesHistoryContext, job_request: JobRequest) -> JobCreateResponse:
+        tool_run_reference = ToolRunReference(job_request.tool_id, job_request.tool_uuid, job_request.tool_version)
+        tool = validate_tool_for_running(trans, tool_run_reference)
+        history_id = job_request.history_id
+        target_history = None
+        if history_id is not None:
+            target_history = self.history_manager.get_owned(history_id, trans.user, current_history=trans.history)
+        inputs = job_request.inputs
+        request_state = RequestToolState(inputs or {})
+        request_state.validate(tool)
+        request_internal_state = decode(request_state, tool, trans.security.decode_id)
+        tool_request = ToolRequest()
+        # TODO: hash and such...
+        tool_request.request = request_internal_state.input_state
+        tool_request.state = ToolRequest.states.NEW
+        tool_request.history = target_history
+        trans.sa_session.add(tool_request)
+        trans.sa_session.flush()
+        tool_request_id = tool_request.id
+        tool_source = ToolSource(
+            raw_tool_source=tool.tool_source.to_string(),
+            tool_dir=tool.tool_dir,
+        )
+        task_request = QueueJobs(
+            user=trans.async_request_user,
+            history_id=target_history and target_history.id,
+            tool_source=tool_source,
+            use_cached_jobs=job_request.use_cached_jobs or False,
+            tool_request_id=tool_request_id,
+        )
+        result = queue_jobs.delay(request=task_request)
+        return JobCreateResponse(
+            **{
+                "tool_request_id": DecodedDatabaseIdField.encode(tool_request_id),
+                "task_result": async_task_summary(result),
+            }
+        )
diff --git a/lib/galaxy/webapps/galaxy/services/tools.py b/lib/galaxy/webapps/galaxy/services/tools.py
index cb5b229b4409..c3dce7cca9ce 100644
--- a/lib/galaxy/webapps/galaxy/services/tools.py
+++ b/lib/galaxy/webapps/galaxy/services/tools.py
@@ -6,6 +6,7 @@
     Any,
     Dict,
     List,
+    NamedTuple,
     Optional,
     Union,
 )
@@ -31,6 +32,7 @@
     FilesPayload,
 )
 from galaxy.security.idencoding import IdEncodingHelper
+from galaxy.tool_util.parameters import ToolParameterT
 from galaxy.tools import Tool
 from galaxy.tools.search import ToolBoxSearch
 from galaxy.webapps.galaxy.services._fetch_util import validate_and_normalize_targets
@@ -39,6 +41,39 @@
 log = logging.getLogger(__name__)
 
 
+class ToolRunReference(NamedTuple):
+    tool_id: Optional[str]
+    tool_uuid: Optional[str]
+    tool_version: Optional[str]
+
+
+def get_tool(trans: ProvidesHistoryContext, tool_ref: ToolRunReference) -> Tool:
+    get_kwds = dict(
+        tool_id=tool_ref.tool_id,
+        tool_uuid=tool_ref.tool_uuid,
+        tool_version=tool_ref.tool_version,
+    )
+
+    tool = trans.app.toolbox.get_tool(**get_kwds)
+    if not tool:
+        log.debug(f"Not found tool with kwds [{tool_ref}]")
+        raise exceptions.ToolMissingException("Tool not found.")
+    return tool
+
+
+def validate_tool_for_running(trans: ProvidesHistoryContext, tool_ref: ToolRunReference) -> Tool:
+    if trans.user_is_bootstrap_admin:
+        raise exceptions.RealUserRequiredException("Only real users can execute tools or run jobs.")
+
+    if tool_ref.tool_id is None and tool_ref.tool_uuid is None:
+        raise exceptions.RequestParameterMissingException("Must specify a valid tool_id to use this endpoint.")
+
+    tool = get_tool(trans, tool_ref)
+    if not tool.allow_user_access(trans.user):
+        raise exceptions.ItemAccessibilityException("Tool not accessible.")
+    return tool
+
+
 class ToolsService(ServiceBase):
     def __init__(
         self,
@@ -52,6 +87,14 @@ def __init__(
         self.toolbox_search = toolbox_search
         self.history_manager = history_manager
 
+    def inputs(
+        self,
+        trans: ProvidesHistoryContext,
+        tool_ref: ToolRunReference,
+    ) -> List[ToolParameterT]:
+        tool = get_tool(trans, tool_ref)
+        return tool.input_models
+
     def create_fetch(
         self,
         trans: ProvidesHistoryContext,
@@ -96,37 +139,14 @@ def create_fetch(
         return self._create(trans, create_payload)
 
     def _create(self, trans: ProvidesHistoryContext, payload, **kwd):
-        if trans.user_is_bootstrap_admin:
-            raise exceptions.RealUserRequiredException("Only real users can execute tools or run jobs.")
         action = payload.get("action")
         if action == "rerun":
             raise Exception("'rerun' action has been deprecated")
 
-        # Get tool.
-        tool_version = payload.get("tool_version")
-        tool_id = payload.get("tool_id")
-        tool_uuid = payload.get("tool_uuid")
-        get_kwds = dict(
-            tool_id=tool_id,
-            tool_uuid=tool_uuid,
-            tool_version=tool_version,
+        tool_run_reference = ToolRunReference(
+            payload.get("tool_id"), payload.get("tool_uuid"), payload.get("tool_version")
         )
-        if tool_id is None and tool_uuid is None:
-            raise exceptions.RequestParameterMissingException("Must specify either a tool_id or a tool_uuid.")
-
-        tool = trans.app.toolbox.get_tool(**get_kwds)
-        if not tool:
-            log.debug(f"Not found tool with kwds [{get_kwds}]")
-            raise exceptions.ToolMissingException("Tool not found.")
-        if not tool.allow_user_access(trans.user):
-            raise exceptions.ItemAccessibilityException("Tool not accessible.")
-        if self.config.user_activation_on:
-            if not trans.user:
-                log.warning("Anonymous user attempts to execute tool, but account activation is turned on.")
-            elif not trans.user.active:
-                log.warning(
-                    f'User "{trans.user.email}" attempts to execute tool, but account activation is turned on and user account is not active.'
-                )
+        tool = validate_tool_for_running(trans, tool_run_reference)
 
         # Set running history from payload parameters.
         # History not set correctly as part of this API call for
diff --git a/lib/galaxy_test/api/test_tool_execution.py b/lib/galaxy_test/api/test_tool_execution.py
new file mode 100644
index 000000000000..737d1d668dfd
--- /dev/null
+++ b/lib/galaxy_test/api/test_tool_execution.py
@@ -0,0 +1,61 @@
+"""
+"""
+from typing import (
+    Any,
+    Dict,
+)
+
+import requests
+
+from galaxy_test.base.populators import (
+    DatasetPopulator,
+    skip_without_tool,
+)
+from ._framework import ApiTestCase
+
+
+class TestToolExecution(ApiTestCase):
+    dataset_populator: DatasetPopulator
+
+    def setUp(self):
+        super().setUp()
+        self.dataset_populator = DatasetPopulator(self.galaxy_interactor)
+
+    @skip_without_tool("gx_int")
+    def test_validation(self):
+        with self.dataset_populator.test_history() as history_id:
+            self._assert_request_validates("gx_int", history_id, {"parameter": 5})
+            self._assert_request_invalid("gx_int", history_id, {})
+            self._assert_request_invalid("gx_int", history_id, {"parameter": None})
+            self._assert_request_invalid("gx_int", history_id, {"parameter": "5"})
+
+    @skip_without_tool("gx_int")
+    def test_execution(self):
+        with self.dataset_populator.test_history() as history_id:
+            response = self._run("gx_int", history_id, {"parameter": 5})
+            response.raise_for_status()
+            response_json = response.json()
+            tool_request_id = response_json.get("tool_request_id")
+            task_result = response_json["task_result"]
+            response = self._get(f"histories/{history_id}/tool_requests")
+            response.raise_for_status()
+            assert tool_request_id in [tr["id"] for tr in response.json()]
+            self.dataset_populator.wait_on_task_object(task_result)
+            self.dataset_populator.wait_on_tool_request(tool_request_id)
+
+    def _assert_request_validates(self, tool_id: str, history_id: str, inputs: Dict[str, Any]):
+        response = self._run(tool_id, history_id, inputs)
+        assert response.status_code == 200
+
+    def _assert_request_invalid(self, tool_id: str, history_id: str, inputs: Dict[str, Any]):
+        response = self._run(tool_id, history_id, inputs)
+        assert response.status_code == 400
+
+    def _run(self, tool_id: str, history_id: str, inputs: Dict[str, Any]) -> requests.Response:
+        payload = {
+            "tool_id": tool_id,
+            "history_id": history_id,
+            "inputs": inputs,
+        }
+        response = self._post("jobs", data=payload, json=True)
+        return response
diff --git a/lib/galaxy_test/base/populators.py b/lib/galaxy_test/base/populators.py
index cd6d72f9388b..8cb7bedbf7d3 100644
--- a/lib/galaxy_test/base/populators.py
+++ b/lib/galaxy_test/base/populators.py
@@ -1356,8 +1356,26 @@ def is_ready():
         wait_on(is_ready, "waiting for download to become ready")
         assert is_ready()
 
+    def wait_on_tool_request(self, tool_request_id: str):
+        def state():
+            state_response = self._get(f"tool_requests/{tool_request_id}/state")
+            state_response.raise_for_status()
+            return state_response.json()
+
+        def is_ready():
+            is_complete = state() in ["submitted", "failed"]
+            return True if is_complete else None
+
+        wait_on(is_ready, "waiting for tool request to submit")
+        return state() == "submitted"
+
     def wait_on_task(self, async_task_response: Response):
-        task_id = async_task_response.json()["id"]
+        response_json = async_task_response.json()
+        self.wait_on_task_object(response_json)
+
+    def wait_on_task_object(self, async_task_json: Dict[str, Any]):
+        assert "id" in async_task_json, f"Task response {async_task_json} does not contain expected 'id' field."
+        task_id = async_task_json["id"]
         return self.wait_on_task_id(task_id)
 
     def wait_on_task_id(self, task_id: str):
diff --git a/scripts/db.py b/scripts/db.py
index f25d87e9d8fc..e40f7bb26a56 100644
--- a/scripts/db.py
+++ b/scripts/db.py
@@ -28,6 +28,7 @@ def main() -> None:
     parser_builder.add_version_command()
     parser_builder.add_dbversion_command()
     parser_builder.add_init_command()
+    parser_builder.add_revision_command()
 
     args = parser.parse_args()
     args.func(args)
diff --git a/scripts/gen_typescript_artifacts.py b/scripts/gen_typescript_artifacts.py
new file mode 100644
index 000000000000..a9da728b9459
--- /dev/null
+++ b/scripts/gen_typescript_artifacts.py
@@ -0,0 +1,20 @@
+import os
+import sys
+
+try:
+    from pydantic2ts import generate_typescript_defs
+except ImportError:
+    generate_typescript_defs = None
+
+
+sys.path.insert(1, os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, "lib")))
+
+
+def main():
+    if generate_typescript_defs is None:
+        raise Exception("Please install pydantic-to-typescript into Galaxy's environment")
+    generate_typescript_defs("galaxy.tool_util.parser.parameters", "client/src/components/Tool/parameterModels.ts")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/test/functional/test_toolbox_pytest.py b/test/functional/test_toolbox_pytest.py
index 6bb11e919c02..83ce3c84518b 100644
--- a/test/functional/test_toolbox_pytest.py
+++ b/test/functional/test_toolbox_pytest.py
@@ -64,4 +64,7 @@ class TestFrameworkTools(ApiTestCase):
 
     @pytest.mark.parametrize("testcase", cases(), ids=idfn)
     def test_tool(self, testcase: ToolTest):
-        self._test_driver.run_tool_test(testcase.tool_id, testcase.test_index, tool_version=testcase.tool_version)
+        use_legacy_api = os.environ.get("GALAXY_TEST_USE_LEGACY_TOOL_API", "1") == "1"
+        self._test_driver.run_tool_test(
+            testcase.tool_id, testcase.test_index, tool_version=testcase.tool_version, use_legacy_api=use_legacy_api
+        )
diff --git a/test/functional/tools/parameters/cwl_boolean.cwl b/test/functional/tools/parameters/cwl_boolean.cwl
new file mode 100644
index 000000000000..be6150d48920
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_boolean.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: boolean
+
+outputs:
+  output: boolean
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_boolean_optional.cwl b/test/functional/tools/parameters/cwl_boolean_optional.cwl
new file mode 100644
index 000000000000..f05516dd5d80
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_boolean_optional.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: boolean?
+
+outputs:
+  output: boolean?
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_directory.cwl b/test/functional/tools/parameters/cwl_directory.cwl
new file mode 100644
index 000000000000..66d3c5353079
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_directory.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: Directory
+
+outputs:
+  output: Directory
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_file.cwl b/test/functional/tools/parameters/cwl_file.cwl
new file mode 100644
index 000000000000..ea48da6d2e82
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_file.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: File
+
+outputs:
+  output: File
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_float.cwl b/test/functional/tools/parameters/cwl_float.cwl
new file mode 100644
index 000000000000..9e7e09469055
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_float.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: float
+
+outputs:
+  output: float
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_float_optional.cwl b/test/functional/tools/parameters/cwl_float_optional.cwl
new file mode 100644
index 000000000000..1bc34fa1bc56
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_float_optional.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: float?
+
+outputs:
+  output: float?
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_int.cwl b/test/functional/tools/parameters/cwl_int.cwl
new file mode 100644
index 000000000000..5ba0a8d5c76c
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_int.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: int
+
+outputs:
+  output: int
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_int_optional.cwl b/test/functional/tools/parameters/cwl_int_optional.cwl
new file mode 100644
index 000000000000..63d9c6915862
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_int_optional.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: int?
+
+outputs:
+  output: int?
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_string.cwl b/test/functional/tools/parameters/cwl_string.cwl
new file mode 100644
index 000000000000..571a4cefc6ec
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_string.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: string
+
+outputs:
+  output: string
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/cwl_string_optional.cwl b/test/functional/tools/parameters/cwl_string_optional.cwl
new file mode 100644
index 000000000000..fecc8272d99a
--- /dev/null
+++ b/test/functional/tools/parameters/cwl_string_optional.cwl
@@ -0,0 +1,15 @@
+#!/usr/bin/env cwl-runner
+
+class: ExpressionTool
+requirements:
+  - class: InlineJavascriptRequirement
+cwlVersion: v1.2
+
+inputs:
+  parameter:
+    type: string?
+
+outputs:
+  output: string?
+
+expression: "$({'output': inputs.parameter})"
diff --git a/test/functional/tools/parameters/gx_boolean.xml b/test/functional/tools/parameters/gx_boolean.xml
new file mode 100644
index 000000000000..e42c9c9b6af6
--- /dev/null
+++ b/test/functional/tools/parameters/gx_boolean.xml
@@ -0,0 +1,29 @@
+<tool id="gx_boolean" name="gx_boolean" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="boolean" truevalue="mytrue" falsevalue="myfalse" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value_json="false" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="myfalse" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value_json="true" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="mytrue" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_boolean_optional.xml b/test/functional/tools/parameters/gx_boolean_optional.xml
new file mode 100644
index 000000000000..dc667b614a1a
--- /dev/null
+++ b/test/functional/tools/parameters/gx_boolean_optional.xml
@@ -0,0 +1,82 @@
+<tool id="gx_boolean_optional" name="gx_boolean_optional" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="boolean" optional="true" />
+    </inputs>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
+    <outputs>
+        <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
+    </outputs>
+    <tests>
+        <test>
+            <output name="output">
+                <assert_contents>
+                    <has_line line="false" />
+                </assert_contents>
+            </output>
+            <!-- I wish this were null? It is somehow in expression_null_handling_boolean -->
+            <output name="inputs_json">
+                <assert_contents>
+                    <has_text text="&quot;parameter&quot;: false" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value_json="null" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="false" />
+                </assert_contents>
+            </output>
+            <!-- I wish this were null? It is somehow in expression_null_handling_boolean -->
+            <output name="inputs_json">
+                <assert_contents>
+                    <has_text text="&quot;parameter&quot;: null" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value_json="false" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="false" />
+                </assert_contents>
+            </output>
+            <output name="inputs_json">
+                <assert_contents>
+                    <has_text text="&quot;parameter&quot;: false" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value_json="true" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="true" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value="true" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="true" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value="false" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="false" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_color.xml b/test/functional/tools/parameters/gx_color.xml
new file mode 100644
index 000000000000..fe158d0e6fb1
--- /dev/null
+++ b/test/functional/tools/parameters/gx_color.xml
@@ -0,0 +1,21 @@
+<tool id="gx_color" name="gx_color" version="1.0.0">
+    <command>
+        echo "$parameter"  > $out_file1;
+    </command>
+    <inputs>
+        <param name="parameter" type="color" value="#aabbcc" />
+    </inputs>
+    <outputs>
+        <data name="out_file1" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="#aaaaaa" />
+            <output name="out_file1">
+                <assert_contents>
+                    <has_line line="#aaaaaa" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_conditional_boolean.xml b/test/functional/tools/parameters/gx_conditional_boolean.xml
new file mode 100644
index 000000000000..7c5feffab0ec
--- /dev/null
+++ b/test/functional/tools/parameters/gx_conditional_boolean.xml
@@ -0,0 +1,101 @@
+<tool id="gx_conditional_boolean" name="gx_conditional_boolean" version="1.0.0">
+    <macros>
+        <import>macros.xml</import>
+    </macros>
+    <expand macro="common_conditional_tags" />    
+    <inputs>
+        <conditional name="conditional_parameter">
+            <!-- boolean parameters as the test parameter are discouraged, respect linting and don't do this -->
+            <param name="test_parameter" type="boolean" />
+            <when value="true">
+                <param name="integer_parameter" type="integer" value="1" />
+            </when>
+            <when value="false">
+                <param name="boolean_parameter" type="boolean" />
+            </when>
+        </conditional>
+    </inputs>
+    <tests>
+        <test>
+            <expand macro="assert_output">
+                <has_line line="test: false" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="false" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: false" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="True" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: true" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="False" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: false" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="true" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: true" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value_json="false" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: false" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value_json="true" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: true" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_conditional_boolean_checked.xml b/test/functional/tools/parameters/gx_conditional_boolean_checked.xml
new file mode 100644
index 000000000000..09fdbd71fe6d
--- /dev/null
+++ b/test/functional/tools/parameters/gx_conditional_boolean_checked.xml
@@ -0,0 +1,53 @@
+<tool id="gx_conditional_boolean_checked" name="gx_conditional_boolean_checked" version="1.0.0">
+    <macros>
+        <import>macros.xml</import>
+    </macros>
+    <expand macro="common_conditional_tags" />
+    <inputs>
+        <conditional name="conditional_parameter">
+            <!-- boolean parameters as the test parameter are discouraged, respect linting and don't do this -->
+            <param name="test_parameter" type="boolean" checked="true" />
+            <when value="true">
+                <param name="integer_parameter" type="integer" value="1" />
+            </when>
+            <when value="false">
+                <param name="boolean_parameter" type="boolean" />
+            </when>
+        </conditional>
+    </inputs>
+    <tests>
+        <test>
+            <expand macro="assert_output">
+                <has_line line="test: true" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="true" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: true" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="false" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: false" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_conditional_boolean_discriminate_on_string_value.xml b/test/functional/tools/parameters/gx_conditional_boolean_discriminate_on_string_value.xml
new file mode 100644
index 000000000000..6bc790d81ad9
--- /dev/null
+++ b/test/functional/tools/parameters/gx_conditional_boolean_discriminate_on_string_value.xml
@@ -0,0 +1,113 @@
+<tool id="gx_conditional_boolean_discriminate_on_string_value" name="gx_conditional_boolean_discriminate_on_string_value" version="1.0.0">
+    <macros>
+        <import>macros.xml</import>
+    </macros>
+    <expand macro="common_conditional_tags" />    
+    <inputs>
+        <conditional name="conditional_parameter">
+            <!-- boolean parameters as the test parameter are discouraged, respect linting and don't do this -->
+            <param name="test_parameter" type="boolean" truevalue="a_value_that_is_t" falsevalue="a_value_that_is_f"  />
+            <when value="a_value_that_is_t">
+                <param name="integer_parameter" type="integer" value="1" />
+            </when>
+            <when value="a_value_that_is_f">
+                <param name="boolean_parameter" type="boolean" />
+            </when>
+        </conditional>
+    </inputs>
+    <tests>
+        <test>
+            <expand macro="assert_output">
+                <has_line line="test: a_value_that_is_f" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="true" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: a_value_that_is_t" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value_json="false" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: a_value_that_is_f" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value_json="true" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: a_value_that_is_t" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="a_value_that_is_t" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: a_value_that_is_t" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="a_value_that_is_f" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: a_value_that_is_f" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="True" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: a_value_that_is_t" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="False" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: a_value_that_is_f" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_conditional_boolean_optional.xml b/test/functional/tools/parameters/gx_conditional_boolean_optional.xml
new file mode 100644
index 000000000000..69fa3d830499
--- /dev/null
+++ b/test/functional/tools/parameters/gx_conditional_boolean_optional.xml
@@ -0,0 +1,79 @@
+<tool id="gx_conditional_boolean_optional" name="gx_conditional_boolean_optional" version="1.0.0">
+    <macros>
+        <import>macros.xml</import>
+    </macros>
+    <expand macro="common_conditional_tags" />
+    <inputs>
+        <conditional name="conditional_parameter">
+            <!-- boolean parameters as the test parameter are discouraged, respect linting and don't do this -->
+            <param name="test_parameter" type="boolean" optional="true" />
+            <when value="true">
+                <param name="integer_parameter" type="integer" value="1" />
+            </when>
+            <when value="false">
+                <param name="boolean_parameter" type="boolean" />
+            </when>
+        </conditional>
+    </inputs>
+    <tests>
+        <test>
+            <expand macro="assert_output">
+                <has_line line="test: false" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value_json="null" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: false" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <!-- When it is a conditional test parameter - it doesn't respect the null. -->
+                <!-- These are discouraged strongly discouraged already - maybe disable for newer profile version. -->
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <!-- The disrespected null was interpreted as false though -->
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value="true" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: true" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value_json="false" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: false" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="false" />
+                <has_json_property_with_value property="boolean_parameter" value="false" />
+            </expand>
+        </test>
+        <test>
+            <conditional name="conditional_parameter">
+                <param name="test_parameter" value_json="true" />
+            </conditional>
+            <expand macro="assert_output">
+                <has_line line="test: true" />
+            </expand>
+            <expand macro="assert_inputs_json">
+                <has_json_property_with_value property="test_parameter" value="true" />
+                <has_json_property_with_value property="integer_parameter" value="1" />
+            </expand>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_conditional_conditional_boolean.xml b/test/functional/tools/parameters/gx_conditional_conditional_boolean.xml
new file mode 100644
index 000000000000..343f3576cf6e
--- /dev/null
+++ b/test/functional/tools/parameters/gx_conditional_conditional_boolean.xml
@@ -0,0 +1,30 @@
+<tool id="gx_conditional_conditional_boolean" name="gx_conditional_conditional_boolean" version="1.0.0">
+    <command><![CDATA[
+echo '$outer_conditional_parameter.outer_test_parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <conditional name="outer_conditional_parameter">
+            <!-- boolean parameters as the test parameter are discouraged, respect linting and don't do this -->
+            <param name="outer_test_parameter" type="boolean" />
+            <when value="true">
+                <conditional name="inner_conditional_parameter">
+                    <param name="inner_test_parameter" type="boolean" />
+                    <when value="true">
+                        <param name="integer_parameter" type="integer" value="1" />
+                    </when>
+                    <when value="false">
+                        <param name="boolean_parameter" type="boolean" />
+                    </when>
+                </conditional>
+            </when>
+            <when value="false">
+                <param name="boolean_parameter" type="boolean" />
+            </when>
+        </conditional>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_data.xml b/test/functional/tools/parameters/gx_data.xml
new file mode 100644
index 000000000000..a122623a607d
--- /dev/null
+++ b/test/functional/tools/parameters/gx_data.xml
@@ -0,0 +1,21 @@
+<tool id="gx_data" name="gx_data" version="1.0.0">
+    <command><![CDATA[
+cat '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="data" ext="data" />
+    </inputs>
+    <outputs>
+        <data name="output" format="data" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_data_collection.xml b/test/functional/tools/parameters/gx_data_collection.xml
new file mode 100644
index 000000000000..5669f2921f64
--- /dev/null
+++ b/test/functional/tools/parameters/gx_data_collection.xml
@@ -0,0 +1,14 @@
+<tool id="gx_data_collection" name="gx_data_collection" version="1.0.0">
+    <command><![CDATA[
+cat '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="data_collection" ext="data" />
+    </inputs>
+    <outputs>
+        <data name="output" format="data" />
+    </outputs>
+    <tests>
+        <!-- TODO: -->
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_data_collection_optional.xml b/test/functional/tools/parameters/gx_data_collection_optional.xml
new file mode 100644
index 000000000000..9802176c4f76
--- /dev/null
+++ b/test/functional/tools/parameters/gx_data_collection_optional.xml
@@ -0,0 +1,14 @@
+<tool id="gx_data_collection_optional" name="gx_data_collection_optional" version="1.0.0">
+    <command><![CDATA[
+cat '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="data_collection" ext="data" optional="true" />
+    </inputs>
+    <outputs>
+        <data name="output" format="data" />
+    </outputs>
+    <tests>
+        <!-- TODO: -->
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_data_multiple.xml b/test/functional/tools/parameters/gx_data_multiple.xml
new file mode 100644
index 000000000000..1a751aceadd2
--- /dev/null
+++ b/test/functional/tools/parameters/gx_data_multiple.xml
@@ -0,0 +1,21 @@
+<tool id="gx_data_multiple" name="gx_data_multiple" version="1.0.0">
+    <command><![CDATA[
+cat '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="data" ext="data" multiple="true" />
+    </inputs>
+    <outputs>
+        <data name="output" format="data" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_data_multiple_optional.xml b/test/functional/tools/parameters/gx_data_multiple_optional.xml
new file mode 100644
index 000000000000..3b2a8eb3e69f
--- /dev/null
+++ b/test/functional/tools/parameters/gx_data_multiple_optional.xml
@@ -0,0 +1,21 @@
+<tool id="gx_data_multiple_optional" name="gx_data_multiple_optional" version="1.0.0">
+    <command><![CDATA[
+cat '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="data" ext="data" multiple="true" optional="true" />
+    </inputs>
+    <outputs>
+        <data name="output" format="data" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_data_optional.xml b/test/functional/tools/parameters/gx_data_optional.xml
new file mode 100644
index 000000000000..33281186ad44
--- /dev/null
+++ b/test/functional/tools/parameters/gx_data_optional.xml
@@ -0,0 +1,21 @@
+<tool id="gx_data_optional" name="gx_data_optional" version="1.0.0">
+    <command><![CDATA[
+cat '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="data" ext="data" optional="true" />
+    </inputs>
+    <outputs>
+        <data name="output" format="data" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_float.xml b/test/functional/tools/parameters/gx_float.xml
new file mode 100644
index 000000000000..5da8bc9790b9
--- /dev/null
+++ b/test/functional/tools/parameters/gx_float.xml
@@ -0,0 +1,29 @@
+<tool id="gx_float" name="gx_float" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" value="1.0" type="float" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value_json="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456.0" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456.0" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_float_optional.xml b/test/functional/tools/parameters/gx_float_optional.xml
new file mode 100644
index 000000000000..7d2ad2be396e
--- /dev/null
+++ b/test/functional/tools/parameters/gx_float_optional.xml
@@ -0,0 +1,29 @@
+<tool id="gx_float_optional" name="gx_float_optional" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="float" optional="true" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value_json="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456.0" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456.0" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_hidden.xml b/test/functional/tools/parameters/gx_hidden.xml
new file mode 100644
index 000000000000..e6da3bfb9279
--- /dev/null
+++ b/test/functional/tools/parameters/gx_hidden.xml
@@ -0,0 +1,21 @@
+<tool id="gx_hidden" name="gx_hidden" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="hidden" value="moo" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_hidden_optional.xml b/test/functional/tools/parameters/gx_hidden_optional.xml
new file mode 100644
index 000000000000..e3969f2a8074
--- /dev/null
+++ b/test/functional/tools/parameters/gx_hidden_optional.xml
@@ -0,0 +1,21 @@
+<tool id="gx_hidden_optional" name="gx_hidden_optional" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="hidden" optional="true" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_int.xml b/test/functional/tools/parameters/gx_int.xml
new file mode 100644
index 000000000000..e6f2e6758d26
--- /dev/null
+++ b/test/functional/tools/parameters/gx_int.xml
@@ -0,0 +1,29 @@
+<tool id="gx_int" name="gx_int" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" value="1" type="integer" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value_json="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_int_optional.xml b/test/functional/tools/parameters/gx_int_optional.xml
new file mode 100644
index 000000000000..73b0141c064b
--- /dev/null
+++ b/test/functional/tools/parameters/gx_int_optional.xml
@@ -0,0 +1,21 @@
+<tool id="gx_int" name="gx_int" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" value="1" type="integer" optional="true" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value_json="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_repeat_boolean.xml b/test/functional/tools/parameters/gx_repeat_boolean.xml
new file mode 100644
index 000000000000..2b01857d8abb
--- /dev/null
+++ b/test/functional/tools/parameters/gx_repeat_boolean.xml
@@ -0,0 +1,15 @@
+<tool id="gx_repeat_boolean" name="gx_repeat_boolean" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter.boolean_parameter[0]' >> '$output'
+    ]]></command>
+    <inputs>
+        <repeat name="parameter" title="Repeat Parameter">
+            <param name="boolean_parameter" type="boolean" />
+        </repeat>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select.xml b/test/functional/tools/parameters/gx_select.xml
new file mode 100644
index 000000000000..dd3515ef74ca
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select.xml
@@ -0,0 +1,27 @@
+<tool id="gx_select" name="gx_select" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="select">
+            <option value="--ex1">Ex1</option>
+            <option value="ex2">Ex2</option>
+            <option value="--ex3">Ex3</option>
+            <option value="--ex4">Ex4</option>
+            <option value="ex5">Ex5</option>
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select_multiple.xml b/test/functional/tools/parameters/gx_select_multiple.xml
new file mode 100644
index 000000000000..a39193bde0a4
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_multiple.xml
@@ -0,0 +1,27 @@
+<tool id="gx_select_multiple" name="gx_select_multiple" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="select" multiple="true">
+            <option value="--ex1">Ex1</option>
+            <option value="ex2">Ex2</option>
+            <option value="--ex3">Ex3</option>
+            <option value="--ex4">Ex4</option>
+            <option value="ex5">Ex5</option>
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select_multiple_optional.xml b/test/functional/tools/parameters/gx_select_multiple_optional.xml
new file mode 100644
index 000000000000..3025b72aed54
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_multiple_optional.xml
@@ -0,0 +1,27 @@
+<tool id="gx_select_multiple" name="gx_select_multiple" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="select" multiple="true" optional="true">
+            <option value="--ex1">Ex1</option>
+            <option value="ex2">Ex2</option>
+            <option value="--ex3">Ex3</option>
+            <option value="--ex4">Ex4</option>
+            <option value="ex5">Ex5</option>
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select_optional.xml b/test/functional/tools/parameters/gx_select_optional.xml
new file mode 100644
index 000000000000..2e524dbae38a
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_optional.xml
@@ -0,0 +1,27 @@
+<tool id="gx_select_optional" name="gx_select_optional" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="select" optional="true">
+            <option value="--ex1">Ex1</option>
+            <option value="ex2">Ex2</option>
+            <option value="--ex3">Ex3</option>
+            <option value="--ex4">Ex4</option>
+            <option value="ex5">Ex5</option>
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_text.xml b/test/functional/tools/parameters/gx_text.xml
new file mode 100644
index 000000000000..16707f63e878
--- /dev/null
+++ b/test/functional/tools/parameters/gx_text.xml
@@ -0,0 +1,21 @@
+<tool id="gx_text" name="gx_text" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="text" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_text_optional.xml b/test/functional/tools/parameters/gx_text_optional.xml
new file mode 100644
index 000000000000..41fe11cea418
--- /dev/null
+++ b/test/functional/tools/parameters/gx_text_optional.xml
@@ -0,0 +1,21 @@
+<tool id="gx_text_optional" name="gx_text_optional" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="text" optional="true" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="parameter" value="12456" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="12456" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/macros.xml b/test/functional/tools/parameters/macros.xml
new file mode 100644
index 000000000000..e47d243f75c4
--- /dev/null
+++ b/test/functional/tools/parameters/macros.xml
@@ -0,0 +1,33 @@
+<macros>
+  <xml name="common_conditional_tags">
+    <command><![CDATA[
+echo 'test: $conditional_parameter.test_parameter' >> '$output';
+cat '$inputs' >> '$inputs_json';
+    ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
+    <outputs>
+        <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
+    </outputs>
+    <help>
+        This is a test tool used to establish and verify the behavior of some aspect of Galaxy's
+        parameter handling.
+    </help>
+  </xml>
+  <xml name="assert_output">
+    <output name="output">
+        <assert_contents>
+            <yield />
+        </assert_contents>
+    </output>
+  </xml>
+  <xml name="assert_inputs_json">
+    <output name="inputs_json">
+        <assert_contents>
+            <yield />
+        </assert_contents>
+    </output>
+  </xml>
+</macros>
diff --git a/test/functional/tools/sample_tool_conf.xml b/test/functional/tools/sample_tool_conf.xml
index 0e32640e96fe..d72917dbde4f 100644
--- a/test/functional/tools/sample_tool_conf.xml
+++ b/test/functional/tools/sample_tool_conf.xml
@@ -254,6 +254,8 @@
   <tool file="for_workflows/create_input_collection.xml" />
   <tool file="for_workflows/randomlines.xml" />
 
+  <tool_dir dir="parameters/" />
+
   <section id="filter" name="For Tours">
     <tool file="for_tours/filtering.xml" />
   </section>
diff --git a/test/unit/tool_util/parameter_specification.yml b/test/unit/tool_util/parameter_specification.yml
new file mode 100644
index 000000000000..df2fb9be479f
--- /dev/null
+++ b/test/unit/tool_util/parameter_specification.yml
@@ -0,0 +1,590 @@
+# Tools to create.
+
+# Notes on conditional boolean values...
+# - if you set truevalue/falsevalue - it doesn't look like the when can remain
+#   true/false - so go through and simplify that. means don't need to create test
+#   cases that test that. Linting also at very least warns on this.
+
+# - gx_conditional_boolean_empty_default
+# - gx_conditional_boolean_empty_else
+# - gx_conditional_select_*
+# - gx_repeat_select_required
+# - gx_repeat_repeat_select_required
+# - gx_repeat_conditional_boolean_optional
+
+# Things to verify:
+# - non optional, multi-selects require a selection (see TODO below...)
+gx_int:
+  request_valid:
+    - parameter: 5
+    - parameter: 6
+    # galaxy parameters created with a value - so doesn't need to appear in request even though non-optional
+    - {}
+  request_invalid:
+    - parameter: null
+    - parameter: "null"
+    - parameter: "None"
+    - parameter: { 5 }
+  test_case_valid:
+    - parameter: 5
+    - {}
+  test_case_invalid:
+    - parameter: null
+    - parameter: "5"
+
+gx_boolean:
+  request_valid:
+    - parameter: True
+    - parameter: False
+    - {}
+  request_invalid:
+    - parameter: {}
+    - parameter: "true"
+    # This is borderline... should we allow truevalue/falsevalue in the API.
+    # Marius and John were on fence here.
+    - parameter: "mytrue"
+    - parameter: null
+
+gx_int_optional:
+  request_valid:
+   - parameter: 5
+   - parameter: null
+   - {}
+  request_invalid:
+   - parameter: "5"
+   - parameter: "None"
+   - parameter: "null"
+   - parameter: [5]
+
+gx_text:
+  request_valid:
+    - parameter: moocow
+    - parameter: 'some spaces'
+    - parameter: ''
+  request_invalid:
+    - parameter: 5
+    - parameter: null
+    - parameter: {}
+    - parameter: { "moo": "cow" }
+
+gx_text_optional:
+  request_valid:
+    - parameter: moocow
+    - parameter: 'some spaces'
+    - parameter: ''
+    - parameter: null
+  request_invalid:
+    - parameter: 5
+    - parameter: {}
+    - parameter: { "moo": "cow" }
+
+gx_select:
+  request_valid:
+  - parameter: "--ex1"
+  - parameter: "ex2"
+  request_invalid:
+  # Not allowing selecting booleans by truevalue/falsevalue - don't allow selecting
+  # selects by label.
+  - parameter: "Ex1"
+  # Do not allow lists for non-multi-selects
+  - parameter: ["ex2"]
+  - parameter: null
+  - parameter: {}
+  - parameter: 5
+  - {}
+
+gx_select_optional:
+  request_valid:
+  - parameter: "--ex1"
+  - parameter: "ex2"
+  - parameter: null
+  - {}
+  request_invalid:
+  # Not allowing selecting booleans by truevalue/falsevalue - don't allow selecting
+  # selects by label.
+  - parameter: "Ex1"
+  # Do not allow lists for non-multi-selects
+  - parameter: ["ex2"]
+  - parameter: {}
+  - parameter: 5
+
+# TODO: confirm null should vaguely not be allowed here
+gx_select_multiple:
+  request_valid:
+  - parameter: ["--ex1"]
+  - parameter: ["ex2"]
+  request_invalid:
+  - parameter: ["Ex1"]
+  - parameter: null
+  - parameter: {}
+  - parameter: 5
+  - {}
+
+gx_select_multiple_optional:
+  request_valid:
+  - parameter: ["--ex1"]
+  - parameter: ["ex2"]
+  - {}
+  - parameter: null
+  request_invalid:
+  - parameter: ["Ex1"]
+  - parameter: {}
+  - parameter: 5
+
+gx_hidden:
+  request_valid:
+    - parameter: moocow
+    - parameter: 'some spaces'
+    - parameter: ''
+  request_invalid:
+    - parameter: null
+    - parameter: 5
+    - parameter: {}
+    - parameter: { "moo": "cow" }
+
+gx_hidden_optional:
+  request_valid:
+    - parameter: moocow
+    - parameter: 'some spaces'
+    - parameter: ''
+    - parameter: null
+  request_invalid:
+    - parameter: 5
+    - parameter: {}
+    - parameter: { "moo": "cow" }
+    
+gx_float:
+  request_valid:
+    - parameter: 5
+    - parameter: 5.0
+    - parameter: 5.0001
+    # galaxy parameters created with a value - so doesn't need to appear in request even though non-optional
+    - {}
+  request_invalid:
+    - parameter: null
+    - parameter: "5"
+    - parameter: "5.0"
+    - parameter: { "moo": "cow" }
+
+gx_float_optional:
+  request_valid:
+    - parameter: 5
+    - parameter: 5.0
+    - parameter: 5.0001
+    - parameter: null
+    - {}
+  request_invalid:
+    - parameter: "5"
+    - parameter: "5.0"
+    - parameter: {}
+    - parameter: { "moo": "cow" }
+
+gx_color:
+  request_valid:
+   - parameter: '#aabbcc'
+   - parameter: '#000000'
+  request_invalid:
+   - parameter: null
+   - parameter: {}
+   - parameter: '#abcd'
+
+gx_data:
+  request_valid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: {__class__: "Batch", values: [{src: hdca, id: abcdabcd}]}
+  request_invalid:
+   - parameter: {__class__: "Batch", values: [{src: hdca, id: 5}]}
+   - parameter: {src: hda, id: 7}
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: null
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: {}
+   - {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+  request_internal_valid:
+   - parameter: {__class__: "Batch", values: [{src: hdca, id: 5}]}
+   - parameter: {src: hda, id: 5}
+   - parameter: {src: hda, id: 0}
+  request_internal_invalid:
+   - parameter: {__class__: "Batch", values: [{src: hdca, id: abcdabcd}]}
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: {}
+   - {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+
+gx_data_optional:
+  request_valid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: null
+   - {}
+  request_invalid:
+   - parameter: {src: hda, id: 5}
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+  request_internal_valid:
+   - parameter: {src: hda, id: 5}
+   - parameter: null
+   - {}
+  request_internal_invalid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+
+gx_data_multiple:
+  request_valid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: [{src: hda, id: abcdabcd}]
+   - parameter: [{src: hdca, id: abcdabcd}]
+   - parameter: [{src: hdca, id: abcdabcd}, {src: hda, id: abcdabcd}]
+  request_invalid:
+   - parameter: {src: hda, id: 5}
+   - parameter: [{src: hdca, id: 5}, {src: hda, id: 5}]
+   - parameter: null
+   - parameter: {}
+   - {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+  request_internal_valid:
+   - parameter: {src: hda, id: 5}
+   - parameter: {src: hdca, id: 5}
+   - parameter: [{src: hda, id: 5}]
+   - parameter: [{src: hdca, id: 5}]
+   - parameter: [{src: hdca, id: 5}, {src: hda, id: 5}]
+  request_internal_invalid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: [{src: hdca, id: abcdabcd}, {src: hda, id: abcdabcd}]
+   - parameter: null
+   - parameter: {}
+   - {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+
+gx_data_multiple_optional:
+  request_valid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: [{src: hda, id: abcdabcd}]
+   - parameter: [{src: hdca, id: abcdabcd}]
+   - parameter: [{src: hdca, id: abcdabcd}, {src: hda, id: abcdabcd}]
+   - parameter: null
+   - {}
+  request_invalid:
+   - parameter: {src: hda, id: 5}
+   - parameter: {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+  request_internal_valid:
+   - parameter: {src: hda, id: 5}
+   - parameter: {src: hdca, id: 5}
+   - parameter: [{src: hda, id: 5}]
+   - parameter: [{src: hdca, id: 5}]
+   - parameter: [{src: hdca, id: 5}, {src: hda, id: 5}]
+   - parameter: null
+   - {}
+  request_internal_invalid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+
+gx_data_collection:
+  request_valid:
+   - parameter: {src: hdca, id: abcdabcd}
+  request_invalid:
+   - parameter: {src: hdca, id: 7}
+   - parameter: null
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: {}
+   - {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+  request_internal_valid:
+   - parameter: {src: hdca, id: 5}
+  request_internal_invalid:
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: null
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: {}
+   - {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+
+gx_data_collection_optional:
+  request_valid:
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: null
+   - {}
+  request_invalid:
+   - parameter: {src: hdca, id: 7}
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+   - parameter: {}
+  request_internal_valid:
+   - parameter: {src: hdca, id: 5}
+   - parameter: null
+   - {}
+  request_internal_invalid:
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+   - parameter: {}
+
+gx_conditional_boolean:
+  request_valid:
+    - conditional_parameter:
+        test_parameter: true
+        integer_parameter: 1
+    - conditional_parameter:
+        test_parameter: true
+        integer_parameter: 2
+    - conditional_parameter:
+        test_parameter: false
+        boolean_parameter: true
+    # Test parameter has default and so does it "case" - so this should be fine
+    - {}
+    # The boolean_parameter is optional so just setting a test_parameter is fine
+    - conditional_parameter:
+        test_parameter: true
+    - conditional_parameter:
+        test_parameter: false
+    # if test parameter is missing, it should be false in this case (TODO: test inverse)
+    # so boolean_parameter or either type or missing should be fine.
+    - conditional_parameter: 
+        boolean_parameter: true
+    - conditional_parameter: 
+        boolean_parameter: false
+    - conditional_parameter: {}
+  request_invalid:
+    - conditional_parameter:
+        test_parameter: false
+        integer_parameter: 1
+    - conditional_parameter:
+        test_parameter: null
+    - conditional_parameter:
+        test_parameter: true
+        integer_parameter: "1"
+    - conditional_parameter: 
+        test_parameter: true
+        integer_parameter: null
+    # if test parameter is missing, it should be false in this case
+    # in that case having an integer_parameter is not acceptable.
+    - conditional_parameter: 
+        integer_parameter: 5
+
+gx_conditional_boolean_checked:
+  request_valid:
+    # if no test parameter is defined, the default is 'checked' so the test
+    # parameter is true.
+    - conditional_parameter:
+        integer_parameter: 5
+    - conditional_parameter:
+        integer_parameter: 0
+
+  request_invalid:
+    # if test parameter is missing, it should be true (it is 'checked') in this case
+    # in that case having a boolean_parameter is not acceptable.
+    - conditional_parameter: 
+        boolean_parameter: false
+
+gx_conditional_conditional_boolean:
+  request_valid:
+    - outer_conditional_parameter:
+        outer_test_parameter: false
+        boolean_parameter: true
+    - outer_conditional_parameter:
+        outer_test_parameter: true
+        inner_conditional_parameter: 
+          inner_test_parameter: true
+          integer_parameter: 5
+    - outer_conditional_parameter:
+        outer_test_parameter: true
+        inner_conditional_parameter:
+          inner_test_parameter: false
+          boolean_parameter: true
+    # Test parameter has default and so does it "case" - so this should be fine
+    - {}
+  request_invalid:
+    - outer_conditional_parameter:
+        outer_test_parameter: true
+        boolean_parameter: true
+    - outer_conditional_parameter:
+        outer_test_parameter: true
+        inner_conditional_parameter:
+          inner_test_parameter: false
+          integer_parameter: 5
+    - outer_conditional_parameter:
+        outer_test_parameter: true
+        inner_conditional_parameter:
+          inner_test_parameter: true
+          integer_parameter: true
+
+gx_repeat_boolean:
+  request_valid:
+    - parameter:
+      - { boolean_parameter: true }
+    - parameter: []
+    - parameter:
+      - { boolean_parameter: true }
+      - { boolean_parameter: false }
+    - parameter: [{}]
+    - parameter: [{}, {}]
+  request_invalid:
+    - parameter:
+      - { boolean_parameter: 4 }
+    - parameter:
+      - { foo: 4 }
+    - parameter:
+      - { boolean_parameter: true }
+      - { boolean_parameter: false }
+      - { boolean_parameter: 4 }
+    - parameter: 5
+
+cwl_int:
+  request_valid:
+    - parameter: 5
+  request_invalid:
+    - parameter: "5"
+    - {}
+    - parameter: null
+    - parameter: "None"
+
+
+# TODO: Not a thing perhaps?
+# cwl_null:
+#   request_valid:
+#     - parameter: null
+#     - {}
+#   request_invalid:
+#     - parameter: "5"
+#     - parameter: 5
+#     - parameter: {}
+
+cwl_int_optional:
+  request_valid:
+    - parameter: 5
+    - parameter: null
+  request_invalid:
+    - parameter: "5"
+    - {}
+    - parameter: "None"
+
+cwl_float:
+  request_valid:
+    - parameter: 5
+    - parameter: 5.0
+  request_invalid:
+    - parameter: null
+    - parameter: "5"
+    - {}
+    - parameter: "None"
+
+cwl_float_optional:
+  request_valid:
+    - parameter: 5
+    - parameter: 5.0
+    - parameter: null
+  request_invalid:
+    - parameter: "5"
+    - {}
+    - parameter: "None"
+
+cwl_string:
+  request_valid:
+    - parameter: "moo"
+    - parameter: ""
+  request_invalid:
+    - parameter: null
+    - {}
+    - parameter: 5
+
+cwl_string_optional:
+  request_valid:
+    - parameter: "moo"
+    - parameter: ""
+    - parameter: null
+  request_invalid:
+    - {}
+    - parameter: 5
+
+cwl_boolean:
+  request_valid:
+    - parameter: true
+    - parameter: false
+  request_invalid:
+    - parameter: null
+    - {}
+    - parameter: 5
+    - parameter: "true"
+    - parameter: "True"
+
+cwl_boolean_optional:
+  request_valid:
+    - parameter: true
+    - parameter: false
+    - parameter: null
+  request_invalid:
+    - {}
+    - parameter: 5
+    - parameter: "true"
+    - parameter: "True"
+
+cwl_file:
+  request_valid:
+   - parameter: {src: hda, id: abcdabcd}
+  request_invalid:
+   - parameter: {src: hda, id: 7}
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: null
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: {}
+   - {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+
+cwl_directory:
+  request_valid:
+   - parameter: {src: hda, id: abcdabcd}
+  request_invalid:
+   - parameter: {src: hda, id: 7}
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: null
+   - parameter: {src: fooda, id: abcdabcd}
+   - parameter: {id: abcdabcd}
+   - parameter: {}
+   - {}
+   - parameter: true
+   - parameter: 5
+   - parameter: "5"
+
diff --git a/test/unit/tool_util/test_parameter_specification.py b/test/unit/tool_util/test_parameter_specification.py
new file mode 100644
index 000000000000..c4fb343868e8
--- /dev/null
+++ b/test/unit/tool_util/test_parameter_specification.py
@@ -0,0 +1,194 @@
+from functools import partial
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+)
+
+import yaml
+
+from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.tool_util.parameters import (
+    decode,
+    encode,
+    RequestInternalToolState,
+    RequestToolState,
+    ToolParameterModel,
+    validate_internal_request,
+    validate_request,
+    validate_test_case,
+)
+from galaxy.tool_util.unittest_utils.parameters import (
+    parameter_bundle,
+    parameter_bundle_for_file,
+    tool_parameter,
+)
+from galaxy.util.resources import resource_string
+
+
+def specification_object():
+    try:
+        yaml_str = resource_string(__package__, "parameter_specification.yml")
+    except AttributeError:
+        # hack for the main() function below where this file is interpreted as part of the
+        # Galaxy tree.
+        yaml_str = open("test/unit/tool_util/parameter_specification.yml").read()
+    return yaml.safe_load(yaml_str)
+
+
+def test_specification():
+    parameter_spec = specification_object()
+    for file in parameter_spec.keys():
+        _test_file(file, parameter_spec)
+
+
+def test_single():
+    # _test_file("gx_int")
+    # _test_file("gx_float")
+    # _test_file("gx_boolean")
+    # _test_file("gx_int_optional")
+    # _test_file("gx_float_optional")
+    # _test_file("gx_conditional_boolean")
+    # _test_file("gx_conditional_conditional_boolean")
+    _test_file("gx_conditional_boolean_checked")
+
+
+def _test_file(file: str, specification=None):
+    spec = specification or specification_object()
+    combos = spec[file]
+    tool_parameter_model = tool_parameter(file)
+    for valid_or_invalid, tests in combos.items():
+        if valid_or_invalid == "request_valid":
+            _assert_requests_validate(tool_parameter_model, tests)
+        elif valid_or_invalid == "request_invalid":
+            _assert_requests_invalid(tool_parameter_model, tests)
+        elif valid_or_invalid == "request_internal_valid":
+            _assert_internal_requests_validate(tool_parameter_model, tests)
+        elif valid_or_invalid == "request_internal_invalid":
+            _assert_internal_requests_invalid(tool_parameter_model, tests)
+        elif valid_or_invalid == "test_case_valid":
+            _assert_test_cases_validate(tool_parameter_model, tests)
+        elif valid_or_invalid == "test_case_invalid":
+            _assert_test_cases_invalid(tool_parameter_model, tests)
+
+    # Assume request validation will work here.
+    if "request_internal_valid" not in combos and "request_valid" in combos:
+        _assert_internal_requests_validate(tool_parameter_model, combos["request_valid"])
+    if "request_internal_invalid" not in combos and "request_invvalid" in combos:
+        _assert_internal_requests_invalid(tool_parameter_model, combos["request_invalid"])
+
+
+def _for_each(test: Callable, parameter: ToolParameterModel, requests: List[Dict[str, Any]]) -> None:
+    for request in requests:
+        test(parameter, request)
+
+
+def _assert_request_validates(parameter, request) -> None:
+    try:
+        validate_request(parameter_bundle(parameter), request)
+    except RequestParameterInvalidException as e:
+        raise AssertionError(f"Parameter {parameter} failed to validate request {request}. {e}")
+
+
+def _assert_request_invalid(parameter, request) -> None:
+    exc = None
+    try:
+        validate_request(parameter_bundle(parameter), request)
+    except RequestParameterInvalidException as e:
+        exc = e
+    assert exc is not None, f"Parameter {parameter} didn't result in validation error on request {request} as expected."
+
+
+def _assert_internal_request_validates(parameter, request) -> None:
+    try:
+        validate_internal_request(parameter_bundle(parameter), request)
+    except RequestParameterInvalidException as e:
+        raise AssertionError(f"Parameter {parameter} failed to validate internal request {request}. {e}")
+
+
+def _assert_internal_request_invalid(parameter, request) -> None:
+    exc = None
+    try:
+        validate_internal_request(parameter_bundle(parameter), request)
+    except RequestParameterInvalidException as e:
+        exc = e
+    assert (
+        exc is not None
+    ), f"Parameter {parameter} didn't result in validation error on internal request {request} as expected."
+
+
+def _assert_test_case_validates(parameter, test_case) -> None:
+    try:
+        validate_test_case(parameter_bundle(parameter), test_case)
+    except RequestParameterInvalidException as e:
+        raise AssertionError(f"Parameter {parameter} failed to validate test_case {test_case}. {e}")
+
+
+def _assert_test_case_invalid(parameter, test_case) -> None:
+    exc = None
+    try:
+        validate_test_case(parameter_bundle(parameter), test_case)
+    except RequestParameterInvalidException as e:
+        exc = e
+    assert (
+        exc is not None
+    ), f"Parameter {parameter} didn't result in validation error on test_case {test_case} as expected."
+
+
+_assert_requests_validate = partial(_for_each, _assert_request_validates)
+_assert_requests_invalid = partial(_for_each, _assert_request_invalid)
+_assert_internal_requests_validate = partial(_for_each, _assert_internal_request_validates)
+_assert_internal_requests_invalid = partial(_for_each, _assert_internal_request_invalid)
+_assert_test_cases_validate = partial(_for_each, _assert_test_case_validates)
+_assert_test_cases_invalid = partial(_for_each, _assert_test_case_invalid)
+
+
+def decode_val(val: str) -> int:
+    assert val == "abcdabcd"
+    return 5
+
+
+def test_decode_gx_data():
+    input_bundle = parameter_bundle_for_file("gx_data")
+
+    request_tool_state = RequestToolState({"parameter": {"src": "hda", "id": "abcdabcd"}})
+    request_internal_tool_state = decode(request_tool_state, input_bundle, decode_val)
+    assert request_internal_tool_state.input_state["parameter"]["id"] == 5
+    assert request_internal_tool_state.input_state["parameter"]["src"] == "hda"
+
+
+def test_decode_gx_int():
+    input_bundle = parameter_bundle_for_file("gx_int")
+
+    request_tool_state = RequestToolState({"parameter": 5})
+    request_internal_tool_state = decode(request_tool_state, input_bundle, decode_val)
+    assert request_internal_tool_state.input_state["parameter"] == 5
+
+
+def test_encode_gx_data():
+    input_bundle = parameter_bundle_for_file("gx_data")
+
+    def encode_val(val: int) -> str:
+        assert val == 5
+        return "abcdabcd"
+
+    request_internal_tool_state = RequestInternalToolState({"parameter": {"src": "hda", "id": 5}})
+    request_tool_state = encode(request_internal_tool_state, input_bundle, encode_val)
+    assert request_tool_state.input_state["parameter"]["id"] == "abcdabcd"
+    assert request_tool_state.input_state["parameter"]["src"] == "hda"
+
+
+if __name__ == "__main__":
+    parameter_spec = specification_object()
+    parameter_models_json = {}
+    for file in parameter_spec.keys():
+        tool_parameter_model = tool_parameter(file)
+        parameter_models_json[file] = tool_parameter_model.dict()
+    yaml_str = yaml.safe_dump(parameter_models_json)
+    with open("client/src/components/Tool/parameter_models.yml", "w") as f:
+        f.write("# auto generated file for JavaScript testing, do not modify manually\n")
+        f.write("# -----\n")
+        f.write('# PYTHONPATH="lib" python test/unit/tool_util/test_parameter_specification.py\n')
+        f.write("# -----\n")
+        f.write(yaml_str)
diff --git a/test/unit/tool_util/test_parameter_test_cases.py b/test/unit/tool_util/test_parameter_test_cases.py
new file mode 100644
index 000000000000..38b0f2327b93
--- /dev/null
+++ b/test/unit/tool_util/test_parameter_test_cases.py
@@ -0,0 +1,29 @@
+from typing import List
+
+from galaxy.tool_util.parameters.case import test_case_state as case_state
+from galaxy.tool_util.unittest_utils.parameters import (
+    parameter_bundle_for_file,
+    parameter_tool_source,
+)
+
+
+def test_parameter_test_cases_validate():
+    validate_test_cases_for("gx_int")
+    warnings = validate_test_cases_for("gx_float")
+    assert len(warnings[0]) == 0
+    assert len(warnings[1]) == 1
+
+
+def validate_test_cases_for(tool_name: str) -> List[List[str]]:
+    tool_parameter_bundle = parameter_bundle_for_file(tool_name)
+    tool_source = parameter_tool_source(tool_name)
+    profile = tool_source.parse_profile()
+    test_cases = tool_source.parse_tests_to_dict()["tests"]
+    warnings_by_test = []
+    for test_case in test_cases:
+        test_case_state_and_warnings = case_state(test_case, tool_parameter_bundle, profile)
+        tool_state = test_case_state_and_warnings.tool_state
+        warnings = test_case_state_and_warnings.warnings
+        assert tool_state.state_representation == "test_case"
+        warnings_by_test.append(warnings)
+    return warnings_by_test