diff --git a/.github/workflows/api.yaml b/.github/workflows/api.yaml
index 8eb5a2dd564a..0ca4399f9314 100644
--- a/.github/workflows/api.yaml
+++ b/.github/workflows/api.yaml
@@ -18,6 +18,7 @@ env:
   GALAXY_TEST_DBURI: 'postgresql://postgres:postgres@localhost:5432/galaxy?client_encoding=utf8'
   GALAXY_TEST_RAISE_EXCEPTION_ON_HISTORYLESS_HDA: '1'
   GALAXY_CONFIG_SQLALCHEMY_WARN_20: '1'
+  GALAXY_TEST_REQUIRE_ALL_NEEDED_TOOLS: '1'
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
diff --git a/.github/workflows/framework_tools.yaml b/.github/workflows/framework_tools.yaml
index a55dfa316488..3ae88c7a7eda 100644
--- a/.github/workflows/framework_tools.yaml
+++ b/.github/workflows/framework_tools.yaml
@@ -26,6 +26,7 @@ jobs:
     strategy:
       matrix:
         python-version: ['3.8']
+        use-legacy-api: ['if_needed', 'always']
     services:
       postgres:
         image: postgres:13
@@ -63,7 +64,7 @@ jobs:
           path: 'galaxy root/.venv'
           key: gxy-venv-${{ runner.os }}-${{ steps.full-python-version.outputs.version }}-${{ hashFiles('galaxy root/requirements.txt') }}-framework-tools
       - name: Run tests
-        run: ./run_tests.sh --coverage --framework-tools
+        run: GALAXY_TEST_USE_LEGACY_TOOL_API="${{ matrix.use-legacy-api }}" ./run_tests.sh --coverage --framework-tools
         working-directory: 'galaxy root'
       - uses: codecov/codecov-action@v3
         with:
diff --git a/client/src/api/schema/schema.ts b/client/src/api/schema/schema.ts
index a8ddacee9b22..d06c90452eff 100644
--- a/client/src/api/schema/schema.ts
+++ b/client/src/api/schema/schema.ts
@@ -2462,6 +2462,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/histories/{history_id}/tool_requests": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Return all the tool requests for the tools submitted to this history. */
+        get: operations["tool_requests_api_histories__history_id__tool_requests_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/histories/{history_id}/unpublish": {
         parameters: {
             query?: never;
@@ -2740,7 +2757,8 @@ export interface paths {
         /** Index */
         get: operations["index_api_jobs_get"];
         put?: never;
-        post?: never;
+        /** Create */
+        post: operations["create_api_jobs_post"];
         delete?: never;
         options?: never;
         head?: never;
@@ -4285,6 +4303,91 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/tool_landings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Create Landing */
+        post: operations["create_landing_api_tool_landings_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tool_landings/{uuid}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Landing */
+        get: operations["get_landing_api_tool_landings__uuid__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tool_landings/{uuid}/claim": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Claim Landing */
+        post: operations["claim_landing_api_tool_landings__uuid__claim_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tool_requests/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get tool request state. */
+        get: operations["get_tool_request_api_tool_requests__id__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tool_requests/{id}/state": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get tool request state. */
+        get: operations["tool_request_state_api_tool_requests__id__state_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/tool_shed_repositories": {
         parameters: {
             query?: never;
@@ -4353,6 +4456,77 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/tools/{tool_id}/inputs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get tool inputs. */
+        get: operations["tool_inputs_api_tools__tool_id__inputs_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tools/{tool_id}/parameter_landing_request_schema": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Return a JSON schema description of the tool's inputs for the tool landing request API. */
+        get: operations["tools__parameter_landing_request_schema"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tools/{tool_id}/parameter_request_schema": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Return a JSON schema description of the tool's inputs for the tool request API that will be added to Galaxy at some point
+         * @description The tool request schema includes validation of map/reduce concepts that can be consumed by the tool execution API and not just the request for a single execution.
+         */
+        get: operations["tools__parameter_request_schema"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tools/{tool_id}/parameter_test_case_xml_schema": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Return a JSON schema description of the tool's inputs for test case construction. */
+        get: operations["tools__parameter_test_case_xml_schema"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/tours": {
         parameters: {
             query?: never;
@@ -6160,6 +6334,39 @@ export interface components {
                   )
                 | ("cloud" | "quota" | "no_quota" | "restricted" | "user_defined");
         };
+        /** BaseUrlParameterModel */
+        BaseUrlParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_baseurl
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_baseurl";
+        };
         /** BasicRoleModel */
         BasicRoleModel: {
             /**
@@ -6275,6 +6482,48 @@ export interface components {
             /** Targets */
             targets: unknown;
         };
+        /** BooleanParameterModel */
+        BooleanParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Falsevalue */
+            falsevalue?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_boolean
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_boolean";
+            /** Truevalue */
+            truevalue?: string | null;
+            /**
+             * Value
+             * @default false
+             */
+            value: boolean | null;
+        };
         /** BroadcastNotificationContent */
         BroadcastNotificationContent: {
             /**
@@ -6575,6 +6824,41 @@ export interface components {
          * @enum {string}
          */
         ColletionSourceType: "hda" | "ldda" | "hdca" | "new_collection";
+        /** ColorParameterModel */
+        ColorParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_color
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_color";
+            /** Value */
+            value?: string | null;
+        };
         /** CompositeDataElement */
         CompositeDataElement: {
             /** Md5 */
@@ -6724,6 +7008,82 @@ export interface components {
              */
             source: string | null;
         };
+        /** ConditionalParameterModel */
+        ConditionalParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_conditional
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_conditional";
+            /** Test Parameter */
+            test_parameter:
+                | components["schemas"]["BooleanParameterModel"]
+                | components["schemas"]["SelectParameterModel"];
+            /** Whens */
+            whens: components["schemas"]["ConditionalWhen"][];
+        };
+        /** ConditionalWhen */
+        ConditionalWhen: {
+            /** Discriminator */
+            discriminator: boolean | string;
+            /** Is Default When */
+            is_default_when: boolean;
+            /** Parameters */
+            parameters: (
+                | components["schemas"]["CwlIntegerParameterModel"]
+                | components["schemas"]["CwlFloatParameterModel"]
+                | components["schemas"]["CwlStringParameterModel"]
+                | components["schemas"]["CwlBooleanParameterModel"]
+                | components["schemas"]["CwlNullParameterModel"]
+                | components["schemas"]["CwlFileParameterModel"]
+                | components["schemas"]["CwlDirectoryParameterModel"]
+                | components["schemas"]["CwlUnionParameterModel"]
+                | components["schemas"]["TextParameterModel"]
+                | components["schemas"]["IntegerParameterModel"]
+                | components["schemas"]["FloatParameterModel"]
+                | components["schemas"]["BooleanParameterModel"]
+                | components["schemas"]["HiddenParameterModel"]
+                | components["schemas"]["SelectParameterModel"]
+                | components["schemas"]["DataParameterModel"]
+                | components["schemas"]["DataCollectionParameterModel"]
+                | components["schemas"]["DataColumnParameterModel"]
+                | components["schemas"]["DirectoryUriParameterModel"]
+                | components["schemas"]["RulesParameterModel"]
+                | components["schemas"]["DrillDownParameterModel"]
+                | components["schemas"]["GroupTagParameterModel"]
+                | components["schemas"]["BaseUrlParameterModel"]
+                | components["schemas"]["GenomeBuildParameterModel"]
+                | components["schemas"]["ColorParameterModel"]
+                | components["schemas"]["ConditionalParameterModel"]
+                | components["schemas"]["RepeatParameterModel"]
+                | components["schemas"]["SectionParameterModel"]
+            )[];
+        };
         /** ConnectAction */
         ConnectAction: {
             /**
@@ -7166,6 +7526,17 @@ export interface components {
              */
             url: string;
         };
+        /** CreateToolLandingRequestPayload */
+        CreateToolLandingRequestPayload: {
+            /** Client Secret */
+            client_secret?: string | null;
+            /** Request State */
+            request_state?: Record<string, never> | null;
+            /** Tool Id */
+            tool_id: string;
+            /** Tool Version */
+            tool_version?: string | null;
+        };
         /**
          * CreateType
          * @enum {string}
@@ -7633,9 +8004,158 @@ export interface components {
              */
             username_and_slug?: string | null;
         };
-        /**
-         * DCESummary
-         * @description Dataset Collection Element summary information.
+        /** CwlBooleanParameterModel */
+        CwlBooleanParameterModel: {
+            /** Name */
+            name: string;
+            /**
+             * Parameter Type
+             * @default cwl_boolean
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "cwl_boolean";
+        };
+        /** CwlDirectoryParameterModel */
+        CwlDirectoryParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default cwl_directory
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "cwl_directory";
+        };
+        /** CwlFileParameterModel */
+        CwlFileParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default cwl_file
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "cwl_file";
+        };
+        /** CwlFloatParameterModel */
+        CwlFloatParameterModel: {
+            /** Name */
+            name: string;
+            /**
+             * Parameter Type
+             * @default cwl_float
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "cwl_float";
+        };
+        /** CwlIntegerParameterModel */
+        CwlIntegerParameterModel: {
+            /** Name */
+            name: string;
+            /**
+             * Parameter Type
+             * @default cwl_integer
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "cwl_integer";
+        };
+        /** CwlNullParameterModel */
+        CwlNullParameterModel: {
+            /** Name */
+            name: string;
+            /**
+             * Parameter Type
+             * @default cwl_null
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "cwl_null";
+        };
+        /** CwlStringParameterModel */
+        CwlStringParameterModel: {
+            /** Name */
+            name: string;
+            /**
+             * Parameter Type
+             * @default cwl_string
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "cwl_string";
+        };
+        /** CwlUnionParameterModel */
+        CwlUnionParameterModel: {
+            /** Name */
+            name: string;
+            /**
+             * Parameter Type
+             * @default cwl_union
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "cwl_union";
+            /** Parameters */
+            parameters: (
+                | components["schemas"]["CwlIntegerParameterModel"]
+                | components["schemas"]["CwlFloatParameterModel"]
+                | components["schemas"]["CwlStringParameterModel"]
+                | components["schemas"]["CwlBooleanParameterModel"]
+                | components["schemas"]["CwlNullParameterModel"]
+                | components["schemas"]["CwlFileParameterModel"]
+                | components["schemas"]["CwlDirectoryParameterModel"]
+                | components["schemas"]["CwlUnionParameterModel"]
+            )[];
+        };
+        /**
+         * DCESummary
+         * @description Dataset Collection Element summary information.
          */
         DCESummary: {
             /**
@@ -7722,6 +8242,85 @@ export interface components {
              */
             populated?: boolean;
         };
+        /** DataCollectionParameterModel */
+        DataCollectionParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Collection Type */
+            collection_type?: string | null;
+            /**
+             * Extensions
+             * @default [
+             *       "data"
+             *     ]
+             */
+            extensions: string[];
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_data_collection
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_data_collection";
+            /** Value */
+            value: Record<string, never> | null;
+        };
+        /** DataColumnParameterModel */
+        DataColumnParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Multiple */
+            multiple: boolean;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_data_column
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_data_column";
+        };
         /** DataElementsFromTarget */
         DataElementsFromTarget: {
             /**
@@ -7778,6 +8377,55 @@ export interface components {
          * @enum {string}
          */
         DataItemSourceType: "hda" | "ldda" | "hdca" | "dce" | "dc";
+        /** DataParameterModel */
+        DataParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /**
+             * Extensions
+             * @default [
+             *       "data"
+             *     ]
+             */
+            extensions: string[];
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Max */
+            max?: number | null;
+            /** Min */
+            min?: number | null;
+            /**
+             * Multiple
+             * @default false
+             */
+            multiple: boolean;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_data
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_data";
+        };
         /** DatasetAssociationRoles */
         DatasetAssociationRoles: {
             /**
@@ -8408,6 +9056,49 @@ export interface components {
              */
             username: string;
         };
+        /** DirectoryUriParameterModel */
+        DirectoryUriParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_directory_uri
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_directory_uri";
+            /**
+             * Validators
+             * @default []
+             */
+            validators: (
+                | components["schemas"]["LengthParameterValidatorModel"]
+                | components["schemas"]["RegexParameterValidatorModel"]
+                | components["schemas"]["ExpressionParameterValidatorModel"]
+                | components["schemas"]["EmptyFieldParameterValidatorModel"]
+            )[];
+        };
         /** DisconnectAction */
         DisconnectAction: {
             /**
@@ -8451,6 +9142,59 @@ export interface components {
             /** Version */
             version: string;
         };
+        /** DrillDownOptionsDict */
+        DrillDownOptionsDict: {
+            /** Name */
+            name: string | null;
+            /** Options */
+            options: components["schemas"]["DrillDownOptionsDict"][];
+            /** Selected */
+            selected: boolean;
+            /** Value */
+            value: string;
+        };
+        /** DrillDownParameterModel */
+        DrillDownParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Hierarchy
+             * @enum {string}
+             */
+            hierarchy: "recurse" | "exact";
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Multiple */
+            multiple: boolean;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /** Options */
+            options?: components["schemas"]["DrillDownOptionsDict"][] | null;
+            /**
+             * Parameter Type
+             * @default gx_drill_down
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_drill_down";
+        };
         /** DrsObject */
         DrsObject: {
             /**
@@ -8543,6 +9287,28 @@ export interface components {
          * @enum {string}
          */
         ElementsFromType: "archive" | "bagit" | "bagit_archive" | "directory";
+        /** EmptyFieldParameterValidatorModel */
+        EmptyFieldParameterValidatorModel: {
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean;
+            /** Message */
+            message?: string | null;
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean;
+            /**
+             * Type
+             * @default empty_field
+             * @constant
+             * @enum {string}
+             */
+            type: "empty_field";
+        };
         /** EncodedDataItemSourceId */
         EncodedDataItemSourceId: {
             /**
@@ -8853,19 +9619,48 @@ export interface components {
         };
         /** ExportTaskListResponse */
         ExportTaskListResponse: components["schemas"]["ObjectExportTaskResponse"][];
-        /** ExtraFileEntry */
-        ExtraFileEntry: {
-            /** @description The class of this entry, either File or Directory. */
-            class: components["schemas"]["ExtraFilesEntryClass"];
+        /**
+         * ExpressionParameterValidatorModel
+         * @description Check if a one line python expression given expression evaluates to True.
+         *
+         *     The expression is given is the content of the validator tag.
+         */
+        ExpressionParameterValidatorModel: {
+            /** Expression */
+            expression: string;
             /**
-             * Path
-             * @description Relative path to the file or directory.
+             * Implicit
+             * @default false
              */
-            path: string;
-        };
-        /** ExtraFiles */
-        ExtraFiles: {
-            /**
+            implicit: boolean;
+            /** Message */
+            message?: string | null;
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean;
+            /**
+             * Type
+             * @default expression
+             * @constant
+             * @enum {string}
+             */
+            type: "expression";
+        };
+        /** ExtraFileEntry */
+        ExtraFileEntry: {
+            /** @description The class of this entry, either File or Directory. */
+            class: components["schemas"]["ExtraFilesEntryClass"];
+            /**
+             * Path
+             * @description Relative path to the file or directory.
+             */
+            path: string;
+        };
+        /** ExtraFiles */
+        ExtraFiles: {
+            /**
              * Fuzzy Root
              * @description Prevent Galaxy from checking for a single file in a directory and re-interpreting the archive
              * @default true
@@ -9219,6 +10014,50 @@ export interface components {
             /** Step */
             step: components["schemas"]["StepReferenceByOrderIndex"] | components["schemas"]["StepReferenceByLabel"];
         };
+        /** FloatParameterModel */
+        FloatParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Max */
+            max?: number | null;
+            /** Min */
+            min?: number | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_float
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_float";
+            /**
+             * Validators
+             * @default []
+             */
+            validators: components["schemas"]["InRangeParameterValidatorModel"][];
+            /** Value */
+            value?: number | null;
+        };
         /** FolderLibraryFolderItem */
         FolderLibraryFolderItem: {
             /** Can Manage */
@@ -9348,6 +10187,41 @@ export interface components {
             /** Tags */
             tags?: string[] | null;
         };
+        /** GenomeBuildParameterModel */
+        GenomeBuildParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Multiple */
+            multiple: boolean;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_genomebuild
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_genomebuild";
+        };
         /**
          * GroupCreatePayload
          * @description Payload schema for creating a group.
@@ -9458,6 +10332,41 @@ export interface components {
              */
             url: string;
         };
+        /** GroupTagParameterModel */
+        GroupTagParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Multiple */
+            multiple: boolean;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_group_tag
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_group_tag";
+        };
         /** GroupUpdatePayload */
         GroupUpdatePayload: {
             /** name of the group */
@@ -11063,6 +11972,51 @@ export interface components {
         HelpForumUser: {
             [key: string]: unknown;
         };
+        /** HiddenParameterModel */
+        HiddenParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_hidden
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_hidden";
+            /**
+             * Validators
+             * @default []
+             */
+            validators: (
+                | components["schemas"]["LengthParameterValidatorModel"]
+                | components["schemas"]["RegexParameterValidatorModel"]
+                | components["schemas"]["ExpressionParameterValidatorModel"]
+                | components["schemas"]["EmptyFieldParameterValidatorModel"]
+            )[];
+            /** Value */
+            value: string | null;
+        };
         /**
          * HistoryActiveContentCounts
          * @description Contains the number of active, deleted or hidden items in a History.
@@ -11475,6 +12429,42 @@ export interface components {
              */
             uri: string;
         };
+        /** InRangeParameterValidatorModel */
+        InRangeParameterValidatorModel: {
+            /**
+             * Exclude Max
+             * @default false
+             */
+            exclude_max: boolean;
+            /**
+             * Exclude Min
+             * @default false
+             */
+            exclude_min: boolean;
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean;
+            /** Max */
+            max?: number | null;
+            /** Message */
+            message?: string | null;
+            /** Min */
+            min?: number | null;
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean;
+            /**
+             * Type
+             * @default in_range
+             * @constant
+             * @enum {string}
+             */
+            type: "in_range";
+        };
         /** InputDataCollectionStep */
         InputDataCollectionStep: {
             /**
@@ -11718,6 +12708,47 @@ export interface components {
             /** Uninstalled */
             uninstalled: boolean;
         };
+        /** IntegerParameterModel */
+        IntegerParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Max */
+            max?: number | null;
+            /** Min */
+            min?: number | null;
+            /** Name */
+            name: string;
+            /** Optional */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_integer
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_integer";
+            /**
+             * Validators
+             * @default []
+             */
+            validators: components["schemas"]["InRangeParameterValidatorModel"][];
+            /** Value */
+            value?: number | null;
+        };
         /** InvocationCancellationHistoryDeletedResponse */
         InvocationCancellationHistoryDeletedResponse: {
             /**
@@ -12613,6 +13644,15 @@ export interface components {
              */
             update_time: string;
         };
+        /** JobCreateResponse */
+        JobCreateResponse: {
+            task_result: components["schemas"]["AsyncTaskResultSummary"];
+            /**
+             * Tool Request Id
+             * @example 0123456789ABCDEF
+             */
+            tool_request_id: string;
+        };
         /** JobDestinationParams */
         JobDestinationParams: {
             /**
@@ -12891,6 +13931,19 @@ export interface components {
              */
             name: string;
         };
+        /** JobOutputCollectionAssociation */
+        JobOutputCollectionAssociation: {
+            /**
+             * dataset_collection_instance
+             * @description Reference to the associated item.
+             */
+            dataset_collection_instance: components["schemas"]["EncodedDataItemSourceId"];
+            /**
+             * name
+             * @description Name of the job parameter.
+             */
+            name: string;
+        };
         /** JobParameter */
         JobParameter: {
             /**
@@ -12919,6 +13972,47 @@ export interface components {
                 | string
                 | null;
         };
+        /** JobRequest */
+        JobRequest: {
+            /**
+             * history_id
+             * @description TODO
+             */
+            history_id?: string | null;
+            /**
+             * Inputs
+             * @description TODO
+             */
+            inputs?: Record<string, never> | null;
+            /**
+             * rerun_remap_job_id
+             * @description TODO
+             */
+            rerun_remap_job_id?: string | null;
+            /**
+             * Send Email Notification
+             * @description TODO
+             * @default false
+             */
+            send_email_notification: boolean;
+            /**
+             * tool_id
+             * @description TODO
+             */
+            tool_id?: string | null;
+            /**
+             * tool_uuid
+             * @description TODO
+             */
+            tool_uuid?: string | null;
+            /**
+             * tool_version
+             * @description TODO
+             */
+            tool_version?: string | null;
+            /** use_cached_jobs */
+            use_cached_jobs?: boolean | null;
+        };
         /**
          * JobSourceType
          * @description Available types of job sources (model classes) that produce dataset collections.
@@ -13051,6 +14145,15 @@ export interface components {
              */
             user_email?: string | null;
         };
+        /** LabelValue */
+        LabelValue: {
+            /** Label */
+            label: string;
+            /** Selected */
+            selected: boolean;
+            /** Value */
+            value: string;
+        };
         /**
          * LabelValuePair
          * @description Generic Label/Value pair model.
@@ -13099,6 +14202,32 @@ export interface components {
              */
             LIBRARY_MODIFY_in: string[] | string | null;
         };
+        /** LengthParameterValidatorModel */
+        LengthParameterValidatorModel: {
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean;
+            /** Max */
+            max?: number | null;
+            /** Message */
+            message?: string | null;
+            /** Min */
+            min?: number | null;
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean;
+            /**
+             * Type
+             * @default length
+             * @constant
+             * @enum {string}
+             */
+            type: "length";
+        };
         /** LibraryAvailablePermissions */
         LibraryAvailablePermissions: {
             /**
@@ -14250,6 +15379,28 @@ export interface components {
              */
             slug: string;
         };
+        /** NoOptionsParameterValidatorModel */
+        NoOptionsParameterValidatorModel: {
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean;
+            /** Message */
+            message?: string | null;
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean;
+            /**
+             * Type
+             * @default no_options
+             * @constant
+             * @enum {string}
+             */
+            type: "no_options";
+        };
         /**
          * NotificationBroadcastUpdateRequest
          * @description A notification update request specific for broadcasting.
@@ -15387,6 +16538,37 @@ export interface components {
             /** Workflow */
             workflow: string;
         };
+        /**
+         * RegexParameterValidatorModel
+         * @description Check if a regular expression **matches** the value, i.e. appears
+         *     at the beginning of the value. To enforce a match of the complete value use
+         *     ``$`` at the end of the expression. The expression is given is the content
+         *     of the validator tag. Note that for ``selects`` each option is checked
+         *     separately.
+         */
+        RegexParameterValidatorModel: {
+            /** Expression */
+            expression: string;
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean;
+            /** Message */
+            message?: string | null;
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean;
+            /**
+             * Type
+             * @default regex
+             * @constant
+             * @enum {string}
+             */
+            type: "regex";
+        };
         /** ReloadFeedback */
         ReloadFeedback: {
             /** Failed */
@@ -15478,8 +16660,75 @@ export interface components {
              */
             action_type: "remove_unlabeled_workflow_outputs";
         };
-        /** Report */
-        Report: {
+        /** RepeatParameterModel */
+        RepeatParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Max */
+            max?: number | null;
+            /** Min */
+            min?: number | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_repeat
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_repeat";
+            /** Parameters */
+            parameters: (
+                | components["schemas"]["CwlIntegerParameterModel"]
+                | components["schemas"]["CwlFloatParameterModel"]
+                | components["schemas"]["CwlStringParameterModel"]
+                | components["schemas"]["CwlBooleanParameterModel"]
+                | components["schemas"]["CwlNullParameterModel"]
+                | components["schemas"]["CwlFileParameterModel"]
+                | components["schemas"]["CwlDirectoryParameterModel"]
+                | components["schemas"]["CwlUnionParameterModel"]
+                | components["schemas"]["TextParameterModel"]
+                | components["schemas"]["IntegerParameterModel"]
+                | components["schemas"]["FloatParameterModel"]
+                | components["schemas"]["BooleanParameterModel"]
+                | components["schemas"]["HiddenParameterModel"]
+                | components["schemas"]["SelectParameterModel"]
+                | components["schemas"]["DataParameterModel"]
+                | components["schemas"]["DataCollectionParameterModel"]
+                | components["schemas"]["DataColumnParameterModel"]
+                | components["schemas"]["DirectoryUriParameterModel"]
+                | components["schemas"]["RulesParameterModel"]
+                | components["schemas"]["DrillDownParameterModel"]
+                | components["schemas"]["GroupTagParameterModel"]
+                | components["schemas"]["BaseUrlParameterModel"]
+                | components["schemas"]["GenomeBuildParameterModel"]
+                | components["schemas"]["ColorParameterModel"]
+                | components["schemas"]["ConditionalParameterModel"]
+                | components["schemas"]["RepeatParameterModel"]
+                | components["schemas"]["SectionParameterModel"]
+            )[];
+        };
+        /** Report */
+        Report: {
             /** Markdown */
             markdown: string;
         };
@@ -15585,6 +16834,39 @@ export interface components {
         RootModel_Dict_str__int__: {
             [key: string]: number;
         };
+        /** RulesParameterModel */
+        RulesParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_rules
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_rules";
+        };
         /** SearchJobsPayload */
         SearchJobsPayload: {
             /**
@@ -15605,6 +16887,108 @@ export interface components {
         } & {
             [key: string]: unknown;
         };
+        /** SectionParameterModel */
+        SectionParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_section
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_section";
+            /** Parameters */
+            parameters: (
+                | components["schemas"]["CwlIntegerParameterModel"]
+                | components["schemas"]["CwlFloatParameterModel"]
+                | components["schemas"]["CwlStringParameterModel"]
+                | components["schemas"]["CwlBooleanParameterModel"]
+                | components["schemas"]["CwlNullParameterModel"]
+                | components["schemas"]["CwlFileParameterModel"]
+                | components["schemas"]["CwlDirectoryParameterModel"]
+                | components["schemas"]["CwlUnionParameterModel"]
+                | components["schemas"]["TextParameterModel"]
+                | components["schemas"]["IntegerParameterModel"]
+                | components["schemas"]["FloatParameterModel"]
+                | components["schemas"]["BooleanParameterModel"]
+                | components["schemas"]["HiddenParameterModel"]
+                | components["schemas"]["SelectParameterModel"]
+                | components["schemas"]["DataParameterModel"]
+                | components["schemas"]["DataCollectionParameterModel"]
+                | components["schemas"]["DataColumnParameterModel"]
+                | components["schemas"]["DirectoryUriParameterModel"]
+                | components["schemas"]["RulesParameterModel"]
+                | components["schemas"]["DrillDownParameterModel"]
+                | components["schemas"]["GroupTagParameterModel"]
+                | components["schemas"]["BaseUrlParameterModel"]
+                | components["schemas"]["GenomeBuildParameterModel"]
+                | components["schemas"]["ColorParameterModel"]
+                | components["schemas"]["ConditionalParameterModel"]
+                | components["schemas"]["RepeatParameterModel"]
+                | components["schemas"]["SectionParameterModel"]
+            )[];
+        };
+        /** SelectParameterModel */
+        SelectParameterModel: {
+            /** Argument */
+            argument?: string | null;
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Multiple */
+            multiple: boolean;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /** Options */
+            options?: components["schemas"]["LabelValue"][] | null;
+            /**
+             * Parameter Type
+             * @default gx_select
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_select";
+            /** Validators */
+            validators: components["schemas"]["NoOptionsParameterValidatorModel"][];
+        };
         /** ServerDirElement */
         ServerDirElement: {
             /** Md5 */
@@ -16613,6 +17997,61 @@ export interface components {
                 [key: string]: string | boolean | number;
             };
         };
+        /** TextParameterModel */
+        TextParameterModel: {
+            /**
+             * Area
+             * @default false
+             */
+            area: boolean;
+            /** Argument */
+            argument?: string | null;
+            /**
+             * Default Options
+             * @default []
+             */
+            default_options: components["schemas"]["LabelValue"][];
+            /** Help */
+            help?: string | null;
+            /**
+             * Hidden
+             * @default false
+             */
+            hidden: boolean;
+            /**
+             * Is Dynamic
+             * @default false
+             */
+            is_dynamic: boolean;
+            /** Label */
+            label?: string | null;
+            /** Name */
+            name: string;
+            /**
+             * Optional
+             * @default false
+             */
+            optional: boolean;
+            /**
+             * Parameter Type
+             * @default gx_text
+             * @constant
+             * @enum {string}
+             */
+            parameter_type: "gx_text";
+            /**
+             * Validators
+             * @default []
+             */
+            validators: (
+                | components["schemas"]["LengthParameterValidatorModel"]
+                | components["schemas"]["RegexParameterValidatorModel"]
+                | components["schemas"]["ExpressionParameterValidatorModel"]
+                | components["schemas"]["EmptyFieldParameterValidatorModel"]
+            )[];
+            /** Value */
+            value?: string | null;
+        };
         /** ToolDataDetails */
         ToolDataDetails: {
             /**
@@ -16693,6 +18132,41 @@ export interface components {
              */
             values: string;
         };
+        /** ToolLandingRequest */
+        ToolLandingRequest: {
+            /** Request State */
+            request_state?: Record<string, never> | null;
+            state: components["schemas"]["LandingRequestState"];
+            /** Tool Id */
+            tool_id: string;
+            /** Tool Version */
+            tool_version?: string | null;
+            /**
+             * UUID
+             * Format: uuid4
+             * @description Universal unique identifier for this dataset.
+             */
+            uuid: string;
+        };
+        /** ToolRequestModel */
+        ToolRequestModel: {
+            /**
+             * ID
+             * @description Encoded ID of the role
+             * @example 0123456789ABCDEF
+             */
+            id: string;
+            /** Request */
+            request: Record<string, never>;
+            state: components["schemas"]["ToolRequestState"];
+            /** State Message */
+            state_message: string | null;
+        };
+        /**
+         * ToolRequestState
+         * @enum {string}
+         */
+        ToolRequestState: "new" | "submitted" | "failed";
         /** ToolStep */
         ToolStep: {
             /**
@@ -26526,6 +28000,50 @@ export interface operations {
             };
         };
     };
+    tool_requests_api_histories__history_id__tool_requests_get: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                /** @description The encoded database identifier of the History. */
+                history_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolRequestModel"][];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
     unpublish_api_histories__history_id__unpublish_put: {
         parameters: {
             query?: never;
@@ -27355,6 +28873,8 @@ export interface operations {
                 invocation_id?: string | null;
                 /** @description Limit listing of jobs to those that match the specified implicit collection job ID. If none, jobs from any implicit collection execution (or from no implicit collection execution) may be returned. */
                 implicit_collection_jobs_id?: string | null;
+                /** @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. */
+                tool_request_id?: string | null;
                 /** @description Sort results by specified field. */
                 order_by?: components["schemas"]["JobIndexSortByEnum"];
                 /** @description A mix of free text and GitHub-style tags used to filter the index operation.
@@ -27447,6 +28967,51 @@ export interface operations {
             };
         };
     };
+    create_api_jobs_post: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["JobRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["JobCreateResponse"];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
     search_jobs_api_jobs_search_post: {
         parameters: {
             query?: never;
@@ -27888,7 +29453,10 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["JobOutputAssociation"][];
+                    "application/json": (
+                        | components["schemas"]["JobOutputAssociation"]
+                        | components["schemas"]["JobOutputCollectionAssociation"]
+                    )[];
                 };
             };
             /** @description Request Error */
@@ -32236,19 +33804,242 @@ export interface operations {
             };
         };
     };
-    index_api_tool_shed_repositories_get: {
+    create_landing_api_tool_landings_post: {
         parameters: {
-            query?: {
-                /** @description Filter by repository name. */
-                name?: string | null;
-                /** @description Filter by repository owner. */
-                owner?: string | null;
-                /** @description Filter by changeset revision. */
-                changeset?: string | null;
-                /** @description Filter by whether the repository has been deleted. */
-                deleted?: boolean | null;
-                /** @description Filter by whether the repository has been uninstalled. */
-                uninstalled?: boolean | null;
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateToolLandingRequestPayload"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolLandingRequest"];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    get_landing_api_tool_landings__uuid__get: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                /** @description The UUID used to identify a persisted landing request. */
+                uuid: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolLandingRequest"];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    claim_landing_api_tool_landings__uuid__claim_post: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                /** @description The UUID used to identify a persisted landing request. */
+                uuid: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ClaimLandingPayload"] | null;
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolLandingRequest"];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    get_tool_request_api_tool_requests__id__get: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolRequestModel"];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    tool_request_state_api_tool_requests__id__state_get: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": string;
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    index_api_tool_shed_repositories_get: {
+        parameters: {
+            query?: {
+                /** @description Filter by repository name. */
+                name?: string | null;
+                /** @description Filter by repository owner. */
+                owner?: string | null;
+                /** @description Filter by changeset revision. */
+                changeset?: string | null;
+                /** @description Filter by whether the repository has been deleted. */
+                deleted?: boolean | null;
+                /** @description Filter by whether the repository has been uninstalled. */
+                uninstalled?: boolean | null;
             };
             header?: never;
             path?: never;
@@ -32414,6 +34205,218 @@ export interface operations {
             };
         };
     };
+    tool_inputs_api_tools__tool_id__inputs_get: {
+        parameters: {
+            query?: {
+                tool_version?: string | null;
+            };
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                /** @description The tool ID for the lineage stored in Galaxy's toolbox. */
+                tool_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": (
+                        | components["schemas"]["CwlIntegerParameterModel"]
+                        | components["schemas"]["CwlFloatParameterModel"]
+                        | components["schemas"]["CwlStringParameterModel"]
+                        | components["schemas"]["CwlBooleanParameterModel"]
+                        | components["schemas"]["CwlNullParameterModel"]
+                        | components["schemas"]["CwlFileParameterModel"]
+                        | components["schemas"]["CwlDirectoryParameterModel"]
+                        | components["schemas"]["CwlUnionParameterModel"]
+                        | components["schemas"]["TextParameterModel"]
+                        | components["schemas"]["IntegerParameterModel"]
+                        | components["schemas"]["FloatParameterModel"]
+                        | components["schemas"]["BooleanParameterModel"]
+                        | components["schemas"]["HiddenParameterModel"]
+                        | components["schemas"]["SelectParameterModel"]
+                        | components["schemas"]["DataParameterModel"]
+                        | components["schemas"]["DataCollectionParameterModel"]
+                        | components["schemas"]["DataColumnParameterModel"]
+                        | components["schemas"]["DirectoryUriParameterModel"]
+                        | components["schemas"]["RulesParameterModel"]
+                        | components["schemas"]["DrillDownParameterModel"]
+                        | components["schemas"]["GroupTagParameterModel"]
+                        | components["schemas"]["BaseUrlParameterModel"]
+                        | components["schemas"]["GenomeBuildParameterModel"]
+                        | components["schemas"]["ColorParameterModel"]
+                        | components["schemas"]["ConditionalParameterModel"]
+                        | components["schemas"]["RepeatParameterModel"]
+                        | components["schemas"]["SectionParameterModel"]
+                    )[];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    tools__parameter_landing_request_schema: {
+        parameters: {
+            query?: {
+                tool_version?: string | null;
+            };
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                /** @description The tool ID for the lineage stored in Galaxy's toolbox. */
+                tool_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    tools__parameter_request_schema: {
+        parameters: {
+            query?: {
+                tool_version?: string | null;
+            };
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                /** @description The tool ID for the lineage stored in Galaxy's toolbox. */
+                tool_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    tools__parameter_test_case_xml_schema: {
+        parameters: {
+            query?: {
+                tool_version?: string | null;
+            };
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                /** @description The tool ID for the lineage stored in Galaxy's toolbox. */
+                tool_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
     index_api_tours_get: {
         parameters: {
             query?: never;
diff --git a/client/src/components/ActivityBar/ActivityBar.vue b/client/src/components/ActivityBar/ActivityBar.vue
index cde4d7b190ad..6e2641b616cb 100644
--- a/client/src/components/ActivityBar/ActivityBar.vue
+++ b/client/src/components/ActivityBar/ActivityBar.vue
@@ -132,12 +132,16 @@ function onToggleSidebar(toggle: string = "", to: string | null = null) {
     userStore.toggleSideBar(toggle);
 }
 
-watch(
-    () => hashedUserId.value,
-    () => {
-        activityStore.sync();
+const syncActivities = () => {
+    activityStore.sync();
+    if (config.value && ["workflow_centric", "workflow_runner"].indexOf(config.value.client_mode) >= 0) {
+        userStore.untoggleToolbarIfNeeded();
     }
-);
+};
+
+watch(() => hashedUserId.value, syncActivities);
+
+watch(isConfigLoaded, syncActivities);
 </script>
 
 <template>
diff --git a/client/src/components/Tool/ToolForm.vue b/client/src/components/Tool/ToolForm.vue
index 0268d65bad8e..827a95a22645 100644
--- a/client/src/components/Tool/ToolForm.vue
+++ b/client/src/components/Tool/ToolForm.vue
@@ -89,7 +89,7 @@
             <template v-slot:header-buttons>
                 <ButtonSpinner
                     id="execute"
-                    title="Run Tool"
+                    :title="runButtonTitle"
                     :disabled="!canMutateHistory"
                     class="btn-sm"
                     :wait="showExecuting"
@@ -98,7 +98,7 @@
             </template>
             <template v-slot:buttons>
                 <ButtonSpinner
-                    title="Run Tool"
+                    :title="runButtonTitle"
                     class="mt-3 mb-3"
                     :disabled="!canMutateHistory"
                     :wait="showExecuting"
@@ -111,12 +111,14 @@
 
 <script>
 import { getGalaxyInstance } from "app";
+import axios from "axios";
 import ButtonSpinner from "components/Common/ButtonSpinner";
 import Heading from "components/Common/Heading";
 import FormDisplay from "components/Form/FormDisplay";
 import FormElement from "components/Form/FormElement";
 import LoadingSpan from "components/LoadingSpan";
 import ToolEntryPoints from "components/ToolEntryPoints/ToolEntryPoints";
+import { getAppRoot } from "onload/loadConfig";
 import { mapActions, mapState, storeToRefs } from "pinia";
 import { useHistoryItemsStore } from "stores/historyItemsStore";
 import { useJobStore } from "stores/jobStore";
@@ -128,7 +130,8 @@ import { useHistoryStore } from "@/stores/historyStore";
 import { useUserStore } from "@/stores/userStore";
 
 import ToolRecommendation from "../ToolRecommendation";
-import { getToolFormData, submitJob, updateToolFormData } from "./services";
+import { getToolFormData, getToolInputs, submitJob, submitToolRequest, updateToolFormData } from "./services";
+import { structuredInputs } from "./structured";
 import ToolCard from "./ToolCard";
 import { allowCachedJobs } from "./utilities";
 
@@ -204,6 +207,8 @@ export default {
             ],
             immutableHistoryMessage:
                 "This history is immutable and you cannot run tools in it. Please switch to a different history.",
+            toolInputs: null,
+            submissionStateMessage: null,
         };
     },
     computed: {
@@ -249,7 +254,15 @@ export default {
             return this.currentHistory && canMutateHistory(this.currentHistory);
         },
         runButtonTitle() {
-            return "Run Tool";
+            if (this.showExecuting) {
+                if (this.submissionStateMessage) {
+                    return this.submissionStateMessage;
+                } else {
+                    return "Run Tool";
+                }
+            } else {
+                return "Run Tool";
+            }
         },
     },
     watch: {
@@ -301,11 +314,38 @@ 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;
             this.loading = 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;
@@ -331,90 +371,135 @@ 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;
-            }
-            if (this.dataManagerMode === "bundle") {
-                jobDef.data_manager_mode = this.dataManagerMode;
-            }
-            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;
+                }
+                if (this.dataManagerMode === "bundle") {
+                    toolRequest.data_manager_mode = this.dataManagerMode;
+                }
+                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;
+                }
+                if (this.dataManagerMode === "bundle") {
+                    jobDef.data_manager_mode = this.dataManagerMode;
+                }
+                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 8ac04d5c4c4d..2c446a3a148f 100644
--- a/client/src/components/Tool/ToolSuccess.vue
+++ b/client/src/components/Tool/ToolSuccess.vue
@@ -17,6 +17,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);
@@ -37,6 +38,10 @@ if (Object.keys(responseVal.value).length === 0) {
             <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"
+                :used-tool-request="usedToolRequest" />
             <ToolSuccessMessage :job-response="jobResponse" :tool-name="toolName" />
             <Webhook type="tool" :tool-id="jobDef.tool_id" />
             <ToolRecommendation v-if="showRecommendation" :tool-id="jobDef.tool_id" />
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..5ca2a43ccba8
--- /dev/null
+++ b/client/src/components/Tool/parameter_models.yml
@@ -0,0 +1,610 @@
+# 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
+  value: '#aabbcc'
+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'
+    is_default_when: false
+    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: 1
+  - discriminator: 'false'
+    is_default_when: true
+    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_boolean_checked:
+  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: true
+  whens:
+  - discriminator: 'true'
+    is_default_when: 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: 1
+  - discriminator: 'false'
+    is_default_when: 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'
+    is_default_when: false
+    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'
+        is_default_when: false
+        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: 1
+      - discriminator: 'false'
+        is_default_when: true
+        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'
+    is_default_when: true
+    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: 1.0
+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: 1
+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: 1
+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
+    selected: false
+    value: --ex1
+  - label: Ex2
+    selected: false
+    value: ex2
+  - label: Ex3
+    selected: false
+    value: --ex3
+  - label: Ex4
+    selected: false
+    value: --ex4
+  - label: Ex5
+    selected: false
+    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
+    selected: false
+    value: --ex1
+  - label: Ex2
+    selected: false
+    value: ex2
+  - label: Ex3
+    selected: false
+    value: --ex3
+  - label: Ex4
+    selected: false
+    value: --ex4
+  - label: Ex5
+    selected: false
+    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
+    selected: false
+    value: --ex1
+  - label: Ex2
+    selected: false
+    value: ex2
+  - label: Ex3
+    selected: false
+    value: --ex3
+  - label: Ex4
+    selected: false
+    value: --ex4
+  - label: Ex5
+    selected: false
+    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
+    selected: false
+    value: --ex1
+  - label: Ex2
+    selected: false
+    value: ex2
+  - label: Ex3
+    selected: false
+    value: --ex3
+  - label: Ex4
+    selected: false
+    value: --ex4
+  - label: Ex5
+    selected: false
+    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 4bf2d5e3702a..14ec852231af 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..345257c7b1ae
--- /dev/null
+++ b/client/src/components/Tool/structured.test.ts
@@ -0,0 +1,79 @@
+import SPEC_PARAMETERS from "./parameter_models.yml";
+import SPEC_TESTS from "./parameter_specification.yml";
+import { type TextParameterModel, type ToolParameterModel } from "./parameterModels";
+import { structuredInputs, validate } from "./structured";
+
+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).toHaveProperty("parameter");
+        if ("parameter" in si) {
+            const val = si["parameter"];
+            expect(val).toBe(5);
+        }
+    });
+});
+
+type TestCase = { [ParameterName: string]: any };
+
+interface FileTestCases {
+    request_invalid: Array<TestCase>;
+    request_valid: Array<TestCase>;
+}
+
+type ParameterSpecification = { [FileName: string]: FileTestCases };
+
+function itShouldValidateParameters(file: string, parameters: Array<TestCase>) {
+    for (const [index, parameter] of parameters.entries()) {
+        itShouldValidateParameter(file, index, parameter);
+    }
+}
+
+function itShouldInvalidateParameters(file: string, parameters: Array<TestCase>) {
+    for (const [index, parameter] of parameters.entries()) {
+        itShouldInvalidateParameter(file, index, parameter);
+    }
+}
+
+function parameterModelsForFile(filename: string): Array<ToolParameterModel> {
+    const parameterModel = SPEC_PARAMETERS[filename];
+    const parameterObject: ToolParameterModel = parameterModel as TextParameterModel;
+    const inputs = [parameterObject];
+    return inputs;
+}
+
+function itShouldValidateParameter(file: string, index: number, parameterTestCase: TestCase) {
+    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: string, index: number, parameterTestCase: TestCase) {
+    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, testCases] of Object.entries(SPEC_TESTS as ParameterSpecification)) {
+        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..153523cf9a00
--- /dev/null
+++ b/client/src/components/Tool/structured.ts
@@ -0,0 +1,397 @@
+import type {
+    BooleanParameterModel,
+    ColorParameterModel,
+    ConditionalParameterModel,
+    CwlBooleanParameterModel,
+    CwlDirectoryParameterModel,
+    CwlFileParameterModel,
+    CwlFloatParameterModel,
+    CwlIntegerParameterModel,
+    CwlNullParameterModel,
+    CwlStringParameterModel,
+    CwlUnionParameterModel,
+    DataCollectionParameterModel,
+    DataParameterModel,
+    FloatParameterModel,
+    HiddenParameterModel,
+    IntegerParameterModel,
+    RepeatParameterModel,
+    SelectParameterModel,
+    TextParameterModel,
+    ToolParameterModel,
+} from "./parameterModels";
+
+type StructuredInputs = { [parameterName: string]: any };
+type FormInputs = { [parameterName: string]: any };
+
+export function structuredInputs(formInputs: FormInputs, toolInputs: Array<ToolParameterModel>): StructuredInputs {
+    const structuredInputs: 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 Error("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: any) => {
+    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: any, srcTypes: Array<string>) {
+    return isObjectWithKeys(v, ["src", "id"]) && srcTypes.indexOf(v.src) >= 0 && isString(v.id);
+}
+
+type TypeChecker = (v: any) => boolean;
+
+function isArrayOf(inputObject: any, typeCheck: TypeChecker): boolean {
+    if (!Array.isArray(inputObject)) {
+        return false;
+    }
+    for (const el of inputObject) {
+        if (!typeCheck(el)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const isDataDict = (v: any) => {
+    return isSrcReferenceObject(v, ["hda", "ldda"]);
+};
+
+const isBatch = (v: any, valueChecker: TypeChecker) => {
+    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: any) => {
+            return v == null;
+        };
+    } else if (isCwlBoolean(parameterModel)) {
+        checkType = isBool;
+    } else if (isCwlString(parameterModel)) {
+        checkType = isString;
+    } else if (isCwlFloat(parameterModel)) {
+        checkType = isFloat;
+    } else {
+        throw Error("Unknown simple CWL type encountered.");
+    }
+    return checkType;
+}
+
+function checkCwlUnionType(parameterModel: CwlUnionParameterModel, inputValue: any) {
+    for (const unionedModel of parameterModel.parameters) {
+        if (simpleCwlTypeChecker(unionedModel)(inputValue)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function validateParameter(inputKey: string, inputValue: any, parameterModel: ToolParameterModel) {
+    const results: string[] = [];
+    let checkType = null;
+
+    function handleOptional(typeCheck: TypeChecker, parameter: ToolParameterModel) {
+        if ("optional" in parameter && parameter.optional) {
+            return (v: any) => {
+                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: any) => {
+            return isString(v) && /^#[0-9A-F]{6}$/i.test(v);
+        };
+        checkType = handleOptional(isColorString, parameterModel);
+    } else if (isGxData(parameterModel)) {
+        const isMultiDataDict = (v: any) => {
+            return isSrcReferenceObject(v, ["hda", "ldda", "hdca"]);
+        };
+        const isArrayOfDataDict = (v: any) => {
+            return isArrayOf(v, isMultiDataDict);
+        };
+        const isBatchData = (v: any) => {
+            return isBatch(v, isMultiDataDict);
+        };
+        let checkRaw: TypeChecker;
+        if (parameterModel.multiple) {
+            checkRaw = handleOptional((v) => {
+                return isMultiDataDict(v) || isArrayOfDataDict(v);
+            }, parameterModel);
+        } else {
+            checkRaw = isDataDict;
+        }
+        checkType = (v: any) => {
+            return checkRaw(v) || isBatchData(v);
+        };
+        checkType = handleOptional(checkType, parameterModel);
+    } else if (isGxSelect(parameterModel)) {
+        let isElement: TypeChecker;
+        if (parameterModel.options != null) {
+            const optionValues = parameterModel.options.map((lv) => {
+                return lv.value;
+            });
+            const isOneOfOptions = (v: any) => {
+                return isString(v) && optionValues.indexOf(v) !== -1;
+            };
+            isElement = isOneOfOptions;
+        } else {
+            isElement = isString;
+        }
+        if (parameterModel.multiple) {
+            checkType = (v: any) => {
+                return isArrayOf(v, isElement);
+            };
+        } else {
+            checkType = isElement;
+        }
+        checkType = handleOptional(checkType, parameterModel);
+    } else if (isGxDataCollection(parameterModel)) {
+        const isDataCollectionDict = (v: any) => {
+            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: any) => {
+            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;
+        let testParameterEffectivelyOptional = testParameter.optional;
+        if (!testParameterEffectivelyOptional && "value" in testParameter && testParameter.value !== null) {
+            testParameterEffectivelyOptional = true;
+        }
+        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 && !testParameterEffectivelyOptional) {
+            results.push(`Non optional conditional test parameter ${testParameterName} was not found in inputs.`);
+        }
+    }
+    if (checkType && !checkType(inputValue)) {
+        results.push(`Parameter ${inputKey} is of invalid type.`);
+    }
+    return results;
+}
+
+function validateParameters(
+    structuredInputs: StructuredInputs,
+    parameterModels: Array<ToolParameterModel>
+): Array<string> {
+    const results = [];
+    const keysEncountered = [];
+    const parameterModelsByName: { [name: string]: ToolParameterModel } = {};
+    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];
+        if (parameterModel) {
+            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" in toolInput && toolInput.optional === true) {
+            continue;
+        }
+        if (toolInput && "value" in toolInput && toolInput.value !== null) {
+            continue;
+        }
+        if (isGxConditional(parameterModel)) {
+            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/components/Workflow/List/WorkflowCard.vue b/client/src/components/Workflow/List/WorkflowCard.vue
index 585ba221b81e..b45b3fd44744 100644
--- a/client/src/components/Workflow/List/WorkflowCard.vue
+++ b/client/src/components/Workflow/List/WorkflowCard.vue
@@ -27,11 +27,13 @@ interface Props {
     workflow: any;
     gridView?: boolean;
     publishedView?: boolean;
+    allowWorkflowManagement?: boolean;
 }
 
 const props = withDefaults(defineProps<Props>(), {
     gridView: false,
     publishedView: false,
+    allowWorkflowManagement: true,
 });
 
 const emit = defineEmits<{
@@ -134,6 +136,7 @@ async function onTagClick(tag: string) {
                     <WorkflowActions
                         :workflow="workflow"
                         :published="publishedView"
+                        :allow-workflow-management="allowWorkflowManagement"
                         @refreshList="emit('refreshList', true)"
                         @toggleShowPreview="toggleShowPreview" />
                 </div>
@@ -185,7 +188,7 @@ async function onTagClick(tag: string) {
 
                     <div class="workflow-edit-run-buttons">
                         <BButton
-                            v-if="!isAnonymous && !shared"
+                            v-if="!isAnonymous && !shared && allowWorkflowManagement"
                             v-b-tooltip.hover.noninteractive
                             :disabled="workflow.deleted"
                             size="sm"
@@ -198,7 +201,7 @@ async function onTagClick(tag: string) {
                         </BButton>
 
                         <AsyncButton
-                            v-else
+                            v-else-if="allowWorkflowManagement"
                             v-b-tooltip.hover.noninteractive
                             size="sm"
                             :disabled="isAnonymous"
diff --git a/client/src/components/Workflow/List/WorkflowList.vue b/client/src/components/Workflow/List/WorkflowList.vue
index 9db7e4865c03..e136a3bdae2a 100644
--- a/client/src/components/Workflow/List/WorkflowList.vue
+++ b/client/src/components/Workflow/List/WorkflowList.vue
@@ -28,10 +28,14 @@ type WorkflowsList = Record<string, never>[];
 
 interface Props {
     activeList?: "my" | "shared_with_me" | "published";
+    clientMode?: "full" | "workflow_centric" | "workflow_runner";
+    initialFilterText?: string;
 }
 
 const props = withDefaults(defineProps<Props>(), {
     activeList: "my",
+    clientMode: "full",
+    initialFilterText: "",
 });
 
 const router = useRouter();
@@ -85,6 +89,7 @@ const validFilters = computed(() => workflowFilters.value.getValidFilters(rawFil
 const invalidFilters = computed(() => workflowFilters.value.getValidFilters(rawFilters.value, true).invalidFilters);
 const isSurroundedByQuotes = computed(() => /^["'].*["']$/.test(filterText.value));
 const hasInvalidFilters = computed(() => !isSurroundedByQuotes.value && Object.keys(invalidFilters.value).length > 0);
+const allowWorkflowManagement = computed(() => props.clientMode == "full");
 
 function updateFilterValue(filterKey: string, newValue: any) {
     const currentFilterText = filterText.value;
@@ -183,6 +188,16 @@ watch([filterText, sortBy, sortDesc], async () => {
     await load(true);
 });
 
+watch(
+    props,
+    () => {
+        if (props.initialFilterText && filterText.value == "") {
+            filterText.value = props.initialFilterText;
+        }
+    },
+    { immediate: true }
+);
+
 onMounted(() => {
     if (router.currentRoute.query.owner) {
         updateFilterValue("user", `'${router.currentRoute.query.owner}'`);
@@ -197,10 +212,10 @@ onMounted(() => {
             <div class="d-flex flex-gapx-1">
                 <Heading h1 separator inline size="xl" class="flex-grow-1 mb-2">Workflows</Heading>
 
-                <WorkflowListActions />
+                <WorkflowListActions v-if="allowWorkflowManagement" />
             </div>
 
-            <BNav pills justified class="mb-2">
+            <BNav v-if="allowWorkflowManagement" pills justified class="mb-2">
                 <BNavItem id="my" :active="activeList === 'my'" :disabled="userStore.isAnonymous" to="/workflows/list">
                     My workflows
                     <LoginRequired v-if="userStore.isAnonymous" target="my" title="Manage your workflows" />
@@ -236,7 +251,7 @@ onMounted(() => {
                 </template>
             </FilterMenu>
 
-            <ListHeader ref="listHeader" show-view-toggle>
+            <ListHeader ref="listHeader" :show-view-toggle="allowWorkflowManagement">
                 <template v-slot:extra-filter>
                     <div v-if="activeList === 'my'">
                         Filter:
@@ -319,6 +334,7 @@ onMounted(() => {
                 :published-view="published"
                 :grid-view="view === 'grid'"
                 :class="view === 'grid' ? 'grid-view' : 'list-view'"
+                :allow-workflow-management="allowWorkflowManagement"
                 @refreshList="load"
                 @tagClick="(tag) => updateFilterValue('tag', `'${tag}'`)"
                 @update-filter="updateFilterValue" />
diff --git a/client/src/components/Workflow/List/WorkflowListActions.vue b/client/src/components/Workflow/List/WorkflowListActions.vue
index f2d2a08a91d3..0cadf5a108ff 100644
--- a/client/src/components/Workflow/List/WorkflowListActions.vue
+++ b/client/src/components/Workflow/List/WorkflowListActions.vue
@@ -17,6 +17,14 @@ const userStore = useUserStore();
 
 const { isAnonymous } = storeToRefs(userStore);
 
+interface Props {
+    advancedOptions: boolean;
+}
+
+withDefaults(defineProps<Props>(), {
+    advancedOptions: true,
+});
+
 const createButtonTitle = computed(() => {
     if (isAnonymous.value) {
         return "Log in to create workflow";
@@ -45,6 +53,7 @@ function navigateToOldCreate() {
     <div id="workflow-list-actions" class="d-flex justify-content-between">
         <div>
             <BButton
+                v-if="advancedOptions"
                 id="workflow-create"
                 v-b-tooltip.hover.noninteractive
                 size="sm"
diff --git a/client/src/entry/analysis/modules/Analysis.vue b/client/src/entry/analysis/modules/Analysis.vue
index 3223f95fc1ca..c7ce9f9f2988 100644
--- a/client/src/entry/analysis/modules/Analysis.vue
+++ b/client/src/entry/analysis/modules/Analysis.vue
@@ -1,7 +1,8 @@
 <script setup>
-import { onMounted, onUnmounted, ref } from "vue";
+import { computed, onMounted, onUnmounted, ref } from "vue";
 import { useRouter } from "vue-router/composables";
 
+import { useConfig } from "@/composables/config";
 import { usePanels } from "@/composables/usePanels";
 
 import CenterFrame from "./CenterFrame.vue";
@@ -13,6 +14,11 @@ import DragAndDropModal from "@/components/Upload/DragAndDropModal.vue";
 const router = useRouter();
 const showCenter = ref(false);
 const { showPanels } = usePanels();
+const { config } = useConfig();
+
+const showHistoryPanel = computed(() => {
+    return showPanels.value && config.value && config.value.client_mode == "full";
+});
 
 // methods
 function hideCenter() {
@@ -44,7 +50,7 @@ onUnmounted(() => {
                 <router-view :key="$route.fullPath" class="h-100" />
             </div>
         </div>
-        <FlexPanel v-if="showPanels" side="right">
+        <FlexPanel v-if="showHistoryPanel" side="right">
             <HistoryIndex />
         </FlexPanel>
         <DragAndDropModal />
diff --git a/client/src/entry/analysis/modules/Home.vue b/client/src/entry/analysis/modules/Home.vue
index ecb9a82ac3f9..f86bb9f5e371 100644
--- a/client/src/entry/analysis/modules/Home.vue
+++ b/client/src/entry/analysis/modules/Home.vue
@@ -3,6 +3,11 @@
         <ToolForm v-if="isTool && !isUpload" v-bind="toolParams" />
         <WorkflowRun v-else-if="isWorkflow" v-bind="workflowParams" />
         <div v-else-if="isController" :src="controllerParams" />
+        <div v-else-if="isWorkflowCentric">
+            <WorkflowLanding
+                :client-mode="config.client_mode"
+                :initial-filter-text="config.simplified_workflow_landing_initial_filter_text || ''" />
+        </div>
         <CenterFrame v-else src="/welcome" />
     </div>
 </template>
@@ -13,11 +18,14 @@ import WorkflowRun from "components/Workflow/Run/WorkflowRun";
 import decodeUriComponent from "decode-uri-component";
 import CenterFrame from "entry/analysis/modules/CenterFrame";
 
+import WorkflowLanding from "./WorkflowLanding.vue";
+
 export default {
     components: {
         CenterFrame,
         ToolForm,
         WorkflowRun,
+        WorkflowLanding,
     },
     props: {
         config: {
@@ -30,6 +38,9 @@ export default {
         },
     },
     computed: {
+        isWorkflowCentric() {
+            return ["workflow_centric", "workflow_runner"].indexOf(this.config.client_mode) >= 0;
+        },
         isController() {
             return this.query.m_c && this.query.m_a;
         },
diff --git a/client/src/entry/analysis/modules/WorkflowLanding.vue b/client/src/entry/analysis/modules/WorkflowLanding.vue
new file mode 100644
index 000000000000..f733c1d1993c
--- /dev/null
+++ b/client/src/entry/analysis/modules/WorkflowLanding.vue
@@ -0,0 +1,16 @@
+<script setup lang="ts">
+import WorkflowList from "@/components/Workflow/List/WorkflowList.vue";
+
+interface Props {
+    initialFilterText: string;
+    clientMode: string;
+}
+
+defineProps<Props>();
+</script>
+
+<template>
+    <div>
+        <WorkflowList active-list="published" :client-mode="clientMode" :initial-filter-text="initialFilterText" />
+    </div>
+</template>
diff --git a/client/src/stores/activitySetup.ts b/client/src/stores/activitySetup.ts
index 17551fc89e2b..9323fad6958e 100644
--- a/client/src/stores/activitySetup.ts
+++ b/client/src/stores/activitySetup.ts
@@ -1,22 +1,42 @@
 /**
  * List of built-in activities
  */
-import { type Activity } from "@/stores/activityStore";
+import { type Activity, type ClientMode, type RawActivity } from "@/stores/activityStore";
 import { type EventData } from "@/stores/eventStore";
 
-export const Activities = [
+function isWorkflowCentric(clientMode: ClientMode): boolean {
+    return ["workflow_centric", "workflow_runner"].indexOf(clientMode) >= 0;
+}
+
+function unlessWorkflowCentric(clientMode: ClientMode): boolean {
+    if (isWorkflowCentric(clientMode)) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+function ifWorkflowCentric(clientMode: ClientMode): boolean {
+    if (isWorkflowCentric(clientMode)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+export const ActivitiesRaw: RawActivity[] = [
     {
         anonymous: false,
         description: "Displays currently running interactive tools (ITs), if these are enabled by the administrator.",
         icon: "fa-laptop",
         id: "interactivetools",
         mutable: false,
-        optional: false,
+        optional: ifWorkflowCentric,
         panel: false,
         title: "Interactive Tools",
         tooltip: "Show active interactive tools",
         to: "/interactivetool_entry_points/list",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
     {
         anonymous: true,
@@ -24,12 +44,12 @@ export const Activities = [
         icon: "upload",
         id: "upload",
         mutable: false,
-        optional: false,
+        optional: ifWorkflowCentric,
         panel: false,
         title: "Upload",
         to: null,
         tooltip: "Download from URL or upload files from disk",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
     {
         anonymous: true,
@@ -37,12 +57,12 @@ export const Activities = [
         icon: "wrench",
         id: "tools",
         mutable: false,
-        optional: false,
+        optional: ifWorkflowCentric,
         panel: true,
         title: "Tools",
-        to: null,
+        to: "/tools",
         tooltip: "Search and run tools",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
     {
         anonymous: true,
@@ -81,7 +101,7 @@ export const Activities = [
         title: "Visualization",
         to: null,
         tooltip: "Visualize datasets",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
     {
         anonymous: true,
@@ -94,7 +114,7 @@ export const Activities = [
         title: "Histories",
         tooltip: "Show all histories",
         to: "/histories/list",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
     {
         anonymous: false,
@@ -107,7 +127,7 @@ export const Activities = [
         title: "History Multiview",
         tooltip: "Select histories to show in History Multiview",
         to: "/histories/view_multiple",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
     {
         anonymous: false,
@@ -120,7 +140,7 @@ export const Activities = [
         title: "Datasets",
         tooltip: "Show all datasets",
         to: "/datasets/list",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
     {
         anonymous: true,
@@ -133,7 +153,7 @@ export const Activities = [
         title: "Pages",
         tooltip: "Show all pages",
         to: "/pages/list",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
     {
         anonymous: false,
@@ -146,10 +166,29 @@ export const Activities = [
         title: "Libraries",
         tooltip: "Access data libraries",
         to: "/libraries",
-        visible: true,
+        visible: unlessWorkflowCentric,
     },
 ];
 
+function resolveActivity(activity: RawActivity, clientMode: ClientMode): Activity {
+    let optional = activity.optional;
+    let visible = activity.visible;
+    if (typeof optional === "function") {
+        optional = optional(clientMode);
+    }
+    if (typeof visible === "function") {
+        visible = visible(clientMode);
+    }
+    return { ...activity, optional, visible };
+}
+
+export function getActivities(clientMode: ClientMode) {
+    const resolve = (activity: RawActivity) => {
+        return resolveActivity(activity, clientMode);
+    };
+    return ActivitiesRaw.map(resolve);
+}
+
 export function convertDropData(data: EventData): Activity | null {
     if (data.history_content_type === "dataset") {
         return {
diff --git a/client/src/stores/activityStore.ts b/client/src/stores/activityStore.ts
index 377a68e08964..9bd46940b7b2 100644
--- a/client/src/stores/activityStore.ts
+++ b/client/src/stores/activityStore.ts
@@ -5,9 +5,10 @@
 import { defineStore } from "pinia";
 import { type Ref } from "vue";
 
+import { useConfig } from "@/composables/config";
 import { useUserLocalStorage } from "@/composables/userLocalStorage";
 
-import { Activities } from "./activitySetup";
+import { getActivities } from "./activitySetup";
 
 export interface Activity {
     // determine wether an anonymous user can access this activity
@@ -34,6 +35,34 @@ export interface Activity {
     visible: boolean;
 }
 
+export type ClientMode = "full" | "workflow_centric" | "workflow_runner";
+
+// config materializes a RawActivity into an Activity
+export interface RawActivity {
+    // determine wether an anonymous user can access this activity
+    anonymous: boolean;
+    // description of the activity
+    description: string;
+    // unique identifier
+    id: string;
+    // icon to be displayed in activity bar
+    icon: string;
+    // indicate if this activity can be modified and/or deleted
+    mutable: boolean;
+    // indicate wether this activity can be disabled by the user
+    optional: boolean | ((mode: ClientMode) => boolean);
+    // specifiy wether this activity utilizes the side panel
+    panel: boolean;
+    // title to be displayed in the activity bar
+    title: string;
+    // route to be executed upon selecting the activity
+    to: string | null;
+    // tooltip to be displayed when hovering above the icon
+    tooltip: string;
+    // indicate wether the activity should be visible by default
+    visible: boolean | ((mode: ClientMode) => boolean);
+}
+
 export const useActivityStore = defineStore("activityStore", () => {
     const activities: Ref<Array<Activity>> = useUserLocalStorage("activity-store-activities", []);
 
@@ -41,7 +70,12 @@ export const useActivityStore = defineStore("activityStore", () => {
      * Restores the default activity bar items
      */
     function restore() {
-        activities.value = Activities.slice();
+        const { config, isConfigLoaded } = useConfig();
+        if (!isConfigLoaded.value) {
+            return;
+        }
+
+        activities.value = getActivities(config.value.client_mode);
     }
 
     /**
@@ -50,11 +84,18 @@ export const useActivityStore = defineStore("activityStore", () => {
      * to the user stored activities which are persisted in local cache.
      */
     function sync() {
+        const { config, isConfigLoaded } = useConfig();
+        if (!isConfigLoaded.value) {
+            return;
+        }
+
         // create a map of built-in activities
         const activitiesMap: Record<string, Activity> = {};
-        Activities.forEach((a) => {
+        const activityDefs = getActivities(config.value.client_mode);
+        activityDefs.forEach((a) => {
             activitiesMap[a.id] = a;
         });
+
         // create an updated array of activities
         const newActivities: Array<Activity> = [];
         const foundActivity = new Set();
@@ -76,7 +117,7 @@ export const useActivityStore = defineStore("activityStore", () => {
             }
         });
         // add new built-in activities
-        Activities.forEach((a) => {
+        activityDefs.forEach((a) => {
             if (!foundActivity.has(a.id)) {
                 newActivities.push({ ...a });
             }
diff --git a/client/src/stores/jobStore.ts b/client/src/stores/jobStore.ts
index bbae01bdf6f4..880bbb290683 100644
--- a/client/src/stores/jobStore.ts
+++ b/client/src/stores/jobStore.ts
@@ -28,6 +28,7 @@ interface ResponseVal {
     jobDef: JobDef;
     jobResponse: JobResponse;
     toolName: string;
+    usedToolRequest: boolean;
 }
 
 export const useJobStore = defineStore("jobStore", {
diff --git a/client/src/stores/userStore.ts b/client/src/stores/userStore.ts
index 55a49d491209..9379bcb89634 100644
--- a/client/src/stores/userStore.ts
+++ b/client/src/stores/userStore.ts
@@ -146,6 +146,12 @@ export const useUserStore = defineStore("userStore", () => {
         };
     }
 
+    function untoggleToolbarIfNeeded() {
+        if (toggledSideBar.value == "tools") {
+            toggledSideBar.value = "";
+        }
+    }
+
     return {
         currentUser,
         currentPreferences,
@@ -163,6 +169,7 @@ export const useUserStore = defineStore("userStore", () => {
         addFavoriteTool,
         removeFavoriteTool,
         toggleSideBar,
+        untoggleToolbarIfNeeded,
         $reset,
     };
 });
diff --git a/doc/source/dev/tool_state_state_classes.plantuml.svg b/doc/source/dev/tool_state_state_classes.plantuml.svg
index 28c7da1c9092..5874d39c6c1d 100644
--- a/doc/source/dev/tool_state_state_classes.plantuml.svg
+++ b/doc/source/dev/tool_state_state_classes.plantuml.svg
@@ -50,10 +50,31 @@ state_representation = "job_internal"
 }
 note bottom: Object references of the form \n{src: "hda", id: <decoded_id>}.\n Mapping constructs expanded out.\n (Defaults are inserted?)
 
+class TestCaseToolState {
+state_representation = "test_case"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Object references of the form file name and URIs.\n Mapping constructs not allowed.\n
+
+class WorkflowStepToolState {
+state_representation = "workflow_step"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Nearly everything optional except conditional discriminators.\n
+
+class WorkflowStepLinkedToolState {
+state_representation = "workflow_step_linked"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Expect pre-process ``in`` dictionaries and bring in representation\n of links and defaults and validate them in model.\n
+
 ToolState <|- - RequestToolState
 ToolState <|- - RequestInternalToolState
 ToolState <|- - RequestInternalDereferencedToolState
 ToolState <|- - JobInternalToolState
+ToolState <|- - TestCaseToolState
+ToolState <|- - WorkflowStepToolState
+ToolState <|- - WorkflowStepLinkedToolState
 
 RequestToolState - RequestInternalToolState : decode >
 
@@ -61,6 +82,7 @@ RequestInternalToolState - RequestInternalDereferencedToolState : dereference >
 
 RequestInternalDereferencedToolState o- - JobInternalToolState : expand >
 
+WorkflowStepToolState o- - WorkflowStepLinkedToolState : preprocess_links_and_defaults >
 }
 @enduml
 
@@ -150,10 +172,31 @@ state_representation = "job_internal"
 }
 note bottom: Object references of the form \n{src: "hda", id: <decoded_id>}.\n Mapping constructs expanded out.\n (Defaults are inserted?)
 
+class TestCaseToolState {
+state_representation = "test_case"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Object references of the form file name and URIs.\n Mapping constructs not allowed.\n
+
+class WorkflowStepToolState {
+state_representation = "workflow_step"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Nearly everything optional except conditional discriminators.\n
+
+class WorkflowStepLinkedToolState {
+state_representation = "workflow_step_linked"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Expect pre-process ``in`` dictionaries and bring in representation\n of links and defaults and validate them in model.\n
+
 ToolState <|- - RequestToolState
 ToolState <|- - RequestInternalToolState
 ToolState <|- - RequestInternalDereferencedToolState
 ToolState <|- - JobInternalToolState
+ToolState <|- - TestCaseToolState
+ToolState <|- - WorkflowStepToolState
+ToolState <|- - WorkflowStepLinkedToolState
 
 RequestToolState - RequestInternalToolState : decode >
 
@@ -161,6 +204,7 @@ RequestInternalToolState - RequestInternalDereferencedToolState : dereference >
 
 RequestInternalDereferencedToolState o- - JobInternalToolState : expand >
 
+WorkflowStepToolState o- - WorkflowStepLinkedToolState : preprocess_links_and_defaults >
 }
 @enduml
 
diff --git a/doc/source/dev/tool_state_state_classes.plantuml.txt b/doc/source/dev/tool_state_state_classes.plantuml.txt
index 0c2c82951eb3..d37366e96f11 100644
--- a/doc/source/dev/tool_state_state_classes.plantuml.txt
+++ b/doc/source/dev/tool_state_state_classes.plantuml.txt
@@ -35,10 +35,31 @@ state_representation = "job_internal"
 }
 note bottom: Object references of the form \n{src: "hda", id: <decoded_id>}.\n Mapping constructs expanded out.\n (Defaults are inserted?)
 
+class TestCaseToolState {
+state_representation = "test_case"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Object references of the form file name and URIs.\n Mapping constructs not allowed.\n
+
+class WorkflowStepToolState {
+state_representation = "workflow_step"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Nearly everything optional except conditional discriminators.\n
+
+class WorkflowStepLinkedToolState {
+state_representation = "workflow_step_linked"
++ _to_base_model(input_models: ToolParameterBundle): Type[BaseModel]    
+}
+note bottom: Expect pre-process ``in`` dictionaries and bring in representation\n of links and defaults and validate them in model.\n
+
 ToolState <|-- RequestToolState
 ToolState <|-- RequestInternalToolState
 ToolState <|-- RequestInternalDereferencedToolState
 ToolState <|-- JobInternalToolState
+ToolState <|-- TestCaseToolState
+ToolState <|-- WorkflowStepToolState
+ToolState <|-- WorkflowStepLinkedToolState
 
 RequestToolState - RequestInternalToolState : decode >
 
@@ -46,5 +67,6 @@ RequestInternalToolState - RequestInternalDereferencedToolState : dereference >
 
 RequestInternalDereferencedToolState o-- JobInternalToolState : expand >
 
+WorkflowStepToolState o-- WorkflowStepLinkedToolState : preprocess_links_and_defaults >
 }
 @enduml
\ No newline at end of file
diff --git a/lib/galaxy/app.py b/lib/galaxy/app.py
index fcbd1a1b7cb0..e246c5f2d9db 100644
--- a/lib/galaxy/app.py
+++ b/lib/galaxy/app.py
@@ -673,6 +673,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)
@@ -751,11 +755,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 1bfe6b34f39f..dca9d7646b60 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
@@ -54,6 +55,7 @@
     MaterializeDatasetInstanceTaskRequest,
     PrepareDatasetCollectionDownload,
     PurgeDatasetsTaskRequest,
+    QueueJobs,
     SetupHistoryExportJob,
     WriteHistoryContentTo,
     WriteHistoryTo,
@@ -75,8 +77,10 @@ def setup_data_table_manager(app):
 
 
 @lru_cache
-def cached_create_tool_from_representation(app: MinimalManagerApp, raw_tool_source: str):
-    return create_tool_from_representation(app=app, raw_tool_source=raw_tool_source, tool_source_class="XmlToolSource")
+def cached_create_tool_from_representation(app: MinimalManagerApp, raw_tool_source: str, tool_dir: str = ""):
+    return create_tool_from_representation(
+        app=app, raw_tool_source=raw_tool_source, tool_dir=tool_dir, tool_source_class="XmlToolSource"
+    )
 
 
 @galaxy_task(action="recalculate a user's disk usage")
@@ -333,6 +337,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/config/__init__.py b/lib/galaxy/config/__init__.py
index 80d57ab04bf6..59ade28759cf 100644
--- a/lib/galaxy/config/__init__.py
+++ b/lib/galaxy/config/__init__.py
@@ -115,6 +115,14 @@
             "level": "INFO",
             "qualname": "watchdog.observers.inotify_buffer",
         },
+        "py.warnings": {
+            "level": "ERROR",
+            "qualname": "py.warnings",
+        },
+        "celery.utils.functional": {
+            "level": "INFO",
+            "qualname": "celery.utils.functional",
+        },
     },
     "filters": {
         "stack": {
diff --git a/lib/galaxy/config/schemas/config_schema.yml b/lib/galaxy/config/schemas/config_schema.yml
index 3ed0c7455e74..0c3f1b3e15eb 100644
--- a/lib/galaxy/config/schemas/config_schema.yml
+++ b/lib/galaxy/config/schemas/config_schema.yml
@@ -3134,6 +3134,33 @@ mapping:
           When false, the most recently added compatible item in the history will
           be used for each "Set at Runtime" input, independent of others in the workflow.
 
+      client_mode:
+        type: str
+        default: 'full'
+        enum: ['full', 'workflow_centric', 'workflow_runner']
+        required: false
+        per_host: true
+        desc: |
+          This will change the modality and focus on the client UI. The traditional
+          full Galaxy with default activity bar is the default of 'full'.
+          'workflow_centric' & 'workflow_runner' yield client applications
+          that are geared to center a collection of workflows in Galaxy and attempts
+          to hide the concept of histories from users. The 'workflow_centric' view
+          still allows the user to manage & edit a collection of their own workflows.
+          'workflow_runner' is a mode that disables workflow management to even further
+          simplify the UI - this may be appropriate for instances that really just want
+          enable particular workflows as-is.
+
+      simplified_workflow_landing_initial_filter_text:
+        type: str
+        required: false
+        per_host: true
+        desc: |
+          If the Galaxy client is in 'workflow_centric' or 'workflow_runner' "client mode",
+          this controls the initial filtering of the workflow search textbox. This can
+          be used to foreground workflows in the published workflow list by tar (e.g. 'tag:XXX')
+          or username (e.g. 'username:XXXX').
+
       simplified_workflow_run_ui:
         type: str
         default: 'prefer'
diff --git a/lib/galaxy/managers/configuration.py b/lib/galaxy/managers/configuration.py
index d0ccfa8d53c2..8a6d30e8454d 100644
--- a/lib/galaxy/managers/configuration.py
+++ b/lib/galaxy/managers/configuration.py
@@ -164,6 +164,8 @@ def _config_is_truthy(item, key, **context):
             "enable_unique_workflow_defaults": _use_config,
             "enable_beta_markdown_export": _use_config,
             "enable_beacon_integration": _use_config,
+            "client_mode": _use_config,
+            "simplified_workflow_landing_initial_filter_text": _use_config,
             "simplified_workflow_run_ui": _use_config,
             "simplified_workflow_run_ui_target_history": _use_config,
             "simplified_workflow_run_ui_job_cache": _use_config,
diff --git a/lib/galaxy/managers/jobs.py b/lib/galaxy/managers/jobs.py
index 1d4a61dac6f0..fd8380c06435 100644
--- a/lib/galaxy/managers/jobs.py
+++ b/lib/galaxy/managers/jobs.py
@@ -1,5 +1,6 @@
 import json
 import logging
+from dataclasses import dataclass
 from datetime import (
     date,
     datetime,
@@ -10,6 +11,7 @@
     Dict,
     List,
     Optional,
+    Tuple,
     Union,
 )
 
@@ -48,13 +50,19 @@
     ProvidesUserContext,
 )
 from galaxy.managers.datasets import DatasetManager
-from galaxy.managers.hdas import HDAManager
+from galaxy.managers.hdas import (
+    dereference_input,
+    HDAManager,
+)
+from galaxy.managers.histories import HistoryManager
 from galaxy.managers.lddas import LDDAManager
+from galaxy.managers.users import UserManager
 from galaxy.model import (
     ImplicitCollectionJobs,
     ImplicitCollectionJobsJobAssociation,
     Job,
     JobParameter,
+    ToolRequest,
     User,
     Workflow,
     WorkflowInvocation,
@@ -71,8 +79,23 @@
     JobIndexQueryPayload,
     JobIndexSortByEnum,
 )
+from galaxy.schema.tasks import (
+    MaterializeDatasetInstanceTaskRequest,
+    QueueJobs,
+)
 from galaxy.security.idencoding import IdEncodingHelper
-from galaxy.structured_app import StructuredApp
+from galaxy.structured_app import (
+    MinimalManagerApp,
+    StructuredApp,
+)
+from galaxy.tool_util.parameters import (
+    DataRequestInternalHda,
+    DataRequestUri,
+    dereference,
+    RequestInternalDereferencedToolState,
+    RequestInternalToolState,
+)
+from galaxy.tools import Tool
 from galaxy.tools._types import (
     ToolStateDumpedToJsonInternalT,
     ToolStateJobInstancePopulatedT,
@@ -87,6 +110,7 @@
     parse_filters_structured,
     RawTextTerm,
 )
+from galaxy.work.context import WorkRequestContext
 
 log = logging.getLogger(__name__)
 
@@ -135,6 +159,8 @@ def index_query(self, trans: ProvidesUserContext, payload: JobIndexQueryPayload)
         workflow_id = payload.workflow_id
         invocation_id = payload.invocation_id
         implicit_collection_jobs_id = payload.implicit_collection_jobs_id
+        tool_request_id = payload.tool_request_id
+
         search = payload.search
         order_by = payload.order_by
 
@@ -151,6 +177,7 @@ def build_and_apply_filters(stmt, objects, filter_func):
 
         def add_workflow_jobs():
             wfi_step = select(WorkflowInvocationStep)
+
             if workflow_id is not None:
                 wfi_step = (
                     wfi_step.join(WorkflowInvocation).join(Workflow).where(Workflow.stored_workflow_id == workflow_id)
@@ -165,6 +192,7 @@ def add_workflow_jobs():
                 ImplicitCollectionJobsJobAssociation.implicit_collection_jobs_id
                 == wfi_step_sq.c.implicit_collection_jobs_id,
             )
+
             # Ensure the result is models, not tuples
             sq = stmt1.union(stmt2).subquery()
             # SQLite won't recognize Job.foo as a valid column for the ORDER BY clause due to the UNION clause, so we'll use the subquery `columns` collection (`sq.c`).
@@ -242,6 +270,9 @@ def add_search_criteria(stmt):
         if history_id is not None:
             stmt = stmt.where(Job.history_id == history_id)
 
+        if tool_request_id is not None:
+            stmt = stmt.filter(model.Job.tool_request_id == tool_request_id)
+
         order_by_columns = Job
         if workflow_id or invocation_id:
             stmt, order_by_columns = add_workflow_jobs()
@@ -1152,3 +1183,102 @@ def get_jobs_to_check_at_startup(session: galaxy_scoped_session, track_jobs_in_d
 def get_job(session, *where_clauses):
     stmt = select(Job).where(*where_clauses).limit(1)
     return session.scalars(stmt).first()
+
+
+@dataclass
+class DereferencedDatasetPair:
+    hda: model.HistoryDatasetAssociation
+    request: DataRequestUri
+
+
+class JobSubmitter:
+    def __init__(
+        self,
+        history_manager: HistoryManager,
+        user_manager: UserManager,
+        hda_manager: HDAManager,
+        app: MinimalManagerApp,
+    ):
+        self.history_manager = history_manager
+        self.user_manager = user_manager
+        self.hda_manager = hda_manager
+        self.app = app
+
+    def materialize_request_for(
+        self, trans: WorkRequestContext, hda: model.HistoryDatasetAssociation
+    ) -> MaterializeDatasetInstanceTaskRequest:
+        return MaterializeDatasetInstanceTaskRequest(
+            user=trans.async_request_user,
+            history_id=trans.history.id,
+            source="hda",
+            content=hda.id,
+        )
+
+    def dereference(
+        self, trans: WorkRequestContext, tool: Tool, request: QueueJobs, tool_request: ToolRequest
+    ) -> Tuple[RequestInternalDereferencedToolState, List[DereferencedDatasetPair]]:
+        new_hdas: List[DereferencedDatasetPair] = []
+
+        def dereference_callback(data_request: DataRequestUri) -> DataRequestInternalHda:
+            # a deferred dataset corresponding to request
+            hda = dereference_input(trans, data_request)
+            new_hdas.append(DereferencedDatasetPair(hda, data_request))
+            return DataRequestInternalHda(id=hda.id)
+
+        tool_state = RequestInternalToolState(tool_request.request)
+        return dereference(tool_state, tool, dereference_callback), new_hdas
+
+    def queue_jobs(self, tool: Tool, request: QueueJobs) -> None:
+        tool_request: ToolRequest = self._tool_request(request.tool_request_id)
+        sa_session = self.app.model.context
+        try:
+            request_context = self._context(tool_request, request)
+            target_history = request_context.history
+            use_cached_jobs = request.use_cached_jobs
+            rerun_remap_job_id = request.rerun_remap_job_id
+            tool_state: RequestInternalDereferencedToolState
+            new_hdas: List[DereferencedDatasetPair]
+            tool_state, new_hdas = self.dereference(request_context, tool, request, tool_request)
+            to_materialize_list: List[DereferencedDatasetPair] = [p for p in new_hdas if not p.request.deferred]
+            for to_materialize in to_materialize_list:
+                materialize_request = self.materialize_request_for(request_context, to_materialize.hda)
+                # API dataset materialization is immutable and produces new datasets
+                # here we just created the datasets - lets just materialize them in place
+                # and avoid extra and confusing input copies
+                self.hda_manager.materialize(materialize_request, in_place=True)
+            tool.handle_input_async(
+                request_context,
+                tool_request,
+                tool_state,
+                history=target_history,
+                use_cached_job=use_cached_jobs,
+                rerun_remap_job_id=rerun_remap_job_id,
+            )
+            tool_request.state = ToolRequest.states.SUBMITTED
+            sa_session.add(tool_request)
+            with transaction(sa_session):
+                sa_session.commit()
+        except Exception as e:
+            log.exception("Problem here....")
+            tool_request.state = ToolRequest.states.FAILED
+            tool_request.state_message = str(e)
+            sa_session.add(tool_request)
+            with transaction(sa_session):
+                sa_session.commit()
+
+    def _context(self, tool_request: ToolRequest, request: QueueJobs) -> WorkRequestContext:
+        user = self.user_manager.by_id(request.user.user_id)
+        target_history = tool_request.history
+        trans = WorkRequestContext(
+            self.app,
+            user,
+            history=target_history,
+        )
+        return trans
+
+    def _tool_request(self, tool_request_id: int) -> ToolRequest:
+        sa_session = self.app.model.context
+        tool_request: ToolRequest = cast(ToolRequest, sa_session.query(ToolRequest).get(tool_request_id))
+        if tool_request is None:
+            raise Exception(f"Problem fetching request with ID {tool_request_id}")
+        return tool_request
diff --git a/lib/galaxy/managers/landing.py b/lib/galaxy/managers/landing.py
index 2138c0c81ca2..ed7a8fdea533 100644
--- a/lib/galaxy/managers/landing.py
+++ b/lib/galaxy/managers/landing.py
@@ -29,23 +29,42 @@
     WorkflowLandingRequest,
 )
 from galaxy.security.idencoding import IdEncodingHelper
+from galaxy.structured_app import MinimalManagerApp
+from galaxy.tool_util.parameters import (
+    landing_decode,
+    LandingRequestToolState,
+)
 from galaxy.util import safe_str_cmp
 from .context import ProvidesUserContext
+from .tools import (
+    get_tool_from_toolbox,
+    ToolRunReference,
+)
 
 LandingRequestModel = Union[ToolLandingRequestModel, WorkflowLandingRequestModel]
 
 
 class LandingRequestManager:
 
-    def __init__(self, sa_session: galaxy_scoped_session, security: IdEncodingHelper):
+    def __init__(self, sa_session: galaxy_scoped_session, security: IdEncodingHelper, app: MinimalManagerApp):
         self.sa_session = sa_session
         self.security = security
+        self.app = app
 
     def create_tool_landing_request(self, payload: CreateToolLandingRequestPayload) -> ToolLandingRequest:
+        tool_id = payload.tool_id
+        tool_version = payload.tool_version
+        request_state = payload.request_state
+
+        ref = ToolRunReference(tool_id=tool_id, tool_version=tool_version, tool_uuid=None)
+        tool = get_tool_from_toolbox(self.app.toolbox, ref)
+        landing_request_state = LandingRequestToolState(request_state or {})
+        internal_landing_request_state = landing_decode(landing_request_state, tool, self.security.decode_id)
+
         model = ToolLandingRequestModel()
-        model.tool_id = payload.tool_id
-        model.tool_version = payload.tool_version
-        model.request_state = payload.request_state
+        model.tool_id = tool_id
+        model.tool_version = tool_version
+        model.request_state = internal_landing_request_state.input_state
         model.uuid = uuid4()
         model.client_secret = payload.client_secret
         self._save(model)
diff --git a/lib/galaxy/managers/tools.py b/lib/galaxy/managers/tools.py
index c6dbe471dc84..fa4c42eadefd 100644
--- a/lib/galaxy/managers/tools.py
+++ b/lib/galaxy/managers/tools.py
@@ -1,5 +1,6 @@
 import logging
 from typing import (
+    NamedTuple,
     Optional,
     TYPE_CHECKING,
     Union,
@@ -16,8 +17,10 @@
     model,
 )
 from galaxy.exceptions import DuplicatedIdentifierException
+from galaxy.managers.context import ProvidesUserContext
 from galaxy.model import DynamicTool
 from galaxy.tool_util.cwl import tool_proxy
+from galaxy.tools import Tool
 from .base import (
     ModelManager,
     raise_filter_err,
@@ -30,6 +33,30 @@
     from galaxy.managers.base import OrmFilterParsersType
 
 
+class ToolRunReference(NamedTuple):
+    tool_id: Optional[str]
+    tool_uuid: Optional[str]
+    tool_version: Optional[str]
+
+
+def get_tool_from_trans(trans: ProvidesUserContext, tool_ref: ToolRunReference) -> Tool:
+    return get_tool_from_toolbox(trans.app.toolbox, tool_ref)
+
+
+def get_tool_from_toolbox(toolbox, 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 = 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
+
+
 class DynamicToolManager(ModelManager):
     """Manages dynamic tools stored in Galaxy's database."""
 
diff --git a/lib/galaxy/managers/workflows.py b/lib/galaxy/managers/workflows.py
index de6a3a472f9d..31f6d9b784b5 100644
--- a/lib/galaxy/managers/workflows.py
+++ b/lib/galaxy/managers/workflows.py
@@ -14,13 +14,6 @@
 )
 
 import sqlalchemy
-import yaml
-from gxformat2 import (
-    from_galaxy_native,
-    ImporterGalaxyInterface,
-    ImportOptions,
-    python_to_workflow,
-)
 from gxformat2.abstract import from_dict
 from gxformat2.cytoscape import to_cytoscape
 from gxformat2.yaml import ordered_dump
@@ -113,6 +106,10 @@
     RawTextTerm,
 )
 from galaxy.work.context import WorkRequestContext
+from galaxy.workflow.format2 import (
+    convert_from_format2,
+    convert_to_format2,
+)
 from galaxy.workflow.modules import (
     module_factory,
     ToolModule,
@@ -609,10 +606,7 @@ def read_workflow_from_path(self, app, user, path, allow_in_directory=None) -> m
         workflow_class, as_dict, object_id = artifact_class(trans, as_dict, allow_in_directory=allow_in_directory)
         assert workflow_class == "GalaxyWorkflow"
         # Format 2 Galaxy workflow.
-        galaxy_interface = Format2ConverterGalaxyInterface()
-        import_options = ImportOptions()
-        import_options.deduplicate_subworkflows = True
-        as_dict = python_to_workflow(as_dict, galaxy_interface, workflow_directory=None, import_options=import_options)
+        as_dict = convert_from_format2(as_dict, None)
         raw_description = RawWorkflowDescription(as_dict, path)
         created_workflow = self.build_workflow_from_raw_description(trans, raw_description, WorkflowCreateOptions())
         return created_workflow.workflow
@@ -639,15 +633,7 @@ def normalize_workflow_format(self, trans, as_dict):
         workflow_class, as_dict, object_id = artifact_class(trans, as_dict)
         if workflow_class == "GalaxyWorkflow" or "yaml_content" in as_dict:
             # Format 2 Galaxy workflow.
-            galaxy_interface = Format2ConverterGalaxyInterface()
-            import_options = ImportOptions()
-            import_options.deduplicate_subworkflows = True
-            try:
-                as_dict = python_to_workflow(
-                    as_dict, galaxy_interface, workflow_directory=workflow_directory, import_options=import_options
-                )
-            except yaml.scanner.ScannerError as e:
-                raise exceptions.MalformedContents(str(e))
+            as_dict = convert_from_format2(as_dict, workflow_directory)
 
         return RawWorkflowDescription(as_dict, workflow_path)
 
@@ -912,8 +898,8 @@ def workflow_to_dict(self, trans, stored, style="export", version=None, history=
         fields like 'url' and 'url' and actual unencoded step ids instead of 'order_index'.
         """
 
-        def to_format_2(wf_dict, **kwds):
-            return from_galaxy_native(wf_dict, None, **kwds)
+        def to_format_2(wf_dict, json_wrapper: bool):
+            return convert_to_format2(wf_dict, json_wrapper=json_wrapper)
 
         if version == "":
             version = None
@@ -934,7 +920,7 @@ def to_format_2(wf_dict, **kwds):
             wf_dict = self._workflow_to_dict_preview(trans, workflow=workflow)
         elif style == "format2":
             wf_dict = self._workflow_to_dict_export(trans, stored, workflow=workflow)
-            wf_dict = to_format_2(wf_dict)
+            wf_dict = to_format_2(wf_dict, json_wrapper=False)
         elif style == "format2_wrapped_yaml":
             wf_dict = self._workflow_to_dict_export(trans, stored, workflow=workflow)
             wf_dict = to_format_2(wf_dict, json_wrapper=True)
@@ -984,7 +970,7 @@ def store_workflow_to_path(self, workflow_path, stored_workflow, workflow, **kwd
                 ordered_dump(abstract_dict, f)
             else:
                 wf_dict = self._workflow_to_dict_export(trans, stored_workflow, workflow=workflow)
-                wf_dict = from_galaxy_native(wf_dict, None, json_wrapper=True)
+                wf_dict = convert_to_format2(wf_dict, json_wrapper=True)
                 f.write(wf_dict["yaml_content"])
 
     def _workflow_to_dict_run(self, trans, stored, workflow, history=None):
@@ -2105,13 +2091,6 @@ def __init__(self, as_dict, workflow_path=None):
         self.workflow_path = workflow_path
 
 
-class Format2ConverterGalaxyInterface(ImporterGalaxyInterface):
-    def import_workflow(self, workflow, **kwds):
-        raise NotImplementedError(
-            "Direct format 2 import of nested workflows is not yet implemented, use bioblend client."
-        )
-
-
 def _get_stored_workflow(session, workflow_uuid, workflow_id, by_stored_id):
     stmt = select(StoredWorkflow)
     if workflow_uuid is not None:
diff --git a/lib/galaxy/schema/jobs.py b/lib/galaxy/schema/jobs.py
index ec7a971a3614..e2d131783686 100644
--- a/lib/galaxy/schema/jobs.py
+++ b/lib/galaxy/schema/jobs.py
@@ -82,6 +82,19 @@ class JobOutputAssociation(JobAssociation):
     )
 
 
+class JobOutputCollectionAssociation(Model):
+    name: str = Field(
+        default=...,
+        title="name",
+        description="Name of the job parameter.",
+    )
+    dataset_collection_instance: EncodedDataItemSourceId = Field(
+        default=...,
+        title="dataset_collection_instance",
+        description="Reference to the associated item.",
+    )
+
+
 class ReportJobErrorPayload(Model):
     dataset_id: DecodedDatabaseIdField = Field(
         default=...,
diff --git a/lib/galaxy/schema/schema.py b/lib/galaxy/schema/schema.py
index f3904dc3d35e..ff173021fad2 100644
--- a/lib/galaxy/schema/schema.py
+++ b/lib/galaxy/schema/schema.py
@@ -1539,6 +1539,7 @@ class JobIndexQueryPayload(Model):
     workflow_id: Optional[DecodedDatabaseIdField] = None
     invocation_id: Optional[DecodedDatabaseIdField] = None
     implicit_collection_jobs_id: Optional[DecodedDatabaseIdField] = None
+    tool_request_id: Optional[DecodedDatabaseIdField] = None
     order_by: JobIndexSortByEnum = JobIndexSortByEnum.update_time
     search: Optional[str] = None
     limit: int = 500
diff --git a/lib/galaxy/schema/tasks.py b/lib/galaxy/schema/tasks.py
index d83640f52ffa..846cecb42399 100644
--- a/lib/galaxy/schema/tasks.py
+++ b/lib/galaxy/schema/tasks.py
@@ -124,3 +124,16 @@ class ComputeDatasetHashTaskRequest(Model):
 
 class PurgeDatasetsTaskRequest(Model):
     dataset_ids: List[int]
+
+
+class ToolSource(Model):
+    raw_tool_source: str
+    tool_dir: str
+
+
+class QueueJobs(Model):
+    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
+    rerun_remap_job_id: Optional[int]  # link to a job to rerun & remap
diff --git a/lib/galaxy/tool_util/parameters/__init__.py b/lib/galaxy/tool_util/parameters/__init__.py
index 4a54ba0a8373..57aa02627132 100644
--- a/lib/galaxy/tool_util/parameters/__init__.py
+++ b/lib/galaxy/tool_util/parameters/__init__.py
@@ -5,6 +5,8 @@
     encode,
     encode_test,
     fill_static_defaults,
+    landing_decode,
+    landing_encode,
 )
 from .factory import (
     from_input_source,
@@ -38,7 +40,9 @@
     FloatParameterModel,
     HiddenParameterModel,
     IntegerParameterModel,
+    is_optional,
     LabelValue,
+    RawStateDict,
     RepeatParameterModel,
     RulesParameterModel,
     SelectParameterModel,
@@ -49,15 +53,21 @@
     ToolParameterT,
     validate_against_model,
     validate_internal_job,
+    validate_internal_landing_request,
     validate_internal_request,
     validate_internal_request_dereferenced,
+    validate_landing_request,
     validate_request,
     validate_test_case,
     validate_workflow_step,
     validate_workflow_step_linked,
+    ValidationFunctionT,
 )
 from .state import (
+    HasToolParameters,
     JobInternalToolState,
+    LandingRequestInternalToolState,
+    LandingRequestToolState,
     RequestInternalDereferencedToolState,
     RequestInternalToolState,
     RequestToolState,
@@ -113,10 +123,15 @@
     "ConditionalParameterModel",
     "ConditionalWhen",
     "RepeatParameterModel",
+    "RawStateDict",
+    "ValidationFunctionT",
+    "is_optional",
     "validate_against_model",
     "validate_internal_job",
+    "validate_internal_landing_request",
     "validate_internal_request",
     "validate_internal_request_dereferenced",
+    "validate_landing_request",
     "validate_request",
     "validate_test_case",
     "validate_workflow_step",
@@ -125,11 +140,14 @@
     "ToolState",
     "TestCaseToolState",
     "ToolParameterT",
+    "HasToolParameters",
     "to_json_schema_string",
     "test_case_state",
     "RequestToolState",
     "RequestInternalToolState",
     "RequestInternalDereferencedToolState",
+    "LandingRequestToolState",
+    "LandingRequestInternalToolState",
     "flat_state_path",
     "keys_starting_with",
     "visit_input_values",
@@ -139,6 +157,8 @@
     "encode",
     "encode_test",
     "fill_static_defaults",
+    "landing_decode",
+    "landing_encode",
     "dereference",
     "WorkflowStepToolState",
     "WorkflowStepLinkedToolState",
diff --git a/lib/galaxy/tool_util/parameters/_types.py b/lib/galaxy/tool_util/parameters/_types.py
index 2b97ee16c200..64fa9a3274fc 100644
--- a/lib/galaxy/tool_util/parameters/_types.py
+++ b/lib/galaxy/tool_util/parameters/_types.py
@@ -6,6 +6,7 @@
 """
 
 from typing import (
+    Any,
     cast,
     List,
     Optional,
@@ -15,6 +16,7 @@
 
 # https://stackoverflow.com/questions/56832881/check-if-a-field-is-typing-optional
 from typing_extensions import (
+    Annotated,
     get_args,
     get_origin,
 )
@@ -46,3 +48,12 @@ def cast_as_type(arg) -> Type:
 
 def is_optional(field) -> bool:
     return get_origin(field) is Union and type(None) in get_args(field)
+
+
+def expand_annotation(field: Type, new_annotations: List[Any]) -> Type:
+    is_annotation = get_origin(field) is Annotated
+    if is_annotation:
+        args = get_args(field)  # noqa: F841
+        return Annotated[tuple([args[0], *args[1:], *new_annotations])]  # type: ignore[return-value]
+    else:
+        return Annotated[tuple([field, *new_annotations])]  # type: ignore[return-value]
diff --git a/lib/galaxy/tool_util/parameters/convert.py b/lib/galaxy/tool_util/parameters/convert.py
index 9484cc6c7e71..63dbb9ab58b9 100644
--- a/lib/galaxy/tool_util/parameters/convert.py
+++ b/lib/galaxy/tool_util/parameters/convert.py
@@ -40,12 +40,15 @@
 )
 from .state import (
     JobInternalToolState,
+    LandingRequestInternalToolState,
+    LandingRequestToolState,
     RequestInternalDereferencedToolState,
     RequestInternalToolState,
     RequestToolState,
     TestCaseToolState,
 )
 from .visitor import (
+    Callback,
     validate_explicit_conditional_test_value,
     visit_input_values,
     VISITOR_NO_REPLACEMENT,
@@ -54,40 +57,22 @@
 log = logging.getLogger(__name__)
 
 
+DecodeFunctionT = Callable[[str], int]
+EncodeFunctionT = Callable[[int], str]
+DereferenceCallable = Callable[[DataRequestUri], DataRequestInternalHda]
+# interfaces for adapting test data dictionaries to tool request dictionaries
+# e.g. {class: File, path: foo.bed} => {src: hda, id: ab1235cdfea3}
+AdaptDatasets = Callable[[JsonTestDatasetDefDict], DataRequestHda]
+AdaptCollections = Callable[[JsonTestCollectionDefDict], DataCollectionRequest]
+
+
 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)."""
+    """Prepare an internal representation of tool state (request_internal) for storing in the database."""
 
     external_state.validate(input_models)
-
-    def decode_src_dict(src_dict: dict):
-        if "id" in src_dict:
-            decoded_dict = src_dict.copy()
-            decoded_dict["id"] = decode_id(src_dict["id"])
-            return decoded_dict
-        else:
-            return src_dict
-
-    def decode_callback(parameter: ToolParameterT, value: Any):
-        if parameter.parameter_type == "gx_data":
-            if value is None:
-                return VISITOR_NO_REPLACEMENT
-            data_parameter = cast(DataParameterModel, parameter)
-            if data_parameter.multiple:
-                assert isinstance(value, list), str(value)
-                return list(map(decode_src_dict, value))
-            else:
-                assert isinstance(value, dict), str(value)
-                return decode_src_dict(value)
-        elif parameter.parameter_type == "gx_data_collection":
-            if value is None:
-                return VISITOR_NO_REPLACEMENT
-            assert isinstance(value, dict), str(value)
-            return decode_src_dict(value)
-        else:
-            return VISITOR_NO_REPLACEMENT
-
+    decode_callback = _decode_callback_for(decode_id)
     internal_state_dict = visit_input_values(
         input_models,
         external_state,
@@ -100,36 +85,14 @@ def decode_callback(parameter: ToolParameterT, value: Any):
 
 
 def encode(
-    external_state: RequestInternalToolState, input_models: ToolParameterBundle, encode_id: Callable[[int], str]
+    internal_state: RequestInternalToolState, input_models: ToolParameterBundle, encode_id: EncodeFunctionT
 ) -> RequestToolState:
-    """Prepare an external representation of tool state (request) for storing in the database (request_internal)."""
-
-    def encode_src_dict(src_dict: dict):
-        if "id" in src_dict:
-            encoded_dict = src_dict.copy()
-            encoded_dict["id"] = encode_id(src_dict["id"])
-            return encoded_dict
-        else:
-            return src_dict
-
-    def encode_callback(parameter: ToolParameterT, value: Any):
-        if parameter.parameter_type == "gx_data":
-            data_parameter = cast(DataParameterModel, parameter)
-            if data_parameter.multiple:
-                assert isinstance(value, list), str(value)
-                return list(map(encode_src_dict, value))
-            else:
-                assert isinstance(value, dict), str(value)
-                return encode_src_dict(value)
-        elif parameter.parameter_type == "gx_data_collection":
-            assert isinstance(value, dict), str(value)
-            return encode_src_dict(value)
-        else:
-            return VISITOR_NO_REPLACEMENT
+    """Prepare an external representation of tool state (request) from persisted state in the database (request_internal)."""
 
+    encode_callback = _encode_callback_for(encode_id)
     request_state_dict = visit_input_values(
         input_models,
-        external_state,
+        internal_state,
         encode_callback,
     )
     request_state = RequestToolState(request_state_dict)
@@ -137,7 +100,38 @@ def encode_callback(parameter: ToolParameterT, value: Any):
     return request_state
 
 
-DereferenceCallable = Callable[[DataRequestUri], DataRequestInternalHda]
+def landing_decode(
+    external_state: LandingRequestToolState, input_models: ToolParameterBundle, decode_id: Callable[[str], int]
+) -> LandingRequestInternalToolState:
+    """Prepare an external representation of tool state (request) for storing in the database (request_internal)."""
+
+    external_state.validate(input_models)
+    decode_callback = _decode_callback_for(decode_id)
+    internal_state_dict = visit_input_values(
+        input_models,
+        external_state,
+        decode_callback,
+    )
+
+    internal_request_state = LandingRequestInternalToolState(internal_state_dict)
+    internal_request_state.validate(input_models)
+    return internal_request_state
+
+
+def landing_encode(
+    internal_state: LandingRequestInternalToolState, input_models: ToolParameterBundle, encode_id: EncodeFunctionT
+) -> LandingRequestToolState:
+    """Prepare an external representation of tool state (request) for storing in the database (request_internal)."""
+
+    encode_callback = _encode_callback_for(encode_id)
+    request_state_dict = visit_input_values(
+        input_models,
+        internal_state,
+        encode_callback,
+    )
+    request_state = LandingRequestToolState(request_state_dict)
+    request_state.validate(input_models)
+    return request_state
 
 
 def dereference(
@@ -177,12 +171,6 @@ def dereference_callback(parameter: ToolParameterT, value: Any):
     return request_state
 
 
-# interfaces for adapting test data dictionaries to tool request dictionaries
-# e.g. {class: File, path: foo.bed} => {src: hda, id: ab1235cdfea3}
-AdaptDatasets = Callable[[JsonTestDatasetDefDict], DataRequestHda]
-AdaptCollections = Callable[[JsonTestCollectionDefDict], DataCollectionRequest]
-
-
 def encode_test(
     test_case_state: TestCaseToolState,
     input_models: ToolParameterBundle,
@@ -324,7 +312,6 @@ def _fill_default_for(tool_state: Dict[str, Any], parameter: ToolParameterT) ->
         )
         test_value = validate_explicit_conditional_test_value(test_parameter_name, explicit_test_value)
         when = _select_which_when(conditional, test_value, conditional_state)
-        test_parameter = conditional.test_parameter
         _fill_default_for(conditional_state, test_parameter)
         _fill_defaults(conditional_state, when)
     elif parameter_type in ["gx_repeat"]:
@@ -358,3 +345,63 @@ def _select_which_when(
         raise Exception(
             f"Invalid conditional test value ({test_value}) for parameter ({conditional.test_parameter.name})"
         )
+
+
+def _encode_callback_for(encode_id: EncodeFunctionT) -> Callback:
+
+    def encode_src_dict(src_dict: dict):
+        if "id" in src_dict:
+            encoded_dict = src_dict.copy()
+            encoded_dict["id"] = encode_id(src_dict["id"])
+            return encoded_dict
+        else:
+            return src_dict
+
+    def encode_callback(parameter: ToolParameterT, value: Any):
+        if parameter.parameter_type == "gx_data":
+            data_parameter = cast(DataParameterModel, parameter)
+            if data_parameter.multiple:
+                assert isinstance(value, list), str(value)
+                return list(map(encode_src_dict, value))
+            else:
+                assert isinstance(value, dict), str(value)
+                return encode_src_dict(value)
+        elif parameter.parameter_type == "gx_data_collection":
+            assert isinstance(value, dict), str(value)
+            return encode_src_dict(value)
+        else:
+            return VISITOR_NO_REPLACEMENT
+
+    return encode_callback
+
+
+def _decode_callback_for(decode_id: DecodeFunctionT) -> Callback:
+
+    def decode_src_dict(src_dict: dict):
+        if "id" in src_dict:
+            decoded_dict = src_dict.copy()
+            decoded_dict["id"] = decode_id(src_dict["id"])
+            return decoded_dict
+        else:
+            return src_dict
+
+    def decode_callback(parameter: ToolParameterT, value: Any):
+        if parameter.parameter_type == "gx_data":
+            if value is None:
+                return VISITOR_NO_REPLACEMENT
+            data_parameter = cast(DataParameterModel, parameter)
+            if data_parameter.multiple:
+                assert isinstance(value, list), str(value)
+                return list(map(decode_src_dict, value))
+            else:
+                assert isinstance(value, dict), str(value)
+                return decode_src_dict(value)
+        elif parameter.parameter_type == "gx_data_collection":
+            if value is None:
+                return VISITOR_NO_REPLACEMENT
+            assert isinstance(value, dict), str(value)
+            return decode_src_dict(value)
+        else:
+            return VISITOR_NO_REPLACEMENT
+
+    return decode_callback
diff --git a/lib/galaxy/tool_util/parameters/factory.py b/lib/galaxy/tool_util/parameters/factory.py
index e200b67aeb0e..932195effb9d 100644
--- a/lib/galaxy/tool_util/parameters/factory.py
+++ b/lib/galaxy/tool_util/parameters/factory.py
@@ -14,7 +14,19 @@
     PagesSource,
     ToolSource,
 )
-from galaxy.tool_util.parser.util import parse_profile_version
+from galaxy.tool_util.parser.parameter_validators import (
+    EmptyFieldParameterValidatorModel,
+    ExpressionParameterValidatorModel,
+    InRangeParameterValidatorModel,
+    LengthParameterValidatorModel,
+    NoOptionsParameterValidatorModel,
+    RegexParameterValidatorModel,
+    static_validators,
+)
+from galaxy.tool_util.parser.util import (
+    parse_profile_version,
+    text_input_is_optional,
+)
 from galaxy.util import string_as_bool
 from .models import (
     BaseUrlParameterModel,
@@ -42,10 +54,13 @@
     HiddenParameterModel,
     IntegerParameterModel,
     LabelValue,
+    NumberCompatiableValidators,
     RepeatParameterModel,
     RulesParameterModel,
     SectionParameterModel,
+    SelectCompatiableValidators,
     SelectParameterModel,
+    TextCompatiableValidators,
     TextParameterModel,
     ToolParameterBundle,
     ToolParameterBundleModel,
@@ -82,7 +97,23 @@ def _from_input_source_galaxy(input_source: InputSource, profile: float) -> Tool
                 int_value = None
             else:
                 raise ParameterDefinitionError()
-            return IntegerParameterModel(name=input_source.parse_name(), optional=optional, value=int_value)
+            static_validator_models = static_validators(input_source.parse_validators())
+            int_validators: List[NumberCompatiableValidators] = []
+            for static_validator in static_validator_models:
+                if static_validator.type == "in_range":
+                    int_validators.append(cast(InRangeParameterValidatorModel, static_validator))
+            min_raw = input_source.get("min", None)
+            max_raw = input_source.get("max", None)
+            min_int = int(min_raw) if min_raw is not None else None
+            max_int = int(max_raw) if max_raw is not None else None
+            return IntegerParameterModel(
+                name=input_source.parse_name(),
+                optional=optional,
+                value=int_value,
+                min=min_int,
+                max=max_int,
+                validators=int_validators,
+            )
         elif param_type == "boolean":
             nullable = input_source.parse_optional()
             value = input_source.get_bool_or_none("checked", None if nullable else False)
@@ -92,10 +123,12 @@ def _from_input_source_galaxy(input_source: InputSource, profile: float) -> Tool
                 value=value,
             )
         elif param_type == "text":
-            optional = input_source.parse_optional()
+            optional, optionality_inferred = text_input_is_optional(input_source)
+            text_validators: List[TextCompatiableValidators] = _text_validators(input_source)
             return TextParameterModel(
                 name=input_source.parse_name(),
                 optional=optional,
+                validators=text_validators,
             )
         elif param_type == "float":
             optional = input_source.parse_optional()
@@ -107,18 +140,32 @@ def _from_input_source_galaxy(input_source: InputSource, profile: float) -> Tool
                 float_value = None
             else:
                 raise ParameterDefinitionError()
+            static_validator_models = static_validators(input_source.parse_validators())
+            float_validators: List[NumberCompatiableValidators] = []
+            for static_validator in static_validator_models:
+                if static_validator.type == "in_range":
+                    float_validators.append(cast(InRangeParameterValidatorModel, static_validator))
+            min_raw = input_source.get("min", None)
+            max_raw = input_source.get("max", None)
+            min_float = float(min_raw) if min_raw is not None else None
+            max_float = float(max_raw) if max_raw is not None else None
             return FloatParameterModel(
                 name=input_source.parse_name(),
                 optional=optional,
                 value=float_value,
+                min=min_float,
+                max=max_float,
+                validators=float_validators,
             )
         elif param_type == "hidden":
             optional = input_source.parse_optional()
             value = input_source.get("value")
+            hidden_validators: List[TextCompatiableValidators] = _text_validators(input_source)
             return HiddenParameterModel(
                 name=input_source.parse_name(),
                 optional=optional,
                 value=value,
+                validators=hidden_validators,
             )
         elif param_type == "color":
             optional = input_source.parse_optional()
@@ -158,11 +205,17 @@ def _from_input_source_galaxy(input_source: InputSource, profile: float) -> Tool
                 options = []
                 for option_label, option_value, selected in input_source.parse_static_options():
                     options.append(LabelValue(label=option_label, value=option_value, selected=selected))
+            static_validator_models = static_validators(input_source.parse_validators())
+            select_validators: List[SelectCompatiableValidators] = []
+            for static_validator in static_validator_models:
+                if static_validator.type == "no_options":
+                    select_validators.append(cast(NoOptionsParameterValidatorModel, static_validator))
             return SelectParameterModel(
                 name=input_source.parse_name(),
                 optional=optional,
                 options=options,
                 multiple=multiple,
+                validators=select_validators,
             )
         elif param_type == "drill_down":
             multiple = input_source.get_bool("multiple", False)
@@ -206,8 +259,10 @@ def _from_input_source_galaxy(input_source: InputSource, profile: float) -> Tool
                 multiple=multiple,
             )
         elif param_type == "directory_uri":
+            directory_uri_validators: List[TextCompatiableValidators] = _text_validators(input_source)
             return DirectoryUriParameterModel(
                 name=input_source.parse_name(),
+                validators=directory_uri_validators,
             )
         else:
             raise UnknownParameterTypeError(f"Unknown Galaxy parameter type {param_type}")
@@ -221,7 +276,12 @@ def _from_input_source_galaxy(input_source: InputSource, profile: float) -> Tool
         default_test_value = cond_test_parameter_default_value(test_parameter)
         for value, case_inputs_sources in input_source.parse_when_input_sources():
             if isinstance(test_parameter, BooleanParameterModel):
-                # TODO: investigate truevalue/falsevalue when...
+                true_value = test_param_input_source.get("truevalue")
+                false_value = test_param_input_source.get("falsevalue")
+                if isinstance(value, str) and value == true_value:
+                    value = True
+                elif isinstance(value, str) and value == false_value:
+                    value = False
                 typed_value = string_as_bool(value)
             else:
                 typed_value = value
@@ -304,6 +364,21 @@ def _simple_cwl_type_to_model(simple_type: str, input_source: CwlInputSource):
     )
 
 
+def _text_validators(input_source: InputSource) -> List[TextCompatiableValidators]:
+    static_validator_models = static_validators(input_source.parse_validators())
+    text_validators: List[TextCompatiableValidators] = []
+    for static_validator in static_validator_models:
+        if static_validator.type == "length":
+            text_validators.append(cast(LengthParameterValidatorModel, static_validator))
+        elif static_validator.type == "regex":
+            text_validators.append(cast(RegexParameterValidatorModel, static_validator))
+        elif static_validator.type == "expression":
+            text_validators.append(cast(ExpressionParameterValidatorModel, static_validator))
+        elif static_validator.type == "empty_field":
+            text_validators.append(cast(EmptyFieldParameterValidatorModel, static_validator))
+    return text_validators
+
+
 def _from_input_source_cwl(input_source: CwlInputSource) -> ToolParameterT:
     schema_salad_field = input_source.field
     if schema_salad_field is None:
diff --git a/lib/galaxy/tool_util/parameters/models.py b/lib/galaxy/tool_util/parameters/models.py
index 11957c37099a..3081130cb8dc 100644
--- a/lib/galaxy/tool_util/parameters/models.py
+++ b/lib/galaxy/tool_util/parameters/models.py
@@ -11,11 +11,14 @@
     Mapping,
     NamedTuple,
     Optional,
+    Sequence,
     Type,
+    TypeVar,
     Union,
 )
 
 from pydantic import (
+    AfterValidator,
     AnyUrl,
     BaseModel,
     ConfigDict,
@@ -44,9 +47,19 @@
     JsonTestCollectionDefDict,
     JsonTestDatasetDefDict,
 )
+from galaxy.tool_util.parser.parameter_validators import (
+    EmptyFieldParameterValidatorModel,
+    ExpressionParameterValidatorModel,
+    InRangeParameterValidatorModel,
+    LengthParameterValidatorModel,
+    NoOptionsParameterValidatorModel,
+    RegexParameterValidatorModel,
+    StaticValidatorModel,
+)
 from ._types import (
     cast_as_type,
-    is_optional,
+    expand_annotation,
+    is_optional as is_python_type_optional,
     list_type,
     optional,
     optional_if_needed,
@@ -54,7 +67,6 @@
 )
 
 # TODO:
-# - implement job vs request...
 # - implement data_ref on rules and implement some cross model validation
 
 # + request: Return info needed to build request pydantic model at runtime.
@@ -64,12 +76,17 @@
     "request",
     "request_internal",
     "request_internal_dereferenced",
+    "landing_request",
+    "landing_request_internal",
     "job_internal",
     "test_case_xml",
     "workflow_step",
     "workflow_step_linked",
 ]
 
+DEFAULT_MODEL_NAME = "DynamicModelForTool"
+RawStateDict = Dict[str, Any]
+
 
 # could be made more specific - validators need to be classmethod
 ValidatorDictT = Dict[str, Callable]
@@ -135,7 +152,7 @@ def dynamic_model_information_from_py_type(
     if requires_value is None:
         requires_value = param_model.request_requires_value
     initialize = ... if requires_value else None
-    py_type_is_optional = is_optional(py_type)
+    py_type_is_optional = is_python_type_optional(py_type)
     validators = validators or {}
     if not py_type_is_optional and not requires_value:
         validators["not_null"] = field_validator(name)(Validators.validate_not_none)
@@ -174,18 +191,64 @@ class LabelValue(BaseModel):
     selected: bool
 
 
+TextCompatiableValidators = Union[
+    LengthParameterValidatorModel,
+    RegexParameterValidatorModel,
+    ExpressionParameterValidatorModel,
+    EmptyFieldParameterValidatorModel,
+]
+
+
+def pydantic_to_galaxy_type(value: Any) -> Any:
+    """We use advanced Pydantic types like URL but the Galaxy validators only expect strings for these."""
+    if isinstance(value, AnyUrl):
+        return str(value)
+
+    return value
+
+
+VT = TypeVar("VT", bound=StaticValidatorModel)
+
+
+def decorate_type_with_validators_if_needed(py_type: Type, static_validator_models: Sequence[VT]) -> Type:
+    pydantic_validator = pydantic_validator_for(static_validator_models)
+    if pydantic_validator:
+        return expand_annotation(py_type, [pydantic_validator])
+    else:
+        return py_type
+
+
+# Looks like Annotated only work with one PlainValidator so condensing all static validators
+# into a single PlainValidator for pydantic.
+def pydantic_validator_for(static_validator_models: Sequence[VT]) -> Optional[AfterValidator]:
+
+    if static_validator_models:
+
+        def validator(v: Any) -> Any:
+            gx_val = pydantic_to_galaxy_type(v)
+
+            for static_validator_model in static_validator_models:
+                static_validator_model.statically_validate(gx_val)
+            return v
+
+        return AfterValidator(validator)
+    else:
+        return None
+
+
 class TextParameterModel(BaseGalaxyToolParameterModelDefinition):
     parameter_type: Literal["gx_text"] = "gx_text"
     area: bool = False
     default_value: Optional[str] = Field(default=None, alias="value")
     default_options: List[LabelValue] = []
+    validators: List[TextCompatiableValidators] = []
 
     @property
     def py_type(self) -> Type:
         return optional_if_needed(StrictStr, self.optional)
 
     def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
-        py_type = self.py_type
+        py_type = decorate_type_with_validators_if_needed(self.py_type, self.validators)
         if state_representation == "workflow_step_linked":
             py_type = allow_connected_value(py_type)
         requires_value = self.request_requires_value
@@ -198,12 +261,16 @@ def request_requires_value(self) -> bool:
         return False
 
 
+NumberCompatiableValidators = Union[InRangeParameterValidatorModel,]
+
+
 class IntegerParameterModel(BaseGalaxyToolParameterModelDefinition):
     parameter_type: Literal["gx_integer"] = "gx_integer"
     optional: bool
     value: Optional[int] = None
     min: Optional[int] = None
     max: Optional[int] = None
+    validators: List[NumberCompatiableValidators] = []
 
     @property
     def py_type(self) -> Type:
@@ -211,11 +278,17 @@ def py_type(self) -> Type:
 
     def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
         py_type = self.py_type
+        validators = self.validators[:]
+        if self.min is not None or self.max is not None:
+            validators.append(InRangeParameterValidatorModel(min=self.min, max=self.max, implicit=True))
+        py_type = decorate_type_with_validators_if_needed(py_type, validators)
         if state_representation == "workflow_step_linked":
             py_type = allow_connected_value(py_type)
         requires_value = self.request_requires_value
         if state_representation == "job_internal":
             requires_value = True
+        elif _is_landing_request(state_representation):
+            requires_value = False
         return dynamic_model_information_from_py_type(self, py_type, requires_value=requires_value)
 
     @property
@@ -228,6 +301,7 @@ class FloatParameterModel(BaseGalaxyToolParameterModelDefinition):
     value: Optional[float] = None
     min: Optional[float] = None
     max: Optional[float] = None
+    validators: List[NumberCompatiableValidators] = []
 
     @property
     def py_type(self) -> Type:
@@ -237,7 +311,16 @@ def pydantic_template(self, state_representation: StateRepresentationT) -> Dynam
         py_type = self.py_type
         if state_representation == "workflow_step_linked":
             py_type = allow_connected_value(py_type)
-        return dynamic_model_information_from_py_type(self, py_type)
+        requires_value = self.request_requires_value
+        if state_representation == "job_internal":
+            requires_value = True
+        elif _is_landing_request(state_representation):
+            requires_value = False
+        validators = self.validators[:]
+        if self.min is not None or self.max is not None:
+            validators.append(InRangeParameterValidatorModel(min=self.min, max=self.max, implicit=True))
+        py_type = decorate_type_with_validators_if_needed(py_type, validators)
+        return dynamic_model_information_from_py_type(self, py_type, requires_value=requires_value)
 
     @property
     def request_requires_value(self) -> bool:
@@ -402,10 +485,19 @@ def py_type_test_case(self) -> Type:
     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)
+        if state_representation == "landing_request":
+            return allow_batching(
+                dynamic_model_information_from_py_type(self, self.py_type, requires_value=False), BatchDataInstance
+            )
         elif state_representation == "request_internal":
             return allow_batching(
                 dynamic_model_information_from_py_type(self, self.py_type_internal), BatchDataInstanceInternal
             )
+        elif state_representation == "landing_request_internal":
+            return allow_batching(
+                dynamic_model_information_from_py_type(self, self.py_type_internal, requires_value=False),
+                BatchDataInstanceInternal,
+            )
         elif state_representation == "request_internal_dereferenced":
             return allow_batching(
                 dynamic_model_information_from_py_type(self, self.py_type_internal_dereferenced),
@@ -452,6 +544,12 @@ def py_type_internal(self) -> Type:
     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 == "landing_request":
+            return allow_batching(dynamic_model_information_from_py_type(self, self.py_type, requires_value=False))
+        elif state_representation == "landing_request_internal":
+            return allow_batching(
+                dynamic_model_information_from_py_type(self, self.py_type_internal, requires_value=False)
+            )
         elif state_representation in ["request_internal", "request_internal_dereferenced"]:
             return allow_batching(dynamic_model_information_from_py_type(self, self.py_type_internal))
         elif state_representation == "job_internal":
@@ -475,6 +573,7 @@ def request_requires_value(self) -> bool:
 class HiddenParameterModel(BaseGalaxyToolParameterModelDefinition):
     parameter_type: Literal["gx_hidden"] = "gx_hidden"
     value: Optional[str]
+    validators: List[TextCompatiableValidators] = []
 
     @property
     def py_type(self) -> Type:
@@ -483,6 +582,7 @@ def py_type(self) -> Type:
     def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
         py_type = self.py_type
         requires_value = not self.optional and self.value is None
+        py_type = decorate_type_with_validators_if_needed(py_type, self.validators)
         if state_representation == "workflow_step_linked":
             py_type = allow_connected_value(py_type)
         elif state_representation == "workflow_step" and not self.optional:
@@ -591,13 +691,21 @@ def request_requires_value(self) -> bool:
 
 class DirectoryUriParameterModel(BaseGalaxyToolParameterModelDefinition):
     parameter_type: Literal["gx_directory_uri"] = "gx_directory_uri"
+    validators: List[TextCompatiableValidators] = []
 
     @property
     def py_type(self) -> Type:
         return AnyUrl
 
     def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
-        return dynamic_model_information_from_py_type(self, self.py_type)
+        py_type = self.py_type
+        py_type = decorate_type_with_validators_if_needed(py_type, self.validators)
+        if state_representation == "workflow_step_linked":
+            py_type = allow_connected_value(py_type)
+        requires_value = self.request_requires_value
+        if _is_landing_request(state_representation):
+            requires_value = False
+        return dynamic_model_information_from_py_type(self, py_type, requires_value=requires_value)
 
     @property
     def request_requires_value(self) -> bool:
@@ -629,10 +737,14 @@ def request_requires_value(self) -> bool:
         return True
 
 
+SelectCompatiableValidators = Union[NoOptionsParameterValidatorModel,]
+
+
 class SelectParameterModel(BaseGalaxyToolParameterModelDefinition):
     parameter_type: Literal["gx_select"] = "gx_select"
     options: Optional[List[LabelValue]] = None
     multiple: bool
+    validators: List[SelectCompatiableValidators]
 
     @staticmethod
     def split_str(cls, data: Any) -> Any:
@@ -669,28 +781,30 @@ def py_type_workflow_step(self) -> Type:
         return optional(self.py_type_if_required())
 
     def pydantic_template(self, state_representation: StateRepresentationT) -> DynamicModelInformation:
+        validators = {}
+        requires_value = self.request_requires_value
+        py_type = None
         if state_representation == "workflow_step":
-            return dynamic_model_information_from_py_type(self, self.py_type_workflow_step, requires_value=False)
+            py_type = self.py_type_workflow_step
         elif state_representation == "workflow_step_linked":
             py_type = self.py_type_if_required(allow_connections=True)
-            return dynamic_model_information_from_py_type(
-                self, optional_if_needed(py_type, self.optional or self.multiple)
-            )
+            py_type = optional_if_needed(py_type, self.optional or self.multiple)
         elif state_representation == "test_case_xml":
             # in a YAML test case representation this can be string, in XML we are still expecting a comma separated string
             py_type = self.py_type_if_required(allow_connections=False)
             if self.multiple:
                 validators = {"from_string": field_validator(self.name, mode="before")(SelectParameterModel.split_str)}
-            else:
-                validators = {}
-            return dynamic_model_information_from_py_type(
-                self, optional_if_needed(py_type, self.optional), validators=validators
-            )
+            py_type = optional_if_needed(py_type, self.optional)
+        elif state_representation == "job_internal":
+            requires_value = True
+            py_type = self.py_type
         else:
-            requires_value = self.request_requires_value
-            if state_representation == "job_internal":
-                requires_value = True
-            return dynamic_model_information_from_py_type(self, self.py_type, requires_value=requires_value)
+            py_type = self.py_type
+
+        py_type = decorate_type_with_validators_if_needed(py_type, self.validators)
+        return dynamic_model_information_from_py_type(
+            self, py_type, validators=validators, requires_value=requires_value
+        )
 
     @property
     def has_selected_static_option(self):
@@ -1077,9 +1191,14 @@ def pydantic_template(self, state_representation: StateRepresentationT) -> Dynam
         instance_class: Type[BaseModel] = create_field_model(
             self.parameters, f"Repeat_{self.name}", state_representation
         )
+        min_length = self.min
+        max_length = self.max
         requires_value = self.request_requires_value
         if state_representation == "job_internal":
             requires_value = True
+        elif _is_landing_request(state_representation):
+            requires_value = False
+            min_length = 0  # in a landing request - parameters can be partially filled
 
         initialize_repeat: Any
         if requires_value:
@@ -1088,7 +1207,7 @@ def pydantic_template(self, state_representation: StateRepresentationT) -> Dynam
             initialize_repeat = None
 
         class RepeatType(RootModel):
-            root: List[instance_class] = Field(initialize_repeat, min_length=self.min, max_length=self.max)  # type: ignore[valid-type]
+            root: List[instance_class] = Field(initialize_repeat, min_length=min_length, max_length=max_length)  # type: ignore[valid-type]
 
         return DynamicModelInformation(
             self.name,
@@ -1339,6 +1458,14 @@ class ToolParameterModel(RootModel):
 CwlUnionParameterModel.model_rebuild()
 
 
+def is_optional(tool_parameter: ToolParameterT):
+    if isinstance(tool_parameter, BaseGalaxyToolParameterModelDefinition):
+        return tool_parameter.optional
+    else:
+        # refine CWL logic in CWL branch...
+        return False
+
+
 class ToolParameterBundle(Protocol):
     """An object having a dictionary of input models (i.e. a 'Tool')"""
 
@@ -1368,34 +1495,23 @@ def create_model_strict(*args, **kwd) -> Type[BaseModel]:
     return create_model(*args, __config__=model_config, **kwd)
 
 
-def create_request_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
-    return create_field_model(tool.parameters, name, "request")
-
-
-def create_request_internal_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
-    return create_field_model(tool.parameters, name, "request_internal")
-
-
-def create_request_internal_dereferenced_model(
-    tool: ToolParameterBundle, name: str = "DynamicModelForTool"
-) -> Type[BaseModel]:
-    return create_field_model(tool.parameters, name, "request_internal_dereferenced")
-
-
-def create_job_internal_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
-    return create_field_model(tool.parameters, name, "job_internal")
+def create_model_factory(state_representation: StateRepresentationT):
 
+    def create_method(tool: ToolParameterBundle, name: str = DEFAULT_MODEL_NAME) -> Type[BaseModel]:
+        return create_field_model(tool.parameters, name, state_representation)
 
-def create_test_case_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
-    return create_field_model(tool.parameters, name, "test_case_xml")
+    return create_method
 
 
-def create_workflow_step_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
-    return create_field_model(tool.parameters, name, "workflow_step")
-
-
-def create_workflow_step_linked_model(tool: ToolParameterBundle, name: str = "DynamicModelForTool") -> Type[BaseModel]:
-    return create_field_model(tool.parameters, name, "workflow_step_linked")
+create_request_model = create_model_factory("request")
+create_request_internal_model = create_model_factory("request_internal")
+create_request_internal_dereferenced_model = create_model_factory("request_internal_dereferenced")
+create_landing_request_model = create_model_factory("landing_request")
+create_landing_request_internal_model = create_model_factory("landing_request_internal")
+create_job_internal_model = create_model_factory("job_internal")
+create_test_case_model = create_model_factory("test_case_xml")
+create_workflow_step_model = create_model_factory("workflow_step")
+create_workflow_step_linked_model = create_model_factory("workflow_step_linked")
 
 
 def create_field_model(
@@ -1423,6 +1539,10 @@ def create_field_model(
     return pydantic_model
 
 
+def _is_landing_request(state_representation: StateRepresentationT):
+    return state_representation in ["landing_request", "landing_request_internal"]
+
+
 def validate_against_model(pydantic_model: Type[BaseModel], parameter_state: Dict[str, Any]) -> None:
     try:
         pydantic_model(**parameter_state)
@@ -1432,36 +1552,28 @@ def validate_against_model(pydantic_model: Type[BaseModel], parameter_state: Dic
         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)
-
+class ValidationFunctionT(Protocol):
 
-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 __call__(self, tool: ToolParameterBundle, request: RawStateDict, name: str = DEFAULT_MODEL_NAME) -> None: ...
 
 
-def validate_internal_request_dereferenced(tool: ToolParameterBundle, request: Dict[str, Any]) -> None:
-    pydantic_model = create_request_internal_dereferenced_model(tool)
-    validate_against_model(pydantic_model, request)
-
-
-def validate_internal_job(tool: ToolParameterBundle, request: Dict[str, Any]) -> None:
-    pydantic_model = create_job_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)
+def validate_model_type_factory(state_representation: StateRepresentationT) -> ValidationFunctionT:
 
+    def validate_request(tool: ToolParameterBundle, request: Dict[str, Any], name: str = DEFAULT_MODEL_NAME) -> None:
+        pydantic_model = create_field_model(
+            tool.parameters, name=DEFAULT_MODEL_NAME, state_representation=state_representation
+        )
+        validate_against_model(pydantic_model, request)
 
-def validate_workflow_step(tool: ToolParameterBundle, request: Dict[str, Any]) -> None:
-    pydantic_model = create_workflow_step_model(tool)
-    validate_against_model(pydantic_model, request)
+    return validate_request
 
 
-def validate_workflow_step_linked(tool: ToolParameterBundle, request: Dict[str, Any]) -> None:
-    pydantic_model = create_workflow_step_linked_model(tool)
-    validate_against_model(pydantic_model, request)
+validate_request = validate_model_type_factory("request")
+validate_internal_request = validate_model_type_factory("request_internal")
+validate_internal_request_dereferenced = validate_model_type_factory("request_internal_dereferenced")
+validate_landing_request = validate_model_type_factory("landing_request")
+validate_internal_landing_request = validate_model_type_factory("landing_request_internal")
+validate_internal_job = validate_model_type_factory("job_internal")
+validate_test_case = validate_model_type_factory("test_case_xml")
+validate_workflow_step = validate_model_type_factory("workflow_step")
+validate_workflow_step_linked = validate_model_type_factory("workflow_step_linked")
diff --git a/lib/galaxy/tool_util/parameters/state.py b/lib/galaxy/tool_util/parameters/state.py
index af15cf23ac7b..3edc96f69c6e 100644
--- a/lib/galaxy/tool_util/parameters/state.py
+++ b/lib/galaxy/tool_util/parameters/state.py
@@ -15,6 +15,8 @@
 
 from .models import (
     create_job_internal_model,
+    create_landing_request_internal_model,
+    create_landing_request_model,
     create_request_internal_dereferenced_model,
     create_request_internal_model,
     create_request_model,
@@ -84,6 +86,22 @@ def _parameter_model_for(cls, parameters: ToolParameterBundle) -> Type[BaseModel
         return create_request_internal_model(parameters)
 
 
+class LandingRequestToolState(ToolState):
+    state_representation: Literal["landing_request"] = "landing_request"
+
+    @classmethod
+    def _parameter_model_for(cls, parameters: ToolParameterBundle) -> Type[BaseModel]:
+        return create_landing_request_model(parameters)
+
+
+class LandingRequestInternalToolState(ToolState):
+    state_representation: Literal["landing_request_internal"] = "landing_request_internal"
+
+    @classmethod
+    def _parameter_model_for(cls, parameters: ToolParameterBundle) -> Type[BaseModel]:
+        return create_landing_request_internal_model(parameters)
+
+
 class RequestInternalDereferencedToolState(ToolState):
     state_representation: Literal["request_internal_dereferenced"] = "request_internal_dereferenced"
 
diff --git a/lib/galaxy/tool_util/parser/interface.py b/lib/galaxy/tool_util/parser/interface.py
index 441985902805..af72bf4a4825 100644
--- a/lib/galaxy/tool_util/parser/interface.py
+++ b/lib/galaxy/tool_util/parser/interface.py
@@ -28,6 +28,7 @@
 
 from galaxy.util import Element
 from galaxy.util.path import safe_walk
+from .parameter_validators import AnyValidatorModel
 from .util import _parse_name
 
 if TYPE_CHECKING:
@@ -434,6 +435,10 @@ def elem(self) -> Element:
         # used with other tool sources.
         raise NotImplementedError(NOT_IMPLEMENTED_MESSAGE)
 
+    @abstractmethod
+    def get_dynamic_options_code(self) -> Optional[str]:
+        """If dynamic options are a piece of code to eval, return it."""
+
     @abstractmethod
     def get_data_table_name(self) -> Optional[str]:
         """If dynamic options are loaded from a data table, return the name."""
@@ -502,7 +507,7 @@ def parse_sanitizer_elem(self):
         """
         return None
 
-    def parse_validator_elems(self):
+    def parse_validators(self) -> List[AnyValidatorModel]:
         """Return an XML description of sanitizers. This is a stop gap
         until we can rework galaxy.tools.parameters.validation to not
         explicitly depend on XML.
diff --git a/lib/galaxy/tool_util/parser/parameter_validators.py b/lib/galaxy/tool_util/parser/parameter_validators.py
new file mode 100644
index 000000000000..6525b7d90fb8
--- /dev/null
+++ b/lib/galaxy/tool_util/parser/parameter_validators.py
@@ -0,0 +1,725 @@
+import json
+from typing import (
+    Any,
+    cast,
+    List,
+    Optional,
+    Sequence,
+    Union,
+)
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    model_validator,
+    PrivateAttr,
+)
+from typing_extensions import (
+    Annotated,
+    get_args,
+    Literal,
+    Protocol,
+    Self,
+)
+
+from galaxy.util import (
+    asbool,
+    Element,
+)
+
+try:
+    import regex
+except ImportError:
+    import re as regex
+
+
+class ValidationArgument:
+    doc: Optional[str]
+    xml_body: bool
+    xml_allow_json_load: bool
+
+    def __init__(
+        self,
+        doc: Optional[str],
+        xml_body: bool = False,
+        xml_allow_json_load: bool = False,
+    ):
+        self.doc = doc
+        self.xml_body = xml_body
+        self.xml_allow_json_load = xml_allow_json_load
+
+
+Negate = Annotated[
+    bool,
+    ValidationArgument("Negates the result of the validator."),
+]
+NEGATE_DEFAULT = False
+SPLIT_DEFAULT = "\t"
+DEFAULT_VALIDATOR_MESSAGE = "Parameter validation error."
+
+ValidatorType = Literal[
+    "expression",
+    "regex",
+    "in_range",
+    "length",
+    "metadata",
+    "dataset_metadata_equal",
+    "unspecified_build",
+    "no_options",
+    "empty_field",
+    "empty_dataset",
+    "empty_extra_files_path",
+    "dataset_metadata_in_data_table",
+    "dataset_metadata_not_in_data_table",
+    "dataset_metadata_in_range",
+    "value_in_data_table",
+    "value_not_in_data_table",
+    "dataset_ok_validator",
+    "dataset_metadata_in_file",
+]
+
+
+class StrictModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class ParameterValidatorModel(StrictModel):
+    type: ValidatorType
+    message: Annotated[
+        Optional[str],
+        ValidationArgument(
+            """The error message displayed on the tool form if validation fails. A placeholder string ``%s`` will be repaced by the ``value``"""
+        ),
+    ] = None
+    # track validators setup by other input parameters and not validation explicitly
+    implicit: bool = False
+    _static: bool = PrivateAttr(False)
+    _deprecated: bool = PrivateAttr(False)
+
+    @model_validator(mode="after")
+    def set_default_message(self) -> Self:
+        if self.message is None:
+            self.message = self.default_message
+        return self
+
+    @property
+    def default_message(self) -> str:
+        return DEFAULT_VALIDATOR_MESSAGE
+
+
+class StaticValidatorModel(ParameterValidatorModel):
+    _static: bool = PrivateAttr(True)
+
+    def statically_validate(self, v: Any) -> None: ...
+
+
+class ExpressionParameterValidatorModel(StaticValidatorModel):
+    """Check if a one line python expression given expression evaluates to True.
+
+    The expression is given is the content of the validator tag."""
+
+    type: Literal["expression"] = "expression"
+    negate: Negate = NEGATE_DEFAULT
+    expression: Annotated[str, ValidationArgument("Python expression to validate.", xml_body=True)]
+
+    def statically_validate(self, value: Any) -> None:
+        ExpressionParameterValidatorModel.expression_validation(self.expression, value, self)
+
+    @staticmethod
+    def ensure_compiled(expression: Union[str, Any]) -> Any:
+        if isinstance(expression, str):
+            return compile(expression, "<string>", "eval")
+        else:
+            return expression
+
+    @staticmethod
+    def expression_validation(
+        expression: str, value: Any, validator: "ValidatorDescription", compiled_expression: Optional[Any] = None
+    ):
+        if compiled_expression is None:
+            compiled_expression = ExpressionParameterValidatorModel.ensure_compiled(expression)
+        message = None
+        try:
+            evalresult = eval(compiled_expression, dict(value=value))
+        except Exception:
+            message = f"Validator '{expression}' could not be evaluated on '{value}'"
+            evalresult = False
+
+        raise_error_if_valiation_fails(bool(evalresult), validator, message=message, value_to_show=value)
+
+    @property
+    def default_message(self) -> str:
+        return f"Value '%s' does not evaluate to {'True' if not self.negate else 'False'} for '{self.expression}'"
+
+
+class RegexParameterValidatorModel(StaticValidatorModel):
+    """Check if a regular expression **matches** the value, i.e. appears
+    at the beginning of the value. To enforce a match of the complete value use
+    ``$`` at the end of the expression. The expression is given is the content
+    of the validator tag. Note that for ``selects`` each option is checked
+    separately."""
+
+    type: Literal["regex"] = "regex"
+    negate: Negate = NEGATE_DEFAULT
+    expression: Annotated[str, ValidationArgument("Regular expression to validate against.", xml_body=True)]
+
+    @property
+    def default_message(self) -> str:
+        return f"Value '%s' does {'not ' if not self.negate else ''}match regular expression '{self.expression.replace('%', '%%')}'"
+
+    def statically_validate(self, value: Any) -> None:
+        if value and not isinstance(value, str):
+            raise ValueError(f"Wrong type found value {value}")
+        RegexParameterValidatorModel.regex_validation(self.expression, value, self)
+
+    @staticmethod
+    def regex_validation(expression: str, value: Any, validator: "ValidatorDescription"):
+        if not isinstance(value, list):
+            value = [value]
+        for val in value:
+            match = regex.match(expression, val or "")
+            raise_error_if_valiation_fails(match is not None, validator, value_to_show=val)
+
+
+class InRangeParameterValidatorModel(StaticValidatorModel):
+    type: Literal["in_range"] = "in_range"
+    min: Optional[Union[float, int]] = None
+    max: Optional[Union[float, int]] = None
+    exclude_min: bool = False
+    exclude_max: bool = False
+    negate: Negate = NEGATE_DEFAULT
+
+    def statically_validate(self, value: Any):
+        if isinstance(value, (int, float)):
+            validates = True
+            if self.min is not None and value == self.min and self.exclude_min:
+                validates = False
+            elif self.min is not None and value < self.min:
+                validates = False
+            elif self.max is not None and value == self.max and self.exclude_max:
+                validates = False
+            if self.max is not None and value > self.max:
+                validates = False
+            raise_error_if_valiation_fails(validates, self)
+
+    @property
+    def default_message(self) -> str:
+        op1 = "<="
+        op2 = "<="
+        if self.exclude_min:
+            op1 = "<"
+        if self.exclude_max:
+            op2 = "<"
+        range_description_str = f"({self.min} {op1} value {op2} {self.max})"
+        return f"Value ('%s') must {'not ' if self.negate else ''}fulfill {range_description_str}"
+
+
+class LengthParameterValidatorModel(StaticValidatorModel):
+    type: Literal["length"] = "length"
+    min: Optional[int] = None
+    max: Optional[int] = None
+    negate: Negate = NEGATE_DEFAULT
+
+    def statically_validate(self, value: Any):
+        if isinstance(value, str):
+            length = len(value)
+            validates = True
+            if self.min is not None and length < self.min:
+                validates = False
+            if self.max is not None and length > self.max:
+                validates = False
+            raise_error_if_valiation_fails(validates, self)
+
+    @property
+    def default_message(self) -> str:
+        return f"Must {'not ' if self.negate else ''}have length of at least {self.min} and at most {self.max}"
+
+
+class MetadataParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["metadata"] = "metadata"
+    check: Optional[List[str]] = None
+    skip: Optional[List[str]] = None
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        check = self.check
+        skip = self.skip
+        message = DEFAULT_VALIDATOR_MESSAGE
+        if not self.negate:
+            message = "Metadata '%s' missing, click the pencil icon in the history item to edit / save the metadata attributes"
+        else:
+            if check:
+                message = f"""At least one of the checked metadata '{",".join(check)}' is set, click the pencil icon in the history item to edit / save the metadata attributes"""
+            elif skip:
+                message = f"""At least one of the non skipped metadata '{",".join(skip)}' is set, click the pencil icon in the history item to edit / save the metadata attributes"""
+        return message
+
+
+class DatasetMetadataEqualParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["dataset_metadata_equal"] = "dataset_metadata_equal"
+    metadata_name: str
+    value: Annotated[Any, ValidationArgument("Value to test against", xml_allow_json_load=True)]
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        if not self.negate:
+            message = f"Metadata value for '{self.metadata_name}' must be '{self.value}', but it is '%s'."
+        else:
+            message = f"Metadata value for '{self.metadata_name}' must not be '{self.value}' but it is."
+        return message
+
+
+class UnspecifiedBuildParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["unspecified_build"] = "unspecified_build"
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        return f"{'Unspecified' if not self.negate else 'Specified'} genome build, click the pencil icon in the history item to {'set' if not self.negate else 'remove'} the genome build"
+
+
+class NoOptionsParameterValidatorModel(StaticValidatorModel):
+    type: Literal["no_options"] = "no_options"
+    negate: Negate = NEGATE_DEFAULT
+
+    @staticmethod
+    def no_options_validate(value: Any, validator: "ValidatorDescription"):
+        raise_error_if_valiation_fails(value is not None, validator)
+
+    def statically_validate(self, value: Any) -> None:
+        NoOptionsParameterValidatorModel.no_options_validate(value, self)
+
+    @property
+    def default_message(self) -> str:
+        return f"{'No options' if not self.negate else 'Options'} available for selection"
+
+
+class EmptyFieldParameterValidatorModel(StaticValidatorModel):
+    type: Literal["empty_field"] = "empty_field"
+    negate: Negate = NEGATE_DEFAULT
+
+    @staticmethod
+    def empty_validate(value: Any, validator: "ValidatorDescription"):
+        raise_error_if_valiation_fails((value != ""), validator)
+
+    def statically_validate(self, value: Any) -> None:
+        EmptyFieldParameterValidatorModel.empty_validate(value, self)
+
+    @property
+    def default_message(self) -> str:
+        if not self.negate:
+            message = "Field requires a value"
+        else:
+            message = "Field must not set a value"
+        return message
+
+
+class EmptyDatasetParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["empty_dataset"] = "empty_dataset"
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        return f"The selected dataset is {'non-' if self.negate else ''}empty, this tool expects {'non-' if not self.negate else ''}empty files."
+
+
+class EmptyExtraFilesPathParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["empty_extra_files_path"] = "empty_extra_files_path"
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        negate = self.negate
+        return f"The selected dataset's extra_files_path directory is {'non-' if negate else ''}empty or does {'not ' if not negate else ''}exist, this tool expects {'non-' if not negate else ''}empty extra_files_path directories associated with the selected input."
+
+
+class DatasetMetadataInDataTableParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["dataset_metadata_in_data_table"] = "dataset_metadata_in_data_table"
+    table_name: str
+    metadata_name: str
+    metadata_column: Union[int, str]
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        return f"Value for metadata {self.metadata_name} was not found in {self.table_name}."
+
+
+class DatasetMetadataNotInDataTableParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["dataset_metadata_not_in_data_table"] = "dataset_metadata_not_in_data_table"
+    table_name: str
+    metadata_name: str
+    metadata_column: Union[int, str]
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        return f"Value for metadata {self.metadata_name} was not found in {self.table_name}."
+
+
+class DatasetMetadataInRangeParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["dataset_metadata_in_range"] = "dataset_metadata_in_range"
+    metadata_name: str
+    min: Optional[Union[float, int]] = None
+    max: Optional[Union[float, int]] = None
+    exclude_min: bool = False
+    exclude_max: bool = False
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        op1 = "<="
+        op2 = "<="
+        if self.exclude_min:
+            op1 = "<"
+        if self.exclude_max:
+            op2 = "<"
+        range_description_str = f"({self.min} {op1} value {op2} {self.max})"
+        return f"Value ('%s') must {'not ' if self.negate else ''}fulfill {range_description_str}"
+
+
+class ValueInDataTableParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["value_in_data_table"] = "value_in_data_table"
+    table_name: str
+    metadata_column: Union[int, str]
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        return "Value for metadata not found."
+
+
+class ValueNotInDataTableParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["value_not_in_data_table"] = "value_not_in_data_table"
+    table_name: str
+    metadata_column: Union[int, str]
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        return f"Value was not found in {self.table_name}."
+
+
+class DatasetOkValidatorParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["dataset_ok_validator"] = "dataset_ok_validator"
+    negate: Negate = NEGATE_DEFAULT
+
+    @property
+    def default_message(self) -> str:
+        if not self.negate:
+            message = (
+                "The selected dataset is still being generated, select another dataset or wait until it is completed"
+            )
+        else:
+            message = "The selected dataset must not be in state OK"
+        return message
+
+
+class DatasetMetadataInFileParameterValidatorModel(ParameterValidatorModel):
+    type: Literal["dataset_metadata_in_file"] = "dataset_metadata_in_file"
+    filename: str
+    metadata_name: str
+    metadata_column: Union[int, str]
+    line_startswith: Optional[str] = None
+    split: str = SPLIT_DEFAULT
+    negate: Negate = NEGATE_DEFAULT
+    _deprecated: bool = PrivateAttr(True)
+
+    @property
+    def default_message(self) -> str:
+        return f"Value for metadata {self.metadata_name} was not found in {self.filename}."
+
+
+AnyValidatorModel = Annotated[
+    Union[
+        ExpressionParameterValidatorModel,
+        RegexParameterValidatorModel,
+        InRangeParameterValidatorModel,
+        LengthParameterValidatorModel,
+        MetadataParameterValidatorModel,
+        DatasetMetadataEqualParameterValidatorModel,
+        UnspecifiedBuildParameterValidatorModel,
+        NoOptionsParameterValidatorModel,
+        EmptyFieldParameterValidatorModel,
+        EmptyDatasetParameterValidatorModel,
+        EmptyExtraFilesPathParameterValidatorModel,
+        DatasetMetadataInDataTableParameterValidatorModel,
+        DatasetMetadataNotInDataTableParameterValidatorModel,
+        DatasetMetadataInRangeParameterValidatorModel,
+        ValueInDataTableParameterValidatorModel,
+        ValueNotInDataTableParameterValidatorModel,
+        DatasetOkValidatorParameterValidatorModel,
+        DatasetMetadataInFileParameterValidatorModel,
+    ],
+    Field(discriminator="type"),
+]
+
+
+def parse_xml_validators(input_elem: Element) -> List[AnyValidatorModel]:
+    validator_els: List[Element] = input_elem.findall("validator") or []
+    models = []
+    for validator_el in validator_els:
+        models.append(parse_xml_validator(validator_el))
+    return models
+
+
+def static_validators(validator_models: List[AnyValidatorModel]) -> List[AnyValidatorModel]:
+    static_validators = []
+    for validator_model in validator_models:
+        print(validator_model._static)
+        if validator_model._static:
+            static_validators.append(validator_model)
+    return static_validators
+
+
+def parse_xml_validator(validator_el: Element) -> AnyValidatorModel:
+    _type = validator_el.get("type")
+    if _type is None:
+        raise ValueError("Required 'type' attribute missing from validator")
+    valid_types = get_args(ValidatorType)
+    if _type not in valid_types:
+        raise ValueError(f"Unknown 'type' attribute in validator {_type}")
+    validator_type: ValidatorType = cast(ValidatorType, _type)
+    if validator_type == "expression":
+        return ExpressionParameterValidatorModel(
+            type="expression",
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+            expression=validator_el.text,
+        )
+    elif validator_type == "regex":
+        return RegexParameterValidatorModel(
+            type="regex",
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+            expression=validator_el.text,
+        )
+    elif validator_type == "in_range":
+        return InRangeParameterValidatorModel(
+            type="in_range",
+            message=_parse_message(validator_el),
+            min=_parse_number(validator_el, "min"),
+            max=_parse_number(validator_el, "max"),
+            exclude_min=_parse_bool(validator_el, "exclude_min", False),
+            exclude_max=_parse_bool(validator_el, "exclude_max", False),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "length":
+        return LengthParameterValidatorModel(
+            type="length",
+            min=_parse_int(validator_el, "min"),
+            max=_parse_int(validator_el, "max"),
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "metadata":
+        return MetadataParameterValidatorModel(
+            type="metadata",
+            message=_parse_message(validator_el),
+            check=_parse_str_list(validator_el, "check"),
+            skip=_parse_str_list(validator_el, "skip"),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "dataset_metadata_equal":
+        return DatasetMetadataEqualParameterValidatorModel(
+            type="dataset_metadata_equal",
+            metadata_name=validator_el.get("metadata_name"),
+            value=_parse_json_value(validator_el),
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "unspecified_build":
+        return UnspecifiedBuildParameterValidatorModel(
+            type="unspecified_build",
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "no_options":
+        return NoOptionsParameterValidatorModel(
+            type="no_options",
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "empty_field":
+        return EmptyFieldParameterValidatorModel(
+            type="empty_field",
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "empty_dataset":
+        return EmptyDatasetParameterValidatorModel(
+            type="empty_dataset",
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "empty_extra_files_path":
+        return EmptyExtraFilesPathParameterValidatorModel(
+            type="empty_extra_files_path",
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "dataset_metadata_in_data_table":
+        return DatasetMetadataInDataTableParameterValidatorModel(
+            type="dataset_metadata_in_data_table",
+            message=_parse_message(validator_el),
+            table_name=validator_el.get("table_name"),
+            metadata_name=validator_el.get("metadata_name"),
+            metadata_column=_parse_metadata_column(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "dataset_metadata_not_in_data_table":
+        return DatasetMetadataNotInDataTableParameterValidatorModel(
+            type="dataset_metadata_not_in_data_table",
+            message=_parse_message(validator_el),
+            table_name=validator_el.get("table_name"),
+            metadata_name=validator_el.get("metadata_name"),
+            metadata_column=_parse_metadata_column(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "dataset_metadata_in_range":
+        return DatasetMetadataInRangeParameterValidatorModel(
+            type="dataset_metadata_in_range",
+            message=_parse_message(validator_el),
+            metadata_name=validator_el.get("metadata_name"),
+            min=_parse_number(validator_el, "min"),
+            max=_parse_number(validator_el, "max"),
+            exclude_min=_parse_bool(validator_el, "exclude_min", False),
+            exclude_max=_parse_bool(validator_el, "exclude_max", False),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "value_in_data_table":
+        return ValueInDataTableParameterValidatorModel(
+            type="value_in_data_table",
+            message=_parse_message(validator_el),
+            table_name=validator_el.get("table_name"),
+            metadata_column=_parse_metadata_column(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "value_not_in_data_table":
+        return ValueNotInDataTableParameterValidatorModel(
+            type="value_not_in_data_table",
+            message=_parse_message(validator_el),
+            table_name=validator_el.get("table_name"),
+            metadata_column=_parse_metadata_column(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "dataset_ok_validator":
+        return DatasetOkValidatorParameterValidatorModel(
+            type="dataset_ok_validator",
+            message=_parse_message(validator_el),
+            negate=_parse_negate(validator_el),
+        )
+    elif validator_type == "dataset_metadata_in_file":
+        filename = validator_el.get("filename")
+        return DatasetMetadataInFileParameterValidatorModel(
+            type="dataset_metadata_in_file",
+            message=_parse_message(validator_el),
+            filename=filename,
+            metadata_name=validator_el.get("metadata_name"),
+            metadata_column=_parse_metadata_column(validator_el),
+            line_startswith=validator_el.get("line_startswith"),
+            split=validator_el.get("split", SPLIT_DEFAULT),
+            negate=_parse_negate(validator_el),
+        )
+    else:
+        raise ValueError(f"Unhandled 'type' attribute in validator {validator_type}")
+
+
+class ValidatorDescription(Protocol):
+
+    @property
+    def negate(self) -> bool: ...
+
+    @property
+    def message(self) -> Optional[str]: ...
+
+
+def raise_error_if_valiation_fails(
+    value: bool, validator: ValidatorDescription, message: Optional[str] = None, value_to_show: Optional[str] = None
+):
+    if not isinstance(value, bool):
+        raise AssertionError("Validator logic problem - computed validation value must be boolean")
+    if message is None:
+        message = validator.message
+    if message is None:
+        message = DEFAULT_VALIDATOR_MESSAGE
+    assert message
+    if value_to_show and "%s" in message:
+        message = message % value_to_show
+    negate = validator.negate
+    if (not negate and value) or (negate and not value):
+        return
+    else:
+        raise ValueError(message)
+
+
+def _parse_message(xml_el: Element) -> Optional[str]:
+    message = cast(Optional[str], xml_el.get("message"))
+    return message
+
+
+def _parse_int(xml_el: Element, attribute: str) -> Optional[int]:
+    raw_value = xml_el.get(attribute)
+    if raw_value:
+        return int(raw_value)
+    else:
+        return None
+
+
+def _parse_number(xml_el: Element, attribute: str) -> Optional[Union[float, int]]:
+    raw_value = xml_el.get(attribute)
+    if raw_value and ("." in raw_value or "e" in raw_value):
+        return float(raw_value)
+    elif raw_value:
+        return int(raw_value)
+    else:
+        return None
+
+
+def _parse_negate(xml_el: Element) -> bool:
+    return _parse_bool(xml_el, "negate", False)
+
+
+def _parse_bool(xml_el: Element, attribute: str, default_value: bool) -> bool:
+    return asbool(xml_el.get(attribute, default_value))
+
+
+def _parse_str_list(xml_el: Element, attribute: str) -> List[str]:
+    raw_value = xml_el.get(attribute)
+    if not raw_value:
+        return []
+    else:
+        return [v.strip() for v in raw_value.split(",")]
+
+
+def _parse_json_value(xml_el: Element) -> Any:
+    value = xml_el.get("value", None) or json.loads(xml_el.get("value_json", "null"))
+    return value
+
+
+def _parse_metadata_column(xml_el: Element) -> Union[int, str]:
+    column = xml_el.get("metadata_column", 0)
+    try:
+        return int(column)
+    except ValueError:
+        return column
+
+
+def static_tool_validators(validators: Sequence[ParameterValidatorModel]) -> List[StaticValidatorModel]:
+    static_validators: List[StaticValidatorModel] = []
+    for validator in validators:
+        if isinstance(validator, StaticValidatorModel):
+            static_validators.append(validator)
+    return static_validators
+
+
+def statically_validates(validators: Sequence[ParameterValidatorModel], value: Any) -> bool:
+    for validator in static_tool_validators(validators):
+        try:
+            validator.statically_validate(value)
+        except ValueError:
+            return False
+    return True
diff --git a/lib/galaxy/tool_util/parser/util.py b/lib/galaxy/tool_util/parser/util.py
index 53009057128e..34f3e0943eea 100644
--- a/lib/galaxy/tool_util/parser/util.py
+++ b/lib/galaxy/tool_util/parser/util.py
@@ -8,6 +8,9 @@
 
 from packaging.version import Version
 
+from galaxy.util import string_as_bool
+from .parameter_validators import statically_validates
+
 if TYPE_CHECKING:
     from .interface import (
         InputSource,
@@ -83,6 +86,27 @@ def boolean_true_and_false_values(input_source, profile: Optional[Union[float, s
     return (truevalue, falsevalue)
 
 
+def text_input_is_optional(input_source: "InputSource") -> Tuple[bool, bool]:
+    # Optionality not explicitly defined, default to False
+    optional: Optional[bool] = False
+    optionality_inferred: bool = False
+
+    optional = input_source.get("optional", None)
+    if optional is not None:
+        optional = string_as_bool(optional)
+    else:
+        # A text parameter that doesn't raise a validation error on empty string
+        # is considered to be optional
+        if statically_validates(input_source.parse_validators(), ""):
+            optional = True
+            optionality_inferred = True
+        else:
+            optional = False
+
+    assert isinstance(optional, bool)
+    return optional, optionality_inferred
+
+
 class ParameterParseException(Exception):
     message: str
 
diff --git a/lib/galaxy/tool_util/parser/xml.py b/lib/galaxy/tool_util/parser/xml.py
index b94cf7a84457..aba5a6874248 100644
--- a/lib/galaxy/tool_util/parser/xml.py
+++ b/lib/galaxy/tool_util/parser/xml.py
@@ -71,6 +71,10 @@
     ToolOutputCollection,
     ToolOutputCollectionStructure,
 )
+from .parameter_validators import (
+    AnyValidatorModel,
+    parse_xml_validators,
+)
 from .stdio import (
     aggressive_error_checks,
     error_on_exit_code,
@@ -1296,18 +1300,23 @@ def parse_input_sources(self):
 
 class XmlDynamicOptions(DynamicOptions):
 
-    def __init__(self, options_elem: Element):
+    def __init__(self, options_elem: Element, dynamic_option_code: Optional[str]):
         self._options_elem = options_elem
+        self._dynamic_options_code = dynamic_option_code
 
     def elem(self) -> Element:
         return self._options_elem
 
+    def get_dynamic_options_code(self) -> Optional[str]:
+        """If dynamic options are a piece of code to eval, return it."""
+        return self._dynamic_options_code
+
     def get_data_table_name(self) -> Optional[str]:
         """If dynamic options are loaded from a data table, return the name."""
-        return self._options_elem.get("from_data_table")
+        return self._options_elem.get("from_data_table") if self._options_elem is not None else None
 
     def get_index_file_name(self) -> Optional[str]:
-        return self._options_elem.get("from_file")
+        return self._options_elem.get("from_file") if self._options_elem is not None else None
 
 
 class XmlInputSource(InputSource):
@@ -1339,13 +1348,18 @@ def parse_help(self):
     def parse_sanitizer_elem(self):
         return self.input_elem.find("sanitizer")
 
-    def parse_validator_elems(self):
-        return self.input_elem.findall("validator")
+    def parse_validators(self) -> List[AnyValidatorModel]:
+        return parse_xml_validators(self.input_elem)
 
     def parse_dynamic_options(self) -> Optional[XmlDynamicOptions]:
         """Return a XmlDynamicOptions to describe dynamic options if options elem is available."""
         options_elem = self.input_elem.find("options")
-        return XmlDynamicOptions(options_elem) if options_elem is not None else None
+        dynamic_option_code = self.input_elem.get("dynamic_options")
+        is_dynamic = options_elem is not None or dynamic_option_code is not None
+        if is_dynamic:
+            return XmlDynamicOptions(options_elem, dynamic_option_code)
+        else:
+            return None
 
     def parse_static_options(self) -> List[Tuple[str, str, bool]]:
         """
diff --git a/lib/galaxy/tool_util/toolbox/__init__.py b/lib/galaxy/tool_util/toolbox/__init__.py
index 34c2070b09f1..b0d611cbff4f 100644
--- a/lib/galaxy/tool_util/toolbox/__init__.py
+++ b/lib/galaxy/tool_util/toolbox/__init__.py
@@ -3,6 +3,7 @@
 from .base import (
     AbstractToolBox,
     AbstractToolTagManager,
+    ToolLoadError,
 )
 from .panel import (
     panel_item_types,
@@ -14,6 +15,7 @@
     "AbstractToolBox",
     "AbstractToolTagManager",
     "panel_item_types",
+    "ToolLoadError",
     "ToolSection",
     "ToolSectionLabel",
 )
diff --git a/lib/galaxy/tool_util/toolbox/base.py b/lib/galaxy/tool_util/toolbox/base.py
index f6ab7bfa98f1..5862f17881f8 100644
--- a/lib/galaxy/tool_util/toolbox/base.py
+++ b/lib/galaxy/tool_util/toolbox/base.py
@@ -133,6 +133,10 @@ def handle_tags(self, tool_id, tool_definition_source) -> None:
         return None
 
 
+class ToolLoadError(Exception):
+    pass
+
+
 class AbstractToolBox(ManagesIntegratedToolPanelMixin):
     """
     Abstract container for managing a ToolPanel - containing tools and
@@ -1073,6 +1077,8 @@ def quick_load(tool_file, async_load=True):
                     self._load_tool_panel_views()
                     self._save_integrated_tool_panel()
                 return tool.id
+            except ToolLoadError as e:
+                log.error(f"Failed to load potential tool {tool_file} - {e}")
             except Exception:
                 log.exception("Failed to load potential tool %s.", tool_file)
                 return None
diff --git a/lib/galaxy/tool_util/unittest_utils/sample_data.py b/lib/galaxy/tool_util/unittest_utils/sample_data.py
index d4b6ddb6f027..e9b19283401a 100644
--- a/lib/galaxy/tool_util/unittest_utils/sample_data.py
+++ b/lib/galaxy/tool_util/unittest_utils/sample_data.py
@@ -17,3 +17,56 @@
 </macros>
 """
 )
+
+VALID_XML_VALIDATORS = [
+    """<validator type="empty_dataset" />""",
+    """<validator type="empty_dataset" message="foobar" />""",
+    """<validator type="empty_dataset" message="foobar" negate="true" />""",
+    """<validator type="expression">value == 7</validator>""",
+    """<validator type="regex">mycoolexpression</validator>""",
+    """<validator type="in_range" min="3.1" max="3.8" />""",
+    """<validator type="in_range" min="3.1" />""",
+    """<validator type="in_range" min="3.1" max="3.8" exclude_min="false" exclude_max="true" />""",
+    """<validator type="length" min="3" />""",
+    """<validator type="length" max="7" />""",
+    """<validator type="length" min="2" max="7" negate="true" />""",
+    """<validator type="empty_field" />""",
+    """<validator type="empty_extra_files_path" />""",
+    """<validator type="no_options" />""",
+    """<validator type="unspecified_build" />""",
+    """<validator type="dataset_ok_validator" />""",
+    """<validator type="metadata" check="foo, bar" />""",
+    """<validator type="metadata" skip="name, dbkey" />""",
+    """<validator type="dataset_metadata_equal" metadata_name="foobar" value="moocow" />""",
+    """<validator type="dataset_metadata_equal" metadata_name="foobar" value_json="null" />""",
+    """<validator type="dataset_metadata_in_range" metadata_name="foobar" min="4.5" max="7.8" />""",
+    """<validator type="dataset_metadata_in_range" metadata_name="foobar" min="4.5" max="7.8" include_min="true" />""",
+    """<validator type="dataset_metadata_in_data_table" metadata_name="foobar" metadata_column="3" table_name="mycooltable" />""",
+    """<validator type="dataset_metadata_not_in_data_table" metadata_name="foobar" metadata_column="3" table_name="mycooltable" />""",
+    """<validator type="value_in_data_table" metadata_column="3" table_name="mycooltable" />""",
+    """<validator type="value_in_data_table" table_name="mycooltable" />""",
+    """<validator type="value_not_in_data_table" metadata_column="3" table_name="mycooltable" />""",
+    """<validator type="value_not_in_data_table" table_name="mycooltable" />""",
+]
+
+INVALID_XML_VALIDATORS = [
+    """<validator type="unknown" />""",
+    """<validator type="empty_datasetx" />""",
+    """<validator type="expression" />""",
+    """<validator type="empty_dataset" message="foobar" negate="NOTABOOLVALUE" />""",
+    """<validator type="regex" />""",
+    """<validator type="in_range" min="3.1" max="3.8" exclude_min="false" exclude_max="foobar" />""",
+    """<validator type="in_range" min="notanumber" max="3.8" />""",
+    """<validator type="length" min="notanumber" />""",
+    """<validator type="length" max="notanumber" />""",
+    """<validator type="length" min="2" max="7" negate="notabool" />""",
+    """<validator type="dataset_metadata_equal" />""",
+    """<validator type="dataset_metadata_equal" metadaata_name="foobar" />""",
+    """<validator type="dataset_metadata_equal" metadaata_name="foobar" value_json="undefined" />""",
+    """<validator type="dataset_metadata_in_range" metadata_name="foobar" min="4.5" max="7.8" include_min="notabool" />"""
+    """<validator type="dataset_metadata_in_range"  min="4.5" max="7.8" />"""
+    """<validator type="dataset_metadata_in_data_table" metadata_name="foobar" metadata_column="3" />""",
+    """<validator type="dataset_metadata_in_data_table" metadata_column="3" table_name="mycooltable" />""",
+    """<validator type="dataset_metadata_not_in_data_table" metadata_name="foobar" metadata_column="3" />""",
+    """<validator type="dataset_metadata_not_in_data_table" metadata_column="3" table_name="mycooltable" />""",
+]
diff --git a/lib/galaxy/tool_util/verify/_types.py b/lib/galaxy/tool_util/verify/_types.py
index e5aa85f1ddb7..c532dab9aa69 100644
--- a/lib/galaxy/tool_util/verify/_types.py
+++ b/lib/galaxy/tool_util/verify/_types.py
@@ -19,10 +19,15 @@
     ToolSourceTestOutputs,
 )
 
-# inputs that have been processed with parse.py and expanded out
+# legacy inputs for working with POST /api/tools
+# + inputs that have been processed with parse.py and expanded out
 ExpandedToolInputs = Dict[str, Any]
-# ExpandedToolInputs where any model objects have been json-ified with to_dict()
+# + ExpandedToolInputs where any model objects have been json-ified with to_dict()
 ExpandedToolInputsJsonified = Dict[str, Any]
+
+# modern inputs for working with POST /api/jobs*
+RawTestToolRequest = Dict[str, Any]
+
 ExtraFileInfoDictT = Dict[str, Any]
 RequiredFileTuple = Tuple[str, ExtraFileInfoDictT]
 RequiredFilesT = List[RequiredFileTuple]
@@ -36,6 +41,8 @@ class ToolTestDescriptionDict(TypedDict):
     name: str
     test_index: int
     inputs: ExpandedToolInputsJsonified
+    request: NotRequired[Optional[Dict[str, Any]]]
+    request_schema: NotRequired[Optional[Dict[str, Any]]]
     outputs: ToolSourceTestOutputs
     output_collections: List[TestSourceTestOutputColllection]
     stdout: Optional[AssertionList]
diff --git a/lib/galaxy/tool_util/verify/interactor.py b/lib/galaxy/tool_util/verify/interactor.py
index cccb1aaa9f58..230da8c99147 100644
--- a/lib/galaxy/tool_util/verify/interactor.py
+++ b/lib/galaxy/tool_util/verify/interactor.py
@@ -35,8 +35,18 @@
 )
 
 from galaxy import util
+from galaxy.tool_util.parameters import (
+    DataCollectionRequest,
+    DataRequestHda,
+    encode_test,
+    input_models_from_json,
+    TestCaseToolState,
+    ToolParameterBundle,
+)
 from galaxy.tool_util.parser.interface import (
     AssertionList,
+    JsonTestCollectionDefDict,
+    JsonTestDatasetDefDict,
     TestCollectionDef,
     TestCollectionOutputDef,
     TestSourceTestOutputColllection,
@@ -53,6 +63,7 @@
 from ._types import (
     ExpandedToolInputs,
     ExpandedToolInputsJsonified,
+    RawTestToolRequest,
     RequiredDataTablesT,
     RequiredFilesT,
     RequiredLocFileT,
@@ -63,6 +74,9 @@
 
 log = getLogger(__name__)
 
+UseLegacyApiT = Literal["always", "never", "if_needed"]
+DEFAULT_USE_LEGACY_API: UseLegacyApiT = "always"
+
 # Off by default because it can pound the database pretty heavily
 # and result in sqlite errors on larger tests or larger numbers of
 # tests.
@@ -102,6 +116,8 @@ def __getitem__(self, item):
 
 class ValidToolTestDict(TypedDict):
     inputs: ExpandedToolInputs
+    request: NotRequired[Optional[RawTestToolRequest]]
+    request_schema: NotRequired[Optional[Dict[str, Any]]]
     outputs: ToolSourceTestOutputs
     output_collections: List[TestSourceTestOutputColllection]
     stdout: NotRequired[AssertionList]
@@ -148,7 +164,7 @@ def stage_data_in_history(
     # Upload any needed files
     upload_waits = []
 
-    assert tool_id
+    assert tool_id, "Tool id not set"
 
     if UPLOAD_ASYNC:
         for test_data in all_test_data:
@@ -236,6 +252,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(self, tool_id: str, tool_version: Optional[str] = None) -> List[ToolTestDescriptionDict]:
         url = f"tools/{tool_id}/test_data"
         params = {"tool_version": tool_version} if tool_version else None
@@ -366,9 +391,27 @@ def wait_for_content():
     def wait_for_job(self, job_id: str, history_id: Optional[str] = None, maxseconds=DEFAULT_TOOL_TEST_WAIT) -> None:
         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 get_tool_request(self, tool_request_id: str):
+        response_raw = self._get(f"tool_requests/{tool_request_id}")
+        response_raw.raise_for_status()
+        return response_raw.json()
+
     def wait_for(self, func: Callable, what: str = "tool test run", **kwd) -> None:
         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: str) -> Dict[str, Any]:
         return self.__get_job_stdio(job_id).json()
@@ -566,8 +609,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 (
@@ -593,39 +637,71 @@ def _ensure_valid_location_in(self, test_data: dict) -> Optional[str]:
         return location
 
     def run_tool(
-        self, testdef: "ToolTestDescription", history_id: str, resource_parameters: Optional[Dict[str, Any]] = None
+        self,
+        testdef: "ToolTestDescription",
+        history_id: str,
+        resource_parameters: Optional[Dict[str, Any]] = None,
+        use_legacy_api: UseLegacyApiT = DEFAULT_USE_LEGACY_API,
     ) -> 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
+        request = testdef.request
+        request_schema = testdef.request_schema
+        submit_with_legacy_api = use_legacy_api == "always" or (use_legacy_api == "if_needed" and request is None)
+        if submit_with_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
+
+            # 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:
+            assert request is not None, "Request not set"
+            assert request_schema is not None, "Request schema not set"
+            parameters = request_schema["parameters"]
+
+            def adapt_datasets(test_input: JsonTestDatasetDefDict) -> DataRequestHda:
+                # if path is not set it might be a composite file with a path,
+                # e.g. composite_shapefile
+                test_input_path = test_input.get("path", "")
+                return DataRequestHda(**self.uploads[test_input_path])
+
+            def adapt_collections(test_input: JsonTestCollectionDefDict) -> DataCollectionRequest:
+                test_collection_def = TestCollectionDef.from_dict(test_input)
+                hdca_id = self._create_collection(history_id, test_collection_def)
+                return DataCollectionRequest(src="hdca", id=hdca_id)
+
+            test_case_state = TestCaseToolState(input_state=request)
+            inputs_tree = encode_test(
+                test_case_state, input_models_from_json(parameters), adapt_datasets, adapt_collections
+            ).input_state
 
         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]
-
         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=submit_with_legacy_api,
             )
             if _are_tool_inputs_not_ready(submit_response):
                 print("Tool inputs not ready yet")
@@ -634,12 +710,38 @@ def run_tool(
             else:
                 break
         submit_response_object = ensure_tool_run_response_okay(submit_response, "execute tool", inputs_tree)
+        if not submit_with_legacy_api:
+            tool_request_id = submit_response_object["tool_request_id"]
+            successful = self.wait_on_tool_request(tool_request_id)
+            if not successful:
+                request = self.get_tool_request(tool_request_id) or {}
+                raise RunToolException(
+                    f"Tool request failure - state {request.get('state')}, message: {request.get('state_message')}",
+                    inputs_tree,
+                )
+            jobs = self.jobs_for_tool_request(tool_request_id)
+            outputs = OutputsDict()
+            output_collections = {}
+            if len(jobs) != 1:
+                raise Exception(f"Found incorrect number of jobs for tool request - was expecting a single job {jobs}")
+            assert len(jobs) == 1, jobs
+            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 = (
@@ -777,14 +879,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()
@@ -801,12 +913,33 @@ def _state_ready(self, job_id: str, error_msg: str):
             )
         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: bool = 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
@@ -1318,6 +1451,7 @@ def verify_tool(
     register_job_data: Optional[JobDataCallbackT] = None,
     test_index: int = 0,
     tool_version: Optional[str] = None,
+    use_legacy_api: UseLegacyApiT = DEFAULT_USE_LEGACY_API,
     quiet: bool = False,
     test_history: Optional[str] = None,
     no_history_cleanup: bool = False,
@@ -1334,11 +1468,7 @@ def verify_tool(
     if client_test_config is None:
         client_test_config = NullClientTestConfig()
     tool_test_dicts = _tool_test_dicts or galaxy_interactor.get_tool_tests(tool_id, tool_version=tool_version)
-    tool_test_dict = tool_test_dicts[test_index]
-    if "test_index" not in tool_test_dict:
-        tool_test_dict["test_index"] = test_index
-    if "tool_id" not in tool_test_dict:
-        tool_test_dict["tool_id"] = tool_id
+    tool_test_dict: ToolTestDescriptionDict = tool_test_dicts[test_index]
     if tool_version is None and "tool_version" in tool_test_dict:
         tool_version = tool_test_dict.get("tool_version")
 
@@ -1403,7 +1533,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:
@@ -1688,6 +1820,8 @@ def adapt_tool_source_dict(processed_dict: ToolTestDict) -> ToolTestDescriptionD
     expect_test_failure: bool = DEFAULT_EXPECT_TEST_FAILURE
     inputs: ExpandedToolInputsJsonified = {}
     maxseconds: Optional[int] = None
+    request: Optional[Dict[str, Any]] = None
+    request_schema: Optional[Dict[str, Any]] = None
 
     if not error_in_test_definition:
         processed_test_dict = cast(ValidToolTestDict, processed_dict)
@@ -1713,6 +1847,8 @@ def adapt_tool_source_dict(processed_dict: ToolTestDict) -> ToolTestDescriptionD
         expect_failure = processed_test_dict.get("expect_failure", DEFAULT_EXPECT_FAILURE)
         expect_test_failure = processed_test_dict.get("expect_test_failure", DEFAULT_EXPECT_TEST_FAILURE)
         inputs = processed_test_dict.get("inputs", {})
+        request = processed_test_dict.get("request", None)
+        request_schema = processed_test_dict.get("request_schema", None)
     else:
         invalid_test_dict = cast(InvalidToolTestDict, processed_dict)
         maxseconds = DEFAULT_TOOL_TEST_WAIT
@@ -1740,6 +1876,8 @@ def adapt_tool_source_dict(processed_dict: ToolTestDict) -> ToolTestDescriptionD
         expect_failure=expect_failure,
         expect_test_failure=expect_test_failure,
         inputs=inputs,
+        request=request,
+        request_schema=request_schema,
     )
 
 
@@ -1802,6 +1940,8 @@ class ToolTestDescription:
     expect_test_failure: bool
     exception: Optional[str]
     inputs: ExpandedToolInputs
+    request: Optional[Dict[str, Any]]
+    request_schema: Optional[Dict[str, Any]]
     outputs: ToolSourceTestOutputs
     output_collections: List[TestCollectionOutputDef]
     maxseconds: Optional[int]
@@ -1830,6 +1970,8 @@ def __init__(self, json_dict: ToolTestDescriptionDict):
         self.expect_failure = json_dict.get("expect_failure", DEFAULT_EXPECT_FAILURE)
         self.expect_test_failure = json_dict.get("expect_test_failure", DEFAULT_EXPECT_TEST_FAILURE)
         self.inputs = expanded_inputs_from_json(json_dict.get("inputs", {}))
+        self.request = json_dict.get("request", None)
+        self.request_schema = json_dict.get("request_schema", None)
         self.tool_id = json_dict["tool_id"]
         self.tool_version = json_dict.get("tool_version")
         self.maxseconds = _get_maxseconds(json_dict)
@@ -1862,6 +2004,8 @@ def to_dict(self) -> ToolTestDescriptionDict:
                 "required_files": self.required_files,
                 "required_data_tables": self.required_data_tables,
                 "required_loc_files": self.required_loc_files,
+                "request": self.request,
+                "request_schema": self.request_schema,
                 "error": self.error,
                 "exception": self.exception,
                 "maxseconds": self.maxseconds,
diff --git a/lib/galaxy/tool_util/verify/parse.py b/lib/galaxy/tool_util/verify/parse.py
index a3aee97eef0c..110dc9a93628 100644
--- a/lib/galaxy/tool_util/verify/parse.py
+++ b/lib/galaxy/tool_util/verify/parse.py
@@ -1,7 +1,10 @@
 import logging
 import os
+import traceback
+from dataclasses import dataclass
 from typing import (
     Any,
+    Dict,
     Iterable,
     List,
     Optional,
@@ -14,6 +17,8 @@
 from galaxy.tool_util.parameters import (
     input_models_for_tool_source,
     test_case_state as case_state,
+    TestCaseToolState,
+    ToolParameterBundleModel,
 )
 from galaxy.tool_util.parser.interface import (
     InputSource,
@@ -64,15 +69,18 @@ def parse_tool_test_descriptions(
     profile = tool_source.parse_profile()
     for i, raw_test_dict in enumerate(raw_tests_dict.get("tests", [])):
         validation_exception: Optional[Exception] = None
-        if validate_on_load:
+        request_and_schema: Optional[TestRequestAndSchema] = None
+        try:
             tool_parameter_bundle = input_models_for_tool_source(tool_source)
-            try:
-                case_state(raw_test_dict, tool_parameter_bundle.parameters, profile, validate=True)
-            except Exception as e:
-                # TOOD: restrict types of validation exceptions a bit probably?
-                validation_exception = e
+            validated_test_case = case_state(raw_test_dict, tool_parameter_bundle.parameters, profile, validate=True)
+            request_and_schema = TestRequestAndSchema(
+                validated_test_case.tool_state,
+                tool_parameter_bundle,
+            )
+        except Exception as e:
+            validation_exception = e
 
-        if validation_exception:
+        if validation_exception and validate_on_load:
             tool_id, tool_version = _tool_id_and_version(tool_source, tool_guid)
             test = ToolTestDescription.from_tool_source_dict(
                 InvalidToolTestDict(
@@ -88,13 +96,23 @@ def parse_tool_test_descriptions(
                 )
             )
         else:
-            test = _description_from_tool_source(tool_source, raw_test_dict, i, tool_guid)
+            test = _description_from_tool_source(tool_source, raw_test_dict, i, tool_guid, request_and_schema)
         tests.append(test)
     return tests
 
 
+@dataclass
+class TestRequestAndSchema:
+    request: TestCaseToolState
+    request_schema: ToolParameterBundleModel
+
+
 def _description_from_tool_source(
-    tool_source: ToolSource, raw_test_dict: ToolSourceTest, test_index: int, tool_guid: Optional[str]
+    tool_source: ToolSource,
+    raw_test_dict: ToolSourceTest,
+    test_index: int,
+    tool_guid: Optional[str],
+    request_and_schema: Optional[TestRequestAndSchema],
 ) -> ToolTestDescription:
     required_files: RequiredFilesT = []
     required_data_tables: RequiredDataTablesT = []
@@ -107,6 +125,12 @@ def _description_from_tool_source(
     if maxseconds is not None:
         maxseconds = int(maxseconds)
 
+    request: Optional[Dict[str, Any]] = None
+    request_schema: Optional[Dict[str, Any]] = None
+    if request_and_schema:
+        request = request_and_schema.request.input_state
+        request_schema = request_and_schema.request_schema.dict()
+
     tool_id, tool_version = _tool_id_and_version(tool_source, tool_guid)
     processed_test_dict: Union[ValidToolTestDict, InvalidToolTestDict]
     try:
@@ -121,6 +145,8 @@ def _description_from_tool_source(
         processed_test_dict = ValidToolTestDict(
             {
                 "inputs": processed_inputs,
+                "request": request,
+                "request_schema": request_schema,
                 "outputs": raw_test_dict["outputs"],
                 "output_collections": raw_test_dict["output_collections"],
                 "num_outputs": num_outputs,
@@ -141,7 +167,7 @@ def _description_from_tool_source(
                 "error": False,
             }
         )
-    except Exception as e:
+    except Exception:
         processed_test_dict = InvalidToolTestDict(
             {
                 "tool_id": tool_id,
@@ -149,7 +175,7 @@ def _description_from_tool_source(
                 "test_index": test_index,
                 "inputs": {},
                 "error": True,
-                "exception": unicodify(e),
+                "exception": unicodify(traceback.format_exc()),
                 "maxseconds": maxseconds,
             }
         )
diff --git a/lib/galaxy/tool_util/version_util.py b/lib/galaxy/tool_util/version_util.py
new file mode 100644
index 000000000000..644d58297e4f
--- /dev/null
+++ b/lib/galaxy/tool_util/version_util.py
@@ -0,0 +1,10 @@
+from typing import Union
+
+from packaging.version import Version
+
+from .version import LegacyVersion
+
+AnyVersionT = Union[LegacyVersion, Version]
+
+
+__all__ = ["AnyVersionT"]
diff --git a/lib/galaxy/tool_util/workflow_state/__init__.py b/lib/galaxy/tool_util/workflow_state/__init__.py
new file mode 100644
index 000000000000..9ae61481fe1c
--- /dev/null
+++ b/lib/galaxy/tool_util/workflow_state/__init__.py
@@ -0,0 +1,23 @@
+"""Abstractions for reasoning about tool state within Galaxy workflows.
+
+Like everything else in galaxy-tool-util, this package should be independent of
+Galaxy's runtime. It is meant to provide utilities for reasonsing about tool state
+(largely building on the abstractions in galaxy.tool_util.parameters) within the
+context of workflows.
+"""
+
+from ._types import GetToolInfo
+from .convert import (
+    ConversionValidationFailure,
+    convert_state_to_format2,
+    Format2State,
+)
+from .validation import validate_workflow
+
+__all__ = (
+    "ConversionValidationFailure",
+    "convert_state_to_format2",
+    "GetToolInfo",
+    "Format2State",
+    "validate_workflow",
+)
diff --git a/lib/galaxy/tool_util/workflow_state/_types.py b/lib/galaxy/tool_util/workflow_state/_types.py
new file mode 100644
index 000000000000..cf91508624b5
--- /dev/null
+++ b/lib/galaxy/tool_util/workflow_state/_types.py
@@ -0,0 +1,28 @@
+from typing import (
+    Any,
+    Dict,
+    Optional,
+    Union,
+)
+
+from typing_extensions import (
+    Literal,
+    Protocol,
+)
+
+from galaxy.tool_util.models import ParsedTool
+
+NativeWorkflowDict = Dict[str, Any]
+Format2WorkflowDict = Dict[str, Any]
+AnyWorkflowDict = Union[NativeWorkflowDict, Format2WorkflowDict]
+WorkflowFormat = Literal["gxformat2", "native"]
+NativeStepDict = Dict[str, Any]
+Format2StepDict = Dict[str, Any]
+NativeToolStateDict = Dict[str, Any]
+Format2StateDict = Dict[str, Any]
+
+
+class GetToolInfo(Protocol):
+    """An interface for fetching tool information for steps in a workflow."""
+
+    def get_tool_info(self, tool_id: str, tool_version: Optional[str]) -> ParsedTool: ...
diff --git a/lib/galaxy/tool_util/workflow_state/convert.py b/lib/galaxy/tool_util/workflow_state/convert.py
new file mode 100644
index 000000000000..37f0c8702bb8
--- /dev/null
+++ b/lib/galaxy/tool_util/workflow_state/convert.py
@@ -0,0 +1,131 @@
+from typing import (
+    Dict,
+    List,
+    Optional,
+)
+
+from pydantic import (
+    BaseModel,
+    Field,
+)
+
+from galaxy.tool_util.models import ParsedTool
+from galaxy.tool_util.parameters import ToolParameterT
+from ._types import (
+    Format2StateDict,
+    GetToolInfo,
+    NativeStepDict,
+)
+from .validation_format2 import validate_step_against
+from .validation_native import (
+    get_parsed_tool_for_native_step,
+    native_tool_state,
+    validate_native_step_against,
+)
+
+Format2InputsDictT = Dict[str, str]
+
+
+class Format2State(BaseModel):
+    state: Format2StateDict
+    inputs: Format2InputsDictT = Field(alias="in")
+
+
+class ConversionValidationFailure(Exception):
+    pass
+
+
+def convert_state_to_format2(native_step_dict: NativeStepDict, get_tool_info: GetToolInfo) -> Format2State:
+    parsed_tool = get_parsed_tool_for_native_step(native_step_dict, get_tool_info)
+    return convert_state_to_format2_using(native_step_dict, parsed_tool)
+
+
+def convert_state_to_format2_using(native_step_dict: NativeStepDict, parsed_tool: Optional[ParsedTool]) -> Format2State:
+    """Create a "clean" gxformat2 workflow tool state from a native workflow step.
+
+    gxformat2 does not know about tool specifications so it cannot reason about the native
+    tool state attribute and just copies it as is. This native state can be pretty ugly. The purpose
+    of this function is to build a cleaned up state to replace the gxformat2 copied native tool_state
+    with that is more readable and has stronger typing by using the tool's inputs to guide
+    the conversion (the parsed_tool parameter).
+
+    This method validates both the native tool state and the resulting gxformat2 tool state
+    so that we can be more confident the conversion doesn't corrupt the workflow. If no meta
+    model to validate against is supplied or if either validation fails this method throws
+    ConversionValidationFailure to signal the caller to just use the native tool state as is
+    instead of trying to convert it to a cleaner gxformat2 tool state - under the assumption
+    it is better to have an "ugly" workflow than a corrupted one during conversion.
+    """
+    if parsed_tool is None:
+        raise ConversionValidationFailure("Could not resolve tool inputs")
+    try:
+        validate_native_step_against(native_step_dict, parsed_tool)
+    except Exception:
+        raise ConversionValidationFailure(
+            "Failed to validate native step - not going to convert a tool state that isn't understood"
+        )
+    result = _convert_valid_state_to_format2(native_step_dict, parsed_tool)
+    print(result.dict())
+    try:
+        validate_step_against(result.dict(), parsed_tool)
+    except Exception:
+        raise ConversionValidationFailure(
+            "Failed to validate resulting cleaned step - not going to convert to an unvalidated tool state"
+        )
+    return result
+
+
+def _convert_valid_state_to_format2(native_step_dict: NativeStepDict, parsed_tool: ParsedTool) -> Format2State:
+    format2_state: Format2StateDict = {}
+    format2_in: Format2InputsDictT = {}
+
+    root_tool_state = native_tool_state(native_step_dict)
+    tool_inputs = parsed_tool.inputs
+    _convert_state_level(native_step_dict, tool_inputs, root_tool_state, format2_state, format2_in)
+    return Format2State(
+        **{
+            "state": format2_state,
+            "in": format2_in,
+        }
+    )
+
+
+def _convert_state_level(
+    step: NativeStepDict,
+    tool_inputs: List[ToolParameterT],
+    native_state: dict,
+    format2_state_at_level: dict,
+    format2_in: Format2InputsDictT,
+    prefix: Optional[str] = None,
+) -> None:
+    prefix = prefix or ""
+    assert prefix is not None
+    for tool_input in tool_inputs:
+        _convert_state_at_level(step, tool_input, native_state, format2_state_at_level, format2_in, prefix)
+
+
+def _convert_state_at_level(
+    step: NativeStepDict,
+    tool_input: ToolParameterT,
+    native_state_at_level: dict,
+    format2_state_at_level: dict,
+    format2_in: Format2InputsDictT,
+    prefix: str,
+) -> None:
+    parameter_type = tool_input.parameter_type
+    parameter_name = tool_input.name
+    value = native_state_at_level.get(parameter_name, None)
+    state_path = parameter_name if prefix is None else f"{prefix}|{parameter_name}"
+    if parameter_type == "gx_integer":
+        # check for runtime input
+        format2_value = int(value)
+        format2_state_at_level[parameter_name] = format2_value
+    elif parameter_type == "gx_data":
+        input_connections = step.get("input_connections", {})
+        print(state_path)
+        print(input_connections)
+        if state_path in input_connections:
+            format2_in[state_path] = "placeholder"
+    else:
+        pass
+        # raise NotImplementedError(f"Unhandled parameter type {parameter_type}")
diff --git a/lib/galaxy/tool_util/workflow_state/validation.py b/lib/galaxy/tool_util/workflow_state/validation.py
new file mode 100644
index 000000000000..56a225fbb8f8
--- /dev/null
+++ b/lib/galaxy/tool_util/workflow_state/validation.py
@@ -0,0 +1,21 @@
+from ._types import (
+    AnyWorkflowDict,
+    GetToolInfo,
+    WorkflowFormat,
+)
+from .validation_format2 import validate_workflow_format2
+from .validation_native import validate_workflow_native
+
+
+def validate_workflow(workflow_dict: AnyWorkflowDict, get_tool_info: GetToolInfo):
+    if _format(workflow_dict) == "gxformat2":
+        validate_workflow_format2(workflow_dict, get_tool_info)
+    else:
+        validate_workflow_native(workflow_dict, get_tool_info)
+
+
+def _format(workflow_dict: AnyWorkflowDict) -> WorkflowFormat:
+    if workflow_dict.get("a_galaxy_workflow") == "true":
+        return "native"
+    else:
+        return "gxformat2"
diff --git a/lib/galaxy/tool_util/workflow_state/validation_format2.py b/lib/galaxy/tool_util/workflow_state/validation_format2.py
new file mode 100644
index 000000000000..160576c3abe7
--- /dev/null
+++ b/lib/galaxy/tool_util/workflow_state/validation_format2.py
@@ -0,0 +1,142 @@
+from typing import (
+    cast,
+    Optional,
+)
+
+from gxformat2.model import (
+    get_native_step_type,
+    pop_connect_from_step_dict,
+    setup_connected_values,
+    steps_as_list,
+)
+
+from galaxy.tool_util.models import ParsedTool
+from galaxy.tool_util.parameters import (
+    ConditionalParameterModel,
+    ConditionalWhen,
+    flat_state_path,
+    keys_starting_with,
+    repeat_inputs_to_array,
+    RepeatParameterModel,
+    ToolParameterT,
+    validate_explicit_conditional_test_value,
+    WorkflowStepLinkedToolState,
+    WorkflowStepToolState,
+)
+from ._types import (
+    Format2StepDict,
+    Format2WorkflowDict,
+    GetToolInfo,
+)
+
+
+def validate_workflow_format2(workflow_dict: Format2WorkflowDict, get_tool_info: GetToolInfo):
+    steps = steps_as_list(workflow_dict)
+    for step in steps:
+        validate_step_format2(step, get_tool_info)
+
+
+def validate_step_format2(step_dict: Format2StepDict, get_tool_info: GetToolInfo):
+    step_type = get_native_step_type(step_dict)
+    if step_type != "tool":
+        return
+    tool_id = cast(str, step_dict.get("tool_id"))
+    tool_version: Optional[str] = cast(Optional[str], step_dict.get("tool_version"))
+    parsed_tool = get_tool_info.get_tool_info(tool_id, tool_version)
+    if parsed_tool is not None:
+        validate_step_against(step_dict, parsed_tool)
+
+
+def validate_step_against(step_dict: Format2StepDict, parsed_tool: ParsedTool):
+    source_tool_state_model = WorkflowStepToolState.parameter_model_for(parsed_tool.inputs)
+    linked_tool_state_model = WorkflowStepLinkedToolState.parameter_model_for(parsed_tool.inputs)
+    contains_format2_state = "state" in step_dict
+    contains_native_state = "tool_state" in step_dict
+    if contains_format2_state:
+        assert source_tool_state_model
+        source_tool_state_model.model_validate(step_dict["state"])
+    if not contains_native_state:
+        if not contains_format2_state:
+            step_dict["state"] = {}
+        # setup links and then validate against model...
+        linked_step = merge_inputs(step_dict, parsed_tool)
+        linked_tool_state_model.model_validate(linked_step["state"])
+
+
+def merge_inputs(step_dict: Format2StepDict, parsed_tool: ParsedTool) -> Format2StepDict:
+    connect = pop_connect_from_step_dict(step_dict)
+    step_dict = setup_connected_values(step_dict, connect)
+    tool_inputs = parsed_tool.inputs
+
+    state_at_level = step_dict["state"]
+
+    for tool_input in tool_inputs:
+        _merge_into_state(connect, tool_input, state_at_level)
+
+    for key in connect:
+        raise Exception(f"Failed to find parameter definition matching workflow linked key {key}")
+    return step_dict
+
+
+def _merge_into_state(
+    connect, tool_input: ToolParameterT, state: dict, prefix: Optional[str] = None, branch_connect=None
+):
+    if branch_connect is None:
+        branch_connect = connect
+
+    name = tool_input.name
+    parameter_type = tool_input.parameter_type
+    state_path = flat_state_path(name, prefix)
+    if parameter_type == "gx_conditional":
+        conditional_state = state.get(name, {})
+        if name not in state:
+            state[name] = conditional_state
+
+        conditional = cast(ConditionalParameterModel, tool_input)
+        when: ConditionalWhen = _select_which_when(conditional, conditional_state)
+        test_parameter = conditional.test_parameter
+        conditional_connect = keys_starting_with(branch_connect, state_path)
+        _merge_into_state(
+            connect, test_parameter, conditional_state, prefix=state_path, branch_connect=conditional_connect
+        )
+        for when_parameter in when.parameters:
+            _merge_into_state(
+                connect, when_parameter, conditional_state, prefix=state_path, branch_connect=conditional_connect
+            )
+    elif parameter_type == "gx_repeat":
+        repeat_state_array = state.get(name, [])
+        repeat = cast(RepeatParameterModel, tool_input)
+        repeat_instance_connects = repeat_inputs_to_array(state_path, connect)
+        for i, repeat_instance_connect in enumerate(repeat_instance_connects):
+            while len(repeat_state_array) <= i:
+                repeat_state_array.append({})
+
+            repeat_instance_prefix = f"{state_path}_{i}"
+            for repeat_parameter in repeat.parameters:
+                _merge_into_state(
+                    connect,
+                    repeat_parameter,
+                    repeat_state_array[i],
+                    prefix=repeat_instance_prefix,
+                    branch_connect=repeat_instance_connect,
+                )
+        if repeat_state_array and name not in state:
+            state[name] = repeat_state_array
+    else:
+        if state_path in branch_connect:
+            state[name] = {"__class__": "ConnectedValue"}
+            del connect[state_path]
+
+
+def _select_which_when(conditional: ConditionalParameterModel, state: dict) -> ConditionalWhen:
+    test_parameter = conditional.test_parameter
+    test_parameter_name = test_parameter.name
+    explicit_test_value = state.get(test_parameter_name)
+    test_value = validate_explicit_conditional_test_value(test_parameter_name, explicit_test_value)
+    for when in conditional.whens:
+        if test_value is None and when.is_default_when:
+            return when
+        elif test_value == when.discriminator:
+            return when
+    else:
+        raise Exception(f"Invalid conditional test value ({explicit_test_value}) for parameter ({test_parameter_name})")
diff --git a/lib/galaxy/tool_util/workflow_state/validation_native.py b/lib/galaxy/tool_util/workflow_state/validation_native.py
new file mode 100644
index 000000000000..ae08d15b4226
--- /dev/null
+++ b/lib/galaxy/tool_util/workflow_state/validation_native.py
@@ -0,0 +1,211 @@
+import json
+from typing import (
+    cast,
+    List,
+    Optional,
+)
+
+from galaxy.tool_util.models import ParsedTool
+from galaxy.tool_util.parameters import (
+    ConditionalParameterModel,
+    ConditionalWhen,
+    flat_state_path,
+    is_optional,
+    repeat_inputs_to_array,
+    RepeatParameterModel,
+    SelectParameterModel,
+    ToolParameterT,
+    validate_explicit_conditional_test_value,
+)
+from ._types import (
+    GetToolInfo,
+    NativeStepDict,
+    NativeToolStateDict,
+    NativeWorkflowDict,
+)
+
+
+def validate_native_step_against(step: NativeStepDict, parsed_tool: ParsedTool):
+    tool_state_jsonified = step.get("tool_state")
+    assert tool_state_jsonified
+    tool_state = json.loads(tool_state_jsonified)
+    tool_inputs = parsed_tool.inputs
+
+    # merge input connections into ConnectedValues if there aren't already there...
+    _merge_inputs_into_state_dict(step, tool_inputs, tool_state)
+
+    allowed_extra_keys = ["__page__", "__rerun_remap_job_id__"]
+    _validate_native_state_level(step, tool_inputs, tool_state, allowed_extra_keys=allowed_extra_keys)
+
+
+def _validate_native_state_level(
+    step: NativeStepDict, tool_inputs: List[ToolParameterT], state_at_level: dict, allowed_extra_keys=None
+):
+    if allowed_extra_keys is None:
+        allowed_extra_keys = []
+
+    keys_processed = set()
+    for tool_input in tool_inputs:
+        parameter_name = tool_input.name
+        keys_processed.add(parameter_name)
+        _validate_native_state_at_level(step, tool_input, state_at_level)
+
+    for key in state_at_level.keys():
+        if key not in keys_processed and key not in allowed_extra_keys:
+            raise Exception(f"Unknown key found {key}, failing state validation")
+
+
+def _validate_native_state_at_level(
+    step: NativeStepDict, tool_input: ToolParameterT, state_at_level: dict, prefix: Optional[str] = None
+):
+    parameter_type = tool_input.parameter_type
+    parameter_name = tool_input.name
+    value = state_at_level.get(parameter_name, None)
+    # state_path = parameter_name if prefix is None else f"{prefix}|{parameter_name}"
+    if parameter_type == "gx_integer":
+        try:
+            int(value)
+        except ValueError:
+            raise Exception(f"Invalid integer data found {value}")
+    elif parameter_type in ["gx_data", "gx_data_collection"]:
+        if isinstance(value, dict):
+            assert "__class__" in value
+            assert value["__class__"] in ["RuntimeValue", "ConnectedValue"]
+        else:
+            assert value in [None, "null"]
+            connections = native_connections_for(step, tool_input, prefix)
+            optional = is_optional(tool_input)
+            if not optional and not connections:
+                raise Exception(
+                    "Disconnected non-optional input found, not attempting to validate non-practice workflow"
+                )
+
+    elif parameter_type == "gx_select":
+        select = cast(SelectParameterModel, tool_input)
+        options = select.options
+        if options is not None:
+            valid_values = [o.value for o in options]
+            if value not in valid_values:
+                raise Exception(f"Invalid select option found {value}")
+    elif parameter_type == "gx_conditional":
+        conditional_state = state_at_level.get(parameter_name, None)
+        conditional = cast(ConditionalParameterModel, tool_input)
+        when: ConditionalWhen = _select_which_when_native(conditional, conditional_state)
+        test_parameter = conditional.test_parameter
+        test_parameter_name = test_parameter.name
+        _validate_native_state_at_level(step, test_parameter, conditional_state)
+        _validate_native_state_level(
+            step, when.parameters, conditional_state, allowed_extra_keys=["__current_case__", test_parameter_name]
+        )
+    else:
+        raise NotImplementedError(f"Unhandled parameter type ({parameter_type})")
+
+
+def _select_which_when_native(conditional: ConditionalParameterModel, conditional_state: dict) -> ConditionalWhen:
+    test_parameter = conditional.test_parameter
+    test_parameter_name = test_parameter.name
+    explicit_test_value = conditional_state.get(test_parameter_name)
+    test_value = validate_explicit_conditional_test_value(test_parameter_name, explicit_test_value)
+    target_when = None
+    for when in conditional.whens:
+        # deal with native string -> bool issues in here...
+        if test_value is None and when.is_default_when:
+            target_when = when
+        elif test_value == when.discriminator:
+            target_when = when
+
+    recorded_case = conditional_state.get("__current_case__")
+    if recorded_case is not None:
+        if not isinstance(recorded_case, int):
+            raise Exception(f"Unknown type of value for __current_case__ encountered {recorded_case}")
+        if recorded_case < 0 or recorded_case >= len(conditional.whens):
+            raise Exception(f"Unknown index value for __current_case__ encountered {recorded_case}")
+        recorded_when = conditional.whens[recorded_case]
+
+    if target_when is None:
+        raise Exception("is this okay? I need more tests")
+    if target_when and recorded_when and target_when != recorded_when:
+        raise Exception(
+            f"Problem parsing out tool state - inferred conflicting tool states for parameter {test_parameter_name}"
+        )
+    return target_when
+
+
+def _merge_inputs_into_state_dict(
+    step_dict: NativeStepDict, tool_inputs: List[ToolParameterT], state_at_level: dict, prefix: Optional[str] = None
+):
+    for tool_input in tool_inputs:
+        _merge_into_state(step_dict, tool_input, state_at_level, prefix=prefix)
+
+
+def _merge_into_state(step_dict: NativeStepDict, tool_input: ToolParameterT, state: dict, prefix: Optional[str] = None):
+    name = tool_input.name
+    parameter_type = tool_input.parameter_type
+    state_path = flat_state_path(name, prefix)
+    if parameter_type == "gx_conditional":
+        conditional_state = state.get(name, {})
+        if name not in state:
+            state[name] = conditional_state
+
+        conditional = cast(ConditionalParameterModel, tool_input)
+        when: ConditionalWhen = _select_which_when_native(conditional, conditional_state)
+        test_parameter = conditional.test_parameter
+        _merge_into_state(step_dict, test_parameter, conditional_state, prefix=state_path)
+        for when_parameter in when.parameters:
+            _merge_into_state(step_dict, when_parameter, conditional_state, prefix=state_path)
+    elif parameter_type == "gx_repeat":
+        repeat_state_array = state.get(name, [])
+        repeat = cast(RepeatParameterModel, tool_input)
+        repeat_instance_connects = repeat_inputs_to_array(state_path, step_dict)
+        for i, _ in enumerate(repeat_instance_connects):
+            while len(repeat_state_array) <= i:
+                repeat_state_array.append({})
+
+            repeat_instance_prefix = f"{state_path}_{i}"
+            for repeat_parameter in repeat.parameters:
+                _merge_into_state(
+                    step_dict,
+                    repeat_parameter,
+                    repeat_state_array[i],
+                    prefix=repeat_instance_prefix,
+                )
+        if repeat_state_array and name not in state:
+            state[name] = repeat_state_array
+    else:
+        input_connections = step_dict.get("input_connections", {})
+        if state_path in input_connections and state.get(name) is None:
+            state[name] = {"__class__": "ConnectedValue"}
+
+
+def validate_step_native(step: NativeStepDict, get_tool_info: GetToolInfo):
+    parsed_tool = get_parsed_tool_for_native_step(step, get_tool_info)
+    if parsed_tool is not None:
+        validate_native_step_against(step, parsed_tool)
+
+
+def get_parsed_tool_for_native_step(step: NativeStepDict, get_tool_info: GetToolInfo) -> Optional[ParsedTool]:
+    tool_id = cast(str, step.get("tool_id"))
+    if not tool_id:
+        return None
+    tool_version: Optional[str] = cast(Optional[str], step.get("tool_version"))
+    parsed_tool = get_tool_info.get_tool_info(tool_id, tool_version)
+    return parsed_tool
+
+
+def validate_workflow_native(workflow_dict: NativeWorkflowDict, get_tool_info: GetToolInfo):
+    for step_def in workflow_dict["steps"].values():
+        validate_step_native(step_def, get_tool_info)
+
+
+def native_tool_state(step: NativeStepDict) -> NativeToolStateDict:
+    tool_state_jsonified = step.get("tool_state")
+    assert tool_state_jsonified
+    tool_state = json.loads(tool_state_jsonified)
+    return tool_state
+
+
+def native_connections_for(step: NativeStepDict, parameter: ToolParameterT, prefix: Optional[str]):
+    parameter_name = parameter.name
+    state_path = parameter_name if prefix is None else f"{prefix}|{parameter_name}"
+    step.get("input_connections", {})
+    return step.get(state_path)
diff --git a/lib/galaxy/tools/__init__.py b/lib/galaxy/tools/__init__.py
index a7b6c96bc1f3..9a2d8238c6f9 100644
--- a/lib/galaxy/tools/__init__.py
+++ b/lib/galaxy/tools/__init__.py
@@ -49,6 +49,7 @@
 from galaxy.model import (
     Job,
     StoredWorkflow,
+    ToolRequest,
 )
 from galaxy.model.base import transaction
 from galaxy.model.dataset_collections.matching import MatchingCollections
@@ -71,6 +72,13 @@
     expand_ontology_data,
 )
 from galaxy.tool_util.output_checker import DETECTED_JOB_STATE
+from galaxy.tool_util.parameters import (
+    fill_static_defaults,
+    input_models_for_pages,
+    JobInternalToolState,
+    RequestInternalDereferencedToolState,
+    ToolParameterBundle,
+)
 from galaxy.tool_util.parser import (
     get_tool_source,
     get_tool_source_from_representation,
@@ -95,16 +103,15 @@
 from galaxy.tool_util.toolbox import (
     AbstractToolBox,
     AbstractToolTagManager,
+    ToolLoadError,
     ToolSection,
 )
 from galaxy.tool_util.toolbox.views.sources import StaticToolBoxViewSources
 from galaxy.tool_util.verify.interactor import ToolTestDescription
 from galaxy.tool_util.verify.parse import parse_tool_test_descriptions
 from galaxy.tool_util.verify.test_data import TestDataNotFoundError
-from galaxy.tool_util.version import (
-    LegacyVersion,
-    parse_version,
-)
+from galaxy.tool_util.version import parse_version
+from galaxy.tool_util.version_util import AnyVersionT
 from galaxy.tools import expressions
 from galaxy.tools.actions import (
     DefaultToolAction,
@@ -117,7 +124,7 @@
 from galaxy.tools.evaluation import global_tool_errors
 from galaxy.tools.execution_helpers import ToolExecutionCache
 from galaxy.tools.imp_exp import JobImportHistoryArchiveWrapper
-from galaxy.tools.parameters import (
+from galaxy.tools.parameters import (  # fill_dynamic_defaults,
     check_param,
     params_from_strings,
     params_to_incoming,
@@ -125,6 +132,7 @@
     params_to_json_internal,
     params_to_strings,
     populate_state,
+    populate_state_async,
     visit_input_values,
 )
 from galaxy.tools.parameters.basic import (
@@ -152,7 +160,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_async,
+)
 from galaxy.tools.parameters.workflow_utils import workflow_building_modes
 from galaxy.tools.parameters.wrapped_json import json_wrap
 from galaxy.util import (
@@ -207,7 +218,8 @@
     DEFAULT_RERUN_REMAP_JOB_ID,
     DEFAULT_SET_OUTPUT_HID,
     DEFAULT_USE_CACHED_JOB,
-    execute as execute_job,
+    execute as execute_sync,
+    execute_async,
     ExecutionSlice,
     JobCallbackT,
     MappingParameters,
@@ -328,8 +340,8 @@
 
 
 class safe_update(NamedTuple):
-    min_version: Union[LegacyVersion, Version]
-    current_version: Union[LegacyVersion, Version]
+    min_version: AnyVersionT
+    current_version: AnyVersionT
 
 
 # Tool updates that did not change parameters in a way that requires rebuilding workflows
@@ -380,7 +392,10 @@ def create_tool_from_source(app, tool_source: ToolSource, config_file: Optional[
     elif tool_type := tool_source.parse_tool_type():
         ToolClass = tool_types.get(tool_type)
         if not ToolClass:
-            raise ValueError(f"Unrecognized tool type: {tool_type}")
+            if tool_type == "cwl":
+                raise ToolLoadError("Runtime support for CWL tools is not implemented currently")
+            else:
+                raise ToolLoadError(f"Parsed unrecognized tool type ({tool_type}) from tool")
     else:
         # Normal tool
         root = getattr(tool_source, "root", None)
@@ -757,7 +772,7 @@ class _Options(Bunch):
     refresh: str
 
 
-class Tool(UsesDictVisibleKeys):
+class Tool(UsesDictVisibleKeys, ToolParameterBundle):
     """
     Represents a computational tool that can be executed through Galaxy.
     """
@@ -1426,6 +1441,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:
+            parameters = input_models_for_pages(pages, self.profile)
+            self.parameters = parameters
+        except Exception:
+            pass
         if pages.inputs_defined:
             if hasattr(pages, "input_elem"):
                 input_elem = pages.input_elem
@@ -1817,6 +1837,62 @@ def visit_inputs(self, values, callback):
         if self.check_values:
             visit_input_values(self.inputs, values, callback)
 
+    def expand_incoming_async(
+        self,
+        request_context: WorkRequestContext,
+        tool_request_internal_state: RequestInternalDereferencedToolState,
+        rerun_remap_job_id: Optional[int],
+    ) -> Tuple[
+        List[ToolStateJobInstancePopulatedT],
+        List[ToolStateJobInstancePopulatedT],
+        Optional[MatchingCollections],
+        List[JobInternalToolState],
+    ]:
+        """The tool request API+tasks version of expand_incoming.
+
+        This is responsible for breaking the map over job requests into individual jobs for execution.
+        """
+        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,
+            )
+
+        set_dataset_matcher_factory(request_context, self)
+
+        job_tool_states: List[ToolStateJobInstanceT]
+        collection_info: Optional[MatchingCollections]
+        job_tool_states, collection_info = expand_meta_parameters_async(
+            request_context.app, self, tool_request_internal_state
+        )
+
+        self._ensure_expansion_is_valid(job_tool_states, rerun_remap_job_id)
+
+        # 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 = []
+        all_params: List[ToolStateJobInstancePopulatedT] = []
+        internal_states: List[JobInternalToolState] = []
+        for expanded_incoming in job_tool_states:
+            log.info(f"expanded_incoming before fill static defaults: {expanded_incoming}")
+            expanded_incoming = fill_static_defaults(expanded_incoming, self, self.profile)
+            log.info(f"expanded_incoming before populate: {expanded_incoming}")
+            params, errors = self._populate_async(request_context, expanded_incoming)
+            log.info(f"expanded_incoming after: {expanded_incoming}")
+            internal_tool_state = JobInternalToolState(expanded_incoming)
+            internal_tool_state.validate(self)
+
+            internal_states.append(internal_tool_state)
+            all_errors.append(errors)
+            all_params.append(params)
+        unset_dataset_matcher_factory(request_context)
+
+        log.info(validation_timer)
+        return all_params, all_errors, collection_info, internal_states
+
     def expand_incoming(
         self, request_context: WorkRequestContext, incoming: ToolRequestT, input_format: InputFormatT = "legacy"
     ) -> Tuple[
@@ -1832,7 +1908,9 @@ def expand_incoming(
         # Expand these out to individual parameters for given jobs (tool executions).
         expanded_incomings: List[ToolStateJobInstanceT]
         collection_info: Optional[MatchingCollections]
-        expanded_incomings, collection_info = expand_meta_parameters(request_context, self, incoming)
+        expanded_incomings, collection_info = expand_meta_parameters(
+            request_context, self, incoming, input_format=input_format
+        )
 
         self._ensure_expansion_is_valid(expanded_incomings, rerun_remap_job_id)
 
@@ -1854,7 +1932,9 @@ def expand_incoming(
         return all_params, all_errors, rerun_remap_job_id, collection_info
 
     def _ensure_expansion_is_valid(
-        self, expanded_incomings: List[ToolStateJobInstanceT], rerun_remap_job_id: Optional[int]
+        self,
+        expanded_incomings: Union[List[JobInternalToolState], List[ToolStateJobInstanceT]],
+        rerun_remap_job_id: Optional[int],
     ) -> None:
         """If the request corresponds to multiple jobs but this doesn't work with request configuration - raise an error.
 
@@ -1900,17 +1980,48 @@ def _populate(
                 simple_errors=False,
                 input_format=input_format,
             )
-            # If the tool provides a `validate_input` hook, call it.
-            validate_input = self.get_hook("validate_input")
-            if validate_input:
-                # hooks are so terrible ... this is specifically for https://github.com/galaxyproject/tools-devteam/blob/main/tool_collections/gops/basecoverage/operation_filter.py
-                legacy_non_dce_params = {
-                    k: v.hda if isinstance(v, model.DatasetCollectionElement) and v.hda else v
-                    for k, v in params.items()
-                }
-                validate_input(request_context, errors, legacy_non_dce_params, self.inputs)
+            self._handle_validate_input_hook(request_context, params, errors)
+        return params, errors
+
+    def _populate_async(
+        self, request_context, expanded_incoming: ToolStateJobInstanceT
+    ) -> Tuple[ToolStateJobInstancePopulatedT, ParameterValidationErrorsT]:
+        """Validate expanded parameters for a job to replace references with model objects.
+
+        So convert a ToolStateJobInstanceT to a ToolStateJobInstancePopulatedT.
+        """
+        params: ToolStateJobInstancePopulatedT = {}
+        errors: ParameterValidationErrorsT = {}
+        if self.input_translator:
+            self.input_translator.translate(expanded_incoming)
+        if not self.check_values:
+            # If `self.check_values` is false we don't do any checking or
+            # processing on input  This is used to pass raw values
+            # through to/from external sites.
+            params = cast(ToolStateJobInstancePopulatedT, expanded_incoming)
+        else:
+            populate_state_async(
+                request_context,
+                self.inputs,
+                expanded_incoming,
+                params,
+                errors,
+            )
+            self._handle_validate_input_hook(request_context, params, errors)
         return params, errors
 
+    def _handle_validate_input_hook(
+        self, request_context, params: ToolStateJobInstancePopulatedT, errors: ParameterValidationErrorsT
+    ):
+        # If the tool provides a `validate_input` hook, call it.
+        validate_input = self.get_hook("validate_input")
+        if validate_input:
+            # hooks are so terrible ... this is specifically for https://github.com/galaxyproject/tools-devteam/blob/main/tool_collections/gops/basecoverage/operation_filter.py
+            legacy_non_dce_params = {
+                k: v.hda if isinstance(v, model.DatasetCollectionElement) and v.hda else v for k, v in params.items()
+            }
+            validate_input(request_context, errors, legacy_non_dce_params, self.inputs)
+
     def completed_jobs(
         self, trans, use_cached_job: bool, all_params: List[ToolStateJobInstancePopulatedT]
     ) -> Dict[int, Optional[model.Job]]:
@@ -1932,6 +2043,39 @@ def completed_jobs(
                 completed_jobs[i] = None
         return completed_jobs
 
+    def handle_input_async(
+        self,
+        request_context: WorkRequestContext,
+        tool_request: ToolRequest,
+        tool_state: RequestInternalDereferencedToolState,
+        history: Optional[model.History] = None,
+        use_cached_job: bool = DEFAULT_USE_CACHED_JOB,
+        preferred_object_store_id: Optional[str] = DEFAULT_PREFERRED_OBJECT_STORE_ID,
+        rerun_remap_job_id: Optional[int] = None,
+        input_format: str = "legacy",
+    ):
+        """The tool request API+tasks version of handle_input."""
+        all_params, all_errors, collection_info, job_tool_states = self.expand_incoming_async(
+            request_context, tool_state, rerun_remap_job_id
+        )
+        self.handle_incoming_errors(all_errors)
+
+        mapping_params = MappingParameters(tool_request.request, all_params, tool_state, job_tool_states)
+        completed_jobs: Dict[int, Optional[model.Job]] = self.completed_jobs(
+            request_context, use_cached_job, all_params
+        )
+        execute_async(
+            request_context,
+            self,
+            mapping_params,
+            request_context.history,
+            tool_request,
+            completed_jobs,
+            rerun_remap_job_id=rerun_remap_job_id,
+            preferred_object_store_id=preferred_object_store_id,
+            collection_info=collection_info,
+        )
+
     def handle_input(
         self,
         trans,
@@ -1957,9 +2101,9 @@ def handle_input(
         # If there were errors, we stay on the same page and display them
         self.handle_incoming_errors(all_errors)
 
-        mapping_params = MappingParameters(incoming, all_params)
+        mapping_params = MappingParameters(incoming, all_params, None, None)
         completed_jobs: Dict[int, Optional[model.Job]] = self.completed_jobs(trans, use_cached_job, all_params)
-        execution_tracker = execute_job(
+        execution_tracker = execute_sync(
             trans,
             self,
             mapping_params,
@@ -3227,9 +3371,8 @@ class InteractiveTool(Tool):
     produces_entry_points = True
 
     def __init__(self, config_file, tool_source, app, **kwd):
-        assert app.config.interactivetools_enable, ValueError(
-            "Trying to load an InteractiveTool, but InteractiveTools are not enabled."
-        )
+        if not app.config.interactivetools_enable:
+            raise ToolLoadError("Trying to load an InteractiveTool, but InteractiveTools are not enabled.")
         super().__init__(config_file, tool_source, app, **kwd)
 
     def __remove_interactivetool_by_job(self, job):
diff --git a/lib/galaxy/tools/execute.py b/lib/galaxy/tools/execute.py
index 31369c948052..734033cce91e 100644
--- a/lib/galaxy/tools/execute.py
+++ b/lib/galaxy/tools/execute.py
@@ -24,12 +24,17 @@
 
 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,
+    RequestInternalDereferencedToolState,
+)
 from galaxy.tool_util.parser import ToolOutputCollectionPart
 from galaxy.tools.execution_helpers import (
     filter_output,
@@ -69,8 +74,58 @@ def __init__(self, execution_tracker: "ExecutionTracker"):
 
 
 class MappingParameters(NamedTuple):
+    # the raw request - might correspond to multiple jobs
     param_template: ToolRequestT
+    # parameters corresponding to individual job
     param_combinations: List[ToolStateJobInstancePopulatedT]
+    # schema driven parameters
+    # model validated tool request - might correspond to multiple jobs
+    validated_param_template: Optional[RequestInternalDereferencedToolState] = None
+    # validated job parameters for individual jobs
+    validated_param_combinations: Optional[List[JobInternalToolState]] = None
+
+    def ensure_validated(self):
+        assert self.validated_param_template is not None
+        assert self.validated_param_combinations is not None
+
+
+def execute_async(
+    trans,
+    tool: "Tool",
+    mapping_params: MappingParameters,
+    history: model.History,
+    tool_request: ToolRequest,
+    completed_jobs: Optional[CompletedJobsT] = None,
+    rerun_remap_job_id: Optional[int] = None,
+    preferred_object_store_id: Optional[str] = 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":
+    """The tool request/async version of execute."""
+    completed_jobs = completed_jobs or {}
+    mapping_params.ensure_validated()
+    return _execute(
+        trans,
+        tool,
+        mapping_params,
+        history,
+        tool_request,
+        rerun_remap_job_id,
+        preferred_object_store_id,
+        collection_info,
+        workflow_invocation_uuid,
+        invocation_step,
+        max_num_jobs,
+        job_callback,
+        completed_jobs,
+        workflow_resource_parameters,
+        validate_outputs,
+    )
 
 
 def execute(
@@ -88,12 +143,48 @@ def execute(
     completed_jobs: Optional[CompletedJobsT] = None,
     workflow_resource_parameters: Optional[WorkflowResourceParametersT] = 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,
+        preferred_object_store_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: MappingParameters,
+    history: model.History,
+    tool_request: Optional[model.ToolRequest],
+    rerun_remap_job_id: Optional[int],
+    preferred_object_store_id: Optional[str],
+    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:
@@ -118,8 +209,9 @@ def execute_single_job(execution_slice: "ExecutionSlice", completed_job: Optiona
             "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"]
+        request_state = mapping_params.param_template
+        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:
@@ -148,6 +240,8 @@ def execute_single_job(execution_slice: "ExecutionSlice", completed_job: Optiona
             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
@@ -188,7 +282,11 @@ def execute_single_job(execution_slice: "ExecutionSlice", completed_job: Optiona
             has_remaining_jobs = True
             break
         else:
-            skip = execution_slice.param_combination.pop("__when_value__", None) is False
+            slice_params = execution_slice.param_combination
+            if isinstance(slice_params, JobInternalToolState):
+                slice_params = slice_params.input_state
+
+            skip = slice_params.pop("__when_value__", None) is False
             execute_single_job(execution_slice, completed_jobs[i], skip=skip)
             history = execution_slice.history or history
             jobs_executed += 1
diff --git a/lib/galaxy/tools/parameters/__init__.py b/lib/galaxy/tools/parameters/__init__.py
index 25d6775446f9..cb1022f2e6bb 100644
--- a/lib/galaxy/tools/parameters/__init__.py
+++ b/lib/galaxy/tools/parameters/__init__.py
@@ -12,6 +12,10 @@
 
 from boltons.iterutils import remap
 
+from galaxy.model import (
+    HistoryDatasetAssociation,
+    HistoryDatasetCollectionAssociation,
+)
 from galaxy.util import unicodify
 from galaxy.util.expressions import ExpressionContext
 from galaxy.util.json import safe_loads
@@ -20,6 +24,7 @@
     DataToolParameter,
     ParameterValueError,
     SelectToolParameter,
+    TextToolParameter,
     ToolParameter,
 )
 from .grouping import (
@@ -62,6 +67,8 @@ def visit_input_values(
     context=None,
     no_replacement_value=REPLACE_ON_TRUTHY,
     replace_optional_connections=False,
+    allow_case_inference=False,
+    unset_value=None,
 ):
     """
     Given a tools parameter definition (`inputs`) and a specific set of
@@ -158,7 +165,7 @@ def visit_input_values(
     """
 
     def callback_helper(input, input_values, name_prefix, label_prefix, parent_prefix, context=None, error=None):
-        value = input_values.get(input.name)
+        value = input_values.get(input.name, unset_value)
         args = {
             "input": input,
             "parent": input_values,
@@ -182,13 +189,23 @@ def callback_helper(input, input_values, name_prefix, label_prefix, parent_prefi
             input_values[input.name] = input.value
 
     def get_current_case(input, input_values):
+        test_parameter = input.test_param
+        test_parameter_name = test_parameter.name
         try:
-            return input.get_current_case(input_values[input.test_param.name])
+            if test_parameter_name not in input_values and allow_case_inference:
+                return input.get_current_case(test_parameter.get_initial_value(None, input_values))
+            else:
+                return input.get_current_case(input_values[test_parameter_name])
         except (KeyError, ValueError):
             return -1
 
     context = ExpressionContext(input_values, context)
-    payload = {"context": context, "no_replacement_value": no_replacement_value}
+    payload = {
+        "context": context,
+        "no_replacement_value": no_replacement_value,
+        "allow_case_inference": allow_case_inference,
+        "unset_value": unset_value,
+    }
     for input in inputs.values():
         if isinstance(input, Repeat) or isinstance(input, UploadDataset):
             values = input_values[input.name] = input_values.get(input.name, [])
@@ -389,53 +406,6 @@ def populate_state(
 ):
     """
     Populates nested state dict from incoming parameter values.
-    >>> from galaxy.util import XML
-    >>> from galaxy.util.bunch import Bunch
-    >>> from galaxy.tools.parameters.basic import TextToolParameter, BooleanToolParameter
-    >>> from galaxy.tools.parameters.grouping import Repeat
-    >>> trans = Bunch(workflow_building_mode=False)
-    >>> a = TextToolParameter(None, XML('<param name="a"/>'))
-    >>> b = Repeat('b')
-    >>> b.min = 0
-    >>> b.max = 1
-    >>> c = TextToolParameter(None, XML('<param name="c"/>'))
-    >>> d = Repeat('d')
-    >>> d.min = 0
-    >>> d.max = 1
-    >>> e = TextToolParameter(None, XML('<param name="e"/>'))
-    >>> f = Conditional('f')
-    >>> g = BooleanToolParameter(None, XML('<param name="g"/>'))
-    >>> h = TextToolParameter(None, XML('<param name="h"/>'))
-    >>> i = TextToolParameter(None, XML('<param name="i"/>'))
-    >>> b.inputs = dict([('c', c), ('d', d)])
-    >>> d.inputs = dict([('e', e), ('f', f)])
-    >>> f.test_param = g
-    >>> f.cases = [Bunch(value='true', inputs= { 'h': h }), Bunch(value='false', inputs= { 'i': i })]
-    >>> inputs = dict([('a',a),('b',b)])
-    >>> flat = dict([('a', 1), ('b_0|c', 2), ('b_0|d_0|e', 3), ('b_0|d_0|f|h', 4), ('b_0|d_0|f|g', True)])
-    >>> state = {}
-    >>> populate_state(trans, inputs, flat, state, check=False)
-    >>> print(state['a'])
-    1
-    >>> print(state['b'][0]['c'])
-    2
-    >>> print(state['b'][0]['d'][0]['e'])
-    3
-    >>> print(state['b'][0]['d'][0]['f']['h'])
-    4
-    >>> # now test with input_format='21.01'
-    >>> nested = {'a': 1, 'b': [{'c': 2, 'd': [{'e': 3, 'f': {'h': 4, 'g': True}}]}]}
-    >>> state_new = {}
-    >>> populate_state(trans, inputs, nested, state_new, check=False, input_format='21.01')
-    >>> print(state_new['a'])
-    1
-    >>> print(state_new['b'][0]['c'])
-    2
-    >>> print(state_new['b'][0]['d'][0]['e'])
-    3
-    >>> print(state_new['b'][0]['d'][0]['f']['h'])
-    4
-
     """
     if errors is None:
         errors = {}
@@ -501,10 +471,13 @@ def populate_state(
                         current_case = conditional_input.get_current_case(value)
                         group_state = state[conditional_input.name] = {}
                         cast_errors: ParameterValidationErrorsT = {}
+                        incoming_for_conditional = cast(
+                            ToolStateJobInstanceT, incoming.get(conditional_input.name) or {}
+                        )
                         populate_state(
                             request_context,
                             conditional_input.cases[current_case].inputs,
-                            cast(ToolStateJobInstanceT, incoming.get(conditional_input.name)),
+                            incoming_for_conditional,
                             group_state,
                             cast_errors,
                             context=context,
@@ -522,10 +495,11 @@ def populate_state(
             elif input.type == "section":
                 section_input = cast(Section, input)
                 section_errors: ParameterValidationErrorsT = {}
+                incoming_for_state = cast(ToolStateJobInstanceT, incoming.get(section_input.name) or {})
                 populate_state(
                     request_context,
                     section_input.inputs,
-                    cast(ToolStateJobInstanceT, incoming.get(section_input.name)),
+                    incoming_for_state,
                     group_state,
                     section_errors,
                     context=context,
@@ -688,6 +662,185 @@ def _populate_state_legacy(
             state[input.name] = value
 
 
+def populate_state_async(
+    request_context,
+    inputs: ToolInputsT,
+    incoming: ToolStateJobInstanceT,
+    state: ToolStateJobInstancePopulatedT,
+    errors: ParameterValidationErrorsT,
+    context=None,
+):
+    context = ExpressionContext(state, context)
+    for input in inputs.values():
+        initial_value = input.get_initial_value(request_context, context)
+        input_name = input.name
+        state[input_name] = initial_value
+        group_state = state[input_name]
+        if input.type == "repeat":
+            repeat_input = cast(Repeat, input)
+            if (
+                len(incoming[repeat_input.name]) > repeat_input.max
+                or len(incoming[repeat_input.name]) < repeat_input.min
+            ):
+                errors[repeat_input.name] = "The number of repeat elements is outside the range specified by the tool."
+            else:
+                del group_state[:]
+                for rep in incoming[repeat_input.name]:
+                    new_state: ToolStateJobInstancePopulatedT = {}
+                    group_state.append(new_state)
+                    repeat_errors: ParameterValidationErrorsT = {}
+                    populate_state_async(
+                        request_context,
+                        repeat_input.inputs,
+                        rep,
+                        new_state,
+                        repeat_errors,
+                        context=context,
+                    )
+                    if repeat_errors:
+                        errors[repeat_input.name] = repeat_errors
+
+        elif input.type == "conditional":
+            conditional_input = cast(Conditional, input)
+            test_param = cast(ToolParameter, conditional_input.test_param)
+            test_param_value = incoming.get(conditional_input.name, {}).get(test_param.name)
+            value, error = check_param(request_context, test_param, test_param_value, context)
+            if error:
+                errors[test_param.name] = error
+            else:
+                try:
+                    current_case = conditional_input.get_current_case(value)
+                    group_state = state[conditional_input.name] = {}
+                    cast_errors: ParameterValidationErrorsT = {}
+                    populate_state_async(
+                        request_context,
+                        conditional_input.cases[current_case].inputs,
+                        cast(ToolStateJobInstanceT, incoming.get(conditional_input.name)),
+                        group_state,
+                        cast_errors,
+                        context=context,
+                    )
+                    if cast_errors:
+                        errors[conditional_input.name] = cast_errors
+                    group_state["__current_case__"] = current_case
+                except Exception:
+                    errors[test_param.name] = "The selected case is unavailable/invalid."
+            group_state[test_param.name] = value
+
+        elif input.type == "section":
+            section_input = cast(Section, input)
+            section_errors: ParameterValidationErrorsT = {}
+            populate_state_async(
+                request_context,
+                section_input.inputs,
+                cast(ToolStateJobInstanceT, incoming.get(section_input.name)),
+                group_state,
+                section_errors,
+                context=context,
+            )
+            if section_errors:
+                errors[section_input.name] = section_errors
+
+        elif input.type == "upload_dataset":
+            raise NotImplementedError
+
+        else:
+            param_value = _get_incoming_value(incoming, input.name, state.get(input.name))
+            value, error = check_param(request_context, input, param_value, context, simple_errors=False)
+            if error:
+                errors[input.name] = error
+            state[input.name] = value
+
+            def to_internal_single(value):
+                if isinstance(value, HistoryDatasetCollectionAssociation):
+                    return {"src": "hdca", "id": value.id}
+                elif isinstance(value, HistoryDatasetAssociation):
+                    return {"src": "hda", "id": value.id}
+                else:
+                    # tests and such to confirm we need DCE, LDDA, etc...
+                    return value
+
+            def to_internal(value):
+                if isinstance(value, list):
+                    return [to_internal_single(v) for v in value]
+                else:
+                    return to_internal_single(value)
+
+            if input_name not in incoming:
+                if input.type == "data_column":
+                    if isinstance(value, str):
+                        incoming[input_name] = int(value)
+                    elif isinstance(value, list):
+                        incoming[input_name] = [int(v) for v in value]
+                    else:
+                        incoming[input_name] = value
+                elif input.type == "text":
+                    text_input = cast(TextToolParameter, input)
+                    # see behavior of tools in test_tools.py::test_null_to_text_tools
+                    # these parameters act as empty string in this context
+                    if value is None and not text_input.optional:
+                        incoming[input_name] = ""
+                    else:
+                        incoming[input_name] = value
+                else:
+                    incoming[input_name] = to_internal(value)
+
+
+def fill_dynamic_defaults(
+    request_context,
+    inputs: ToolInputsT,
+    incoming: ToolStateJobInstanceT,
+    context=None,
+):
+    """
+    Expands incoming parameters with default values.
+    """
+    if context is None:
+        context = flat_to_nested_state(incoming)
+    for input in inputs.values():
+        if input.type == "repeat":
+            repeat_input = cast(Repeat, input)
+            for rep in incoming[repeat_input.name]:
+                fill_dynamic_defaults(
+                    request_context,
+                    repeat_input.inputs,
+                    rep,
+                    context=context,
+                )
+
+        elif input.type == "conditional":
+            conditional_input = cast(Conditional, input)
+            test_param = cast(ToolParameter, conditional_input.test_param)
+            test_param_value = incoming.get(conditional_input.name, {}).get(test_param.name)
+            try:
+                current_case = conditional_input.get_current_case(test_param_value)
+                fill_dynamic_defaults(
+                    request_context,
+                    conditional_input.cases[current_case].inputs,
+                    cast(ToolStateJobInstanceT, incoming.get(conditional_input.name)),
+                    context=context,
+                )
+            except Exception:
+                raise Exception("The selected case is unavailable/invalid.")
+
+        elif input.type == "section":
+            section_input = cast(Section, input)
+            fill_dynamic_defaults(
+                request_context,
+                section_input.inputs,
+                cast(ToolStateJobInstanceT, incoming.get(section_input.name)),
+                context=context,
+            )
+
+        elif input.type == "upload_dataset":
+            raise NotImplementedError
+
+        else:
+            if input.name not in incoming:
+                param_value = input.get_initial_value(request_context, context)
+                incoming[input.name] = param_value
+
+
 def _get_incoming_value(incoming, key, default):
     """
     Fetch value from incoming dict directly or check special nginx upload
diff --git a/lib/galaxy/tools/parameters/basic.py b/lib/galaxy/tools/parameters/basic.py
index 08ae06864732..06d75152db46 100644
--- a/lib/galaxy/tools/parameters/basic.py
+++ b/lib/galaxy/tools/parameters/basic.py
@@ -13,6 +13,7 @@
 from collections.abc import MutableMapping
 from typing import (
     Any,
+    cast,
     Dict,
     List,
     Optional,
@@ -41,11 +42,13 @@
 )
 from galaxy.model.dataset_collections import builder
 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.tool_util.parser.util import (
     boolean_is_checked,
     boolean_true_and_false_values,
     ParameterParseException,
+    text_input_is_optional,
 )
 from galaxy.tools.parameters.workflow_utils import workflow_building_modes
 from galaxy.util import (
@@ -121,6 +124,8 @@ def parse_dynamic_options(param, input_source):
     if not dynamic_options_config:
         return None
     options_elem = dynamic_options_config.elem()
+    if options_elem is None:
+        return None
     return dynamic_options.DynamicOptions(options_elem, param)
 
 
@@ -186,7 +191,6 @@ def __init__(self, tool, input_source, context=None):
         self.hidden = input_source.get_bool("hidden", False)
         self.refresh_on_change = input_source.get_bool("refresh_on_change", False)
         self.optional = input_source.parse_optional()
-        self.optionality_inferred = False
         self.is_dynamic = False
         self.label = input_source.parse_label()
         self.help = input_source.parse_help()
@@ -194,9 +198,7 @@ def __init__(self, tool, input_source, context=None):
             self.sanitizer = ToolParameterSanitizer.from_element(sanitizer_elem)
         else:
             self.sanitizer = None
-        self.validators = []
-        for elem in input_source.parse_validator_elems():
-            self.validators.append(validation.Validator.from_element(self, elem))
+        self.validators = validation.to_validators(tool.app if tool else None, input_source.parse_validators())
 
     @property
     def visible(self) -> bool:
@@ -358,18 +360,7 @@ def __init__(self, tool, input_source):
         else:
             # Optionality not explicitly defined, default to False
             optional = False
-            if self.type == "text":
-                # A text parameter that doesn't raise a validation error on empty string
-                # is considered to be optional
-                try:
-                    for validator in self.validators:
-                        validator.validate("")
-                    optional = True
-                    self.optionality_inferred = True
-                except ValueError:
-                    pass
         self.optional = optional
-
         if self.optional:
             self.value = None
         else:
@@ -404,9 +395,16 @@ class TextToolParameter(SimpleTextToolParameter):
     def __init__(self, tool, input_source):
         input_source = ensure_input_source(input_source)
         super().__init__(tool, input_source)
+        self.profile = tool.profile if tool else None
         self.datalist = []
         for title, value, _ in input_source.parse_static_options():
             self.datalist.append({"label": title, "value": value})
+
+        # why does Integer and Float subclass this :_(
+        if self.type == "text":
+            self.optional, self.optionality_inferred = text_input_is_optional(input_source)
+        else:
+            self.optionality_inferred = False
         self.value = input_source.get("value")
         self.area = input_source.get_bool("area", False)
 
@@ -419,6 +417,16 @@ def validate(self, value, trans=None):
         ):
             return super().validate(value, trans)
 
+    @property
+    def wrapper_default(self) -> Optional[str]:
+        """Handle change in default handling pre and post 23.0 profiles."""
+        profile = self.profile
+        legacy_behavior = profile is None or Version(str(profile)) < Version("23.0")
+        default_value = None
+        if self.optional and self.optionality_inferred and legacy_behavior:
+            default_value = ""
+        return default_value
+
     def to_dict(self, trans, other_values=None):
         d = super().to_dict(trans)
         other_values = other_values or {}
@@ -466,7 +474,7 @@ def __init__(self, tool, input_source):
             except ValueError:
                 raise ParameterValueError("attribute 'max' must be an integer", self.name, self.max)
         if self.min is not None or self.max is not None:
-            self.validators.append(validation.InRangeValidator(None, self.min, self.max))
+            self.validators.append(validation.InRangeValidator.simple_range_validator(self.min, self.max))
 
     def from_json(self, value, trans, other_values=None):
         other_values = other_values or {}
@@ -539,7 +547,7 @@ def __init__(self, tool, input_source):
             except ValueError:
                 raise ParameterValueError("attribute 'max' must be a real number", self.name, self.max)
         if self.min is not None or self.max is not None:
-            self.validators.append(validation.InRangeValidator(None, self.min, self.max))
+            self.validators.append(validation.InRangeValidator.simple_range_validator(self.min, self.max))
 
     def from_json(self, value, trans, other_values=None):
         other_values = other_values or {}
@@ -848,7 +856,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):
@@ -1078,7 +1086,7 @@ def _select_from_json(self, value, trans, other_values=None, require_legal_value
                         )
             if is_runtime_value(value):
                 return None
-            if value in legal_values:
+            if value in legal_values or str(value) in legal_values:
                 return value
             elif value in fallback_values:
                 return fallback_values[value]
@@ -2044,7 +2052,7 @@ def __init__(self, tool, input_source, trans=None):
         self.load_contents = int(input_source.get("load_contents", 0))
         # Add metadata validator
         if not input_source.get_bool("no_validation", False):
-            self.validators.append(validation.MetadataValidator())
+            self.validators.append(validation.MetadataValidator.default_metadata_validator())
         self._parse_formats(trans, input_source)
         tag = input_source.get("tag")
         self.multiple = input_source.get_bool("multiple", False)
@@ -2465,7 +2473,10 @@ def from_json(self, value, trans, other_values=None):
             rval = value
         elif isinstance(value, MutableMapping) and "src" in value and "id" in value:
             if value["src"] == "hdca":
-                rval = session.get(HistoryDatasetCollectionAssociation, trans.security.decode_id(value["id"]))
+                rval = cast(
+                    HistoryDatasetCollectionAssociation,
+                    src_id_to_item(sa_session=trans.sa_session, value=value, security=trans.security),
+                )
         elif isinstance(value, list):
             if len(value) > 0:
                 value = value[0]
diff --git a/lib/galaxy/tools/parameters/dynamic_options.py b/lib/galaxy/tools/parameters/dynamic_options.py
index e354c93eabb5..8d9488128a03 100644
--- a/lib/galaxy/tools/parameters/dynamic_options.py
+++ b/lib/galaxy/tools/parameters/dynamic_options.py
@@ -621,8 +621,9 @@ def load_from_parameter(from_parameter, transform_lines=None):
             self.filters.append(Filter.from_element(self, filter_elem))
 
         # Load Validators
-        for validator in elem.findall("validator"):
-            self.validators.append(validation.Validator.from_element(self.tool_param, validator))
+        validators = validation.parse_xml_validators(self.tool_param.tool.app, elem)
+        if validators:
+            self.validators = validators
 
         if self.dataset_ref_name:
             tool_param.data_ref = self.dataset_ref_name
diff --git a/lib/galaxy/tools/parameters/meta.py b/lib/galaxy/tools/parameters/meta.py
index f2d8ba1a68d1..9173cc9ba1a7 100644
--- a/lib/galaxy/tools/parameters/meta.py
+++ b/lib/galaxy/tools/parameters/meta.py
@@ -19,10 +19,23 @@
     matching,
     subcollections,
 )
-from galaxy.util import permutations
+from galaxy.tool_util.parameters import (
+    RequestInternalDereferencedToolState,
+    ToolParameterBundle,
+)
+from galaxy.util.permutations import (
+    build_combos,
+    input_classification,
+    is_in_state,
+    state_copy,
+    state_get_value,
+    state_remove_value,
+    state_set_value,
+)
 from . import visit_input_values
 from .wrapped import process_key
 from .._types import (
+    InputFormatT,
     ToolRequestT,
     ToolStateJobInstanceT,
 )
@@ -161,12 +174,21 @@ def is_batch(value):
 ExpandedT = Tuple[List[ToolStateJobInstanceT], Optional[matching.MatchingCollections]]
 
 
-def expand_meta_parameters(trans, tool, incoming: ToolRequestT) -> ExpandedT:
+def expand_flat_parameters_to_nested(incoming_copy: ToolRequestT) -> Dict[str, Any]:
+    nested_dict: Dict[str, Any] = {}
+    for incoming_key, incoming_value in incoming_copy.items():
+        if not incoming_key.startswith("__"):
+            process_key(incoming_key, incoming_value=incoming_value, d=nested_dict)
+    return nested_dict
+
+
+def expand_meta_parameters(trans, tool, incoming: ToolRequestT, input_format: InputFormatT) -> ExpandedT:
     """
     Take in a dictionary of raw incoming parameters and expand to a list
     of expanded incoming parameters (one set of parameters per tool
     execution).
     """
+    log.info(f"in input_format={input_format} with: incoming {incoming} tool {tool.id}")
 
     for key in list(incoming.keys()):
         if key.endswith("|__identifier__"):
@@ -176,33 +198,24 @@ def expand_meta_parameters(trans, tool, incoming: ToolRequestT) -> ExpandedT:
     # order matters, so the following reorders incoming
     # according to tool.inputs (which is ordered).
     incoming_copy = incoming.copy()
-    nested_dict: Dict[str, Any] = {}
-    for incoming_key, incoming_value in incoming_copy.items():
-        if not incoming_key.startswith("__"):
-            process_key(incoming_key, incoming_value=incoming_value, d=nested_dict)
-
-    reordered_incoming = {}
-
-    def visitor(input, value, prefix, prefixed_name, prefixed_label, error, **kwargs):
-        if prefixed_name in incoming_copy:
-            reordered_incoming[prefixed_name] = incoming_copy[prefixed_name]
-            del incoming_copy[prefixed_name]
+    if input_format == "legacy":
+        nested_dict = expand_flat_parameters_to_nested(incoming_copy)
+    else:
+        nested_dict = incoming_copy
 
-    visit_input_values(inputs=tool.inputs, input_values=nested_dict, callback=visitor)
-    reordered_incoming.update(incoming_copy)
+    collections_to_match = matching.CollectionsToMatch()
 
-    def classifier(input_key):
-        value = incoming[input_key]
+    def classifier_from_value(value, input_key):
         if isinstance(value, dict) and "values" in value:
             # Explicit meta wrapper for inputs...
             is_batch = value.get("batch", False)
             is_linked = value.get("linked", True)
             if is_batch and is_linked:
-                classification = permutations.input_classification.MATCHED
+                classification = input_classification.MATCHED
             elif is_batch:
-                classification = permutations.input_classification.MULTIPLIED
+                classification = input_classification.MULTIPLIED
             else:
-                classification = permutations.input_classification.SINGLE
+                classification = input_classification.SINGLE
             if __collection_multirun_parameter(value):
                 collection_value = value["values"][0]
                 values = __expand_collection_parameter(
@@ -211,17 +224,31 @@ def classifier(input_key):
             else:
                 values = value["values"]
         else:
-            classification = permutations.input_classification.SINGLE
+            classification = input_classification.SINGLE
             values = value
         return classification, values
 
-    collections_to_match = matching.CollectionsToMatch()
+    nested = input_format != "legacy"
+    if not nested:
+        reordered_incoming = reorder_parameters(tool, incoming_copy, nested_dict, nested)
+        incoming_template = reordered_incoming
 
-    # Stick an unexpanded version of multirun keys so they can be replaced,
-    # by expand_mult_inputs.
-    incoming_template = reordered_incoming
+        def classifier_flat(input_key):
+            return classifier_from_value(incoming[input_key], input_key)
 
-    expanded_incomings = permutations.expand_multi_inputs(incoming_template, classifier)
+        single_inputs, matched_multi_inputs, multiplied_multi_inputs = split_inputs_flat(
+            incoming_template, classifier_flat
+        )
+    else:
+        reordered_incoming = reorder_parameters(tool, incoming_copy, nested_dict, nested)
+        incoming_template = reordered_incoming
+        single_inputs, matched_multi_inputs, multiplied_multi_inputs = split_inputs_nested(
+            tool.inputs, incoming_template, classifier_from_value
+        )
+
+    log.info(f"in nested={nested} with: single_inputs: {single_inputs}, matched_multi_inputs {matched_multi_inputs}, multiplied_multi_inputs: {multiplied_multi_inputs}")
+    expanded_incomings = build_combos(single_inputs, matched_multi_inputs, multiplied_multi_inputs, nested=nested)
+    log.info(f"ei {expanded_incomings}")
     if collections_to_match.has_collections():
         collection_info = trans.app.dataset_collection_manager.match_collections(collections_to_match)
     else:
@@ -229,8 +256,128 @@ def classifier(input_key):
     return expanded_incomings, collection_info
 
 
+def reorder_parameters(tool, incoming, nested_dict, nested):
+    # If we're going to multiply input dataset combinations
+    # order matters, so the following reorders incoming
+    # according to tool.inputs (which is ordered).
+    incoming_copy = state_copy(incoming, nested)
+
+    reordered_incoming = {}
+
+    def visitor(input, value, prefix, prefixed_name, prefixed_label, error, **kwargs):
+        if is_in_state(incoming_copy, prefixed_name, nested):
+            value_to_copy_over = state_get_value(incoming_copy, prefixed_name, nested)
+            state_set_value(reordered_incoming, prefixed_name, value_to_copy_over, nested)
+            state_remove_value(incoming_copy, prefixed_name, nested)
+
+    visit_input_values(inputs=tool.inputs, input_values=nested_dict, callback=visitor)
+
+    def merge_into(from_object, into_object):
+        if isinstance(from_object, dict):
+            for key, value in from_object.items():
+                if key not in into_object:
+                    into_object[key] = value
+                else:
+                    into_target = into_object[key]
+                    merge_into(value, into_target)
+        elif isinstance(from_object, list):
+            for index in from_object:
+                if len(into_object) <= index:
+                    into_object.append(from_object[index])
+                else:
+                    merge_into(from_object[index], into_object[index])
+
+    merge_into(incoming_copy, reordered_incoming)
+    return reordered_incoming
+
+
+def split_inputs_flat(inputs: Dict[str, Any], classifier):
+    single_inputs: Dict[str, Any] = {}
+    matched_multi_inputs: Dict[str, Any] = {}
+    multiplied_multi_inputs: Dict[str, Any] = {}
+
+    for input_key in inputs:
+        input_type, expanded_val = classifier(input_key)
+        if input_type == input_classification.SINGLE:
+            single_inputs[input_key] = expanded_val
+        elif input_type == input_classification.MATCHED:
+            matched_multi_inputs[input_key] = expanded_val
+        elif input_type == input_classification.MULTIPLIED:
+            multiplied_multi_inputs[input_key] = expanded_val
+
+    return (single_inputs, matched_multi_inputs, multiplied_multi_inputs)
+
+
+def split_inputs_nested(inputs, nested_dict, classifier):
+    single_inputs: Dict[str, Any] = {}
+    matched_multi_inputs: Dict[str, Any] = {}
+    multiplied_multi_inputs: Dict[str, Any] = {}
+    unset_value = object()
+
+    def visitor(input, value, prefix, prefixed_name, prefixed_label, error, **kwargs):
+        if value is unset_value:
+            # don't want to inject extra nulls into state
+            return
+
+        input_type, expanded_val = classifier(value, prefixed_name)
+        if input_type == input_classification.SINGLE:
+            single_inputs[prefixed_name] = expanded_val
+        elif input_type == input_classification.MATCHED:
+            matched_multi_inputs[prefixed_name] = expanded_val
+        elif input_type == input_classification.MULTIPLIED:
+            multiplied_multi_inputs[prefixed_name] = expanded_val
+
+    visit_input_values(
+        inputs=inputs, input_values=nested_dict, callback=visitor, allow_case_inference=True, unset_value=unset_value
+    )
+    single_inputs_nested = expand_flat_parameters_to_nested(single_inputs)
+    return (single_inputs_nested, matched_multi_inputs, multiplied_multi_inputs)
+
+
+Expanded2T = Tuple[List[ToolStateJobInstanceT], Optional[matching.MatchingCollections]]
+
+
+def expand_meta_parameters_async(
+    app, tool: ToolParameterBundle, incoming: RequestInternalDereferencedToolState
+) -> 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 = input_classification.MATCHED
+            elif is_batch:
+                classification = input_classification.MULTIPLIED
+            else:
+                classification = input_classification.SINGLE
+            if __collection_multirun_parameter(value):
+                collection_value = value["values"][0]
+                values = __expand_collection_parameter_async(
+                    app, input_key, collection_value, collections_to_match, linked=is_linked
+                )
+            else:
+                values = value["values"]
+        else:
+            classification = input_classification.SINGLE
+            values = value
+        return classification, values
+
+    collections_to_match = matching.CollectionsToMatch()
+    # TODO: fix this...
+    expanded_incoming_dicts = [incoming.input_state]  # 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
+    return expanded_incoming_dicts, 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
+    # If subcollection multirun of data_collection param - value will
     # be "hdca_id|subcollection_type" else it will just be hdca_id
     if "|" in incoming_val:
         encoded_hdc_id, subcollection_type = incoming_val.split("|", 1)
@@ -261,8 +408,34 @@ def __expand_collection_parameter(trans, input_key, incoming_val, collections_to
         return hdas
 
 
+def __expand_collection_parameter_async(app, input_key, incoming_val, collections_to_match, linked=False):
+    # If subcollection 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.get(HistoryDatasetCollectionAssociation, 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/tools/parameters/validation.py b/lib/galaxy/tools/parameters/validation.py
index 6334fd95f8b8..895cd1dfadef 100644
--- a/lib/galaxy/tools/parameters/validation.py
+++ b/lib/galaxy/tools/parameters/validation.py
@@ -3,16 +3,30 @@
 """
 
 import abc
-import json
 import logging
-import os.path
-
-import regex
+import os
+from typing import (
+    Any,
+    cast,
+    List,
+    Optional,
+    Union,
+)
 
 from galaxy import (
     model,
     util,
 )
+from galaxy.tool_util.parser.parameter_validators import (
+    AnyValidatorModel,
+    EmptyFieldParameterValidatorModel,
+    ExpressionParameterValidatorModel,
+    InRangeParameterValidatorModel,
+    MetadataParameterValidatorModel,
+    parse_xml_validators as parse_xml_validators_models,
+    raise_error_if_valiation_fails,
+    RegexParameterValidatorModel,
+)
 
 log = logging.getLogger(__name__)
 
@@ -24,27 +38,7 @@ class Validator(abc.ABC):
 
     requires_dataset_metadata = False
 
-    @classmethod
-    def from_element(cls, param, elem):
-        """
-        Initialize the appropriate Validator class
-
-        example call `validation.Validator.from_element(ToolParameter_object, Validator_object)`
-
-        needs to be implemented in the subclasses and should return the
-        corresponding Validator object by a call to `cls( ... )` which calls the
-        `__init__` method of the corresponding validator
-
-        param cls the Validator class
-        param param the element to be evaluated (which contains the validator)
-        param elem the validator element
-        return an object of a Validator subclass that corresponds to the type attribute of the validator element
-        """
-        _type = elem.get("type")
-        assert _type is not None, "Required 'type' attribute missing from validator"
-        return validator_types[_type].from_element(param, elem)
-
-    def __init__(self, message, negate=False):
+    def __init__(self, message: str, negate: bool = False):
         self.message = message
         self.negate = util.asbool(negate)
         super().__init__()
@@ -68,15 +62,7 @@ def validate(self, value, trans=None, message=None, value_to_show=None):
 
         return None if positive validation, otherwise a ValueError is raised
         """
-        assert isinstance(value, bool), "value must be boolean"
-        if message is None:
-            message = self.message
-        if value_to_show and "%s" in message:
-            message = message % value_to_show
-        if (not self.negate and value) or (self.negate and not value):
-            return
-        else:
-            raise ValueError(message)
+        raise_error_if_valiation_fails(value, self, message=message, value_to_show=value_to_show)
 
 
 class RegexValidator(Validator):
@@ -84,24 +70,14 @@ class RegexValidator(Validator):
     Validator that evaluates a regular expression
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        return cls(elem.get("message"), elem.text, elem.get("negate", "false"))
-
-    def __init__(self, message, expression, negate):
-        if message is None:
-            message = f"Value '%s' does {'not ' if negate == 'false' else ''}match regular expression '{expression.replace('%', '%%')}'"
+    def __init__(self, message: str, expression: str, negate: bool):
         super().__init__(message, negate)
         # Compile later. RE objects used to not be thread safe. Not sure about
         # the sre module.
         self.expression = expression
 
     def validate(self, value, trans=None):
-        if not isinstance(value, list):
-            value = [value]
-        for val in value:
-            match = regex.match(self.expression, val or "")
-            super().validate(match is not None, value_to_show=val)
+        RegexParameterValidatorModel.regex_validation(self.expression, value, self)
 
 
 class ExpressionValidator(Validator):
@@ -109,24 +85,16 @@ class ExpressionValidator(Validator):
     Validator that evaluates a python expression using the value
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        return cls(elem.get("message"), elem.text, elem.get("negate", "false"))
-
-    def __init__(self, message, expression, negate):
-        if message is None:
-            message = f"Value '%s' does not evaluate to {'True' if negate == 'false' else 'False'} for '{expression}'"
+    def __init__(self, message: str, expression: str, negate: bool):
         super().__init__(message, negate)
         self.expression = expression
         # Save compiled expression, code objects are thread safe (right?)
-        self.compiled_expression = compile(expression, "<string>", "eval")
+        self.compiled_expression = ExpressionParameterValidatorModel.ensure_compiled(expression)
 
     def validate(self, value, trans=None):
-        try:
-            evalresult = eval(self.compiled_expression, dict(value=value))
-        except Exception:
-            super().validate(False, message=f"Validator '{self.expression}' could not be evaluated on '{value}'")
-        super().validate(bool(evalresult), value_to_show=value)
+        ExpressionParameterValidatorModel.expression_validation(
+            self.expression, value, self, compiled_expression=self.compiled_expression
+        )
 
 
 class InRangeValidator(ExpressionValidator):
@@ -134,18 +102,15 @@ class InRangeValidator(ExpressionValidator):
     Validator that ensures a number is in a specified range
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        return cls(
-            elem.get("message"),
-            elem.get("min"),
-            elem.get("max"),
-            elem.get("exclude_min", "false"),
-            elem.get("exclude_max", "false"),
-            elem.get("negate", "false"),
-        )
-
-    def __init__(self, message, range_min, range_max, exclude_min=False, exclude_max=False, negate=False):
+    def __init__(
+        self,
+        message: str,
+        min: Optional[float] = None,
+        max: Optional[float] = None,
+        exclude_min: bool = False,
+        exclude_max: bool = False,
+        negate: bool = False,
+    ):
         """
         When the optional exclude_min and exclude_max attributes are set
         to true, the range excludes the end points (i.e., min < value < max),
@@ -153,10 +118,10 @@ def __init__(self, message, range_min, range_max, exclude_min=False, exclude_max
         (1.e., min <= value <= max).  Combinations of exclude_min and exclude_max
         values are allowed.
         """
-        self.min = range_min if range_min is not None else "-inf"
-        self.exclude_min = util.asbool(exclude_min)
-        self.max = range_max if range_max is not None else "inf"
-        self.exclude_max = util.asbool(exclude_max)
+        self.min = str(min) if min is not None else "-inf"
+        self.exclude_min = exclude_min
+        self.max = str(max) if max is not None else "inf"
+        self.exclude_max = exclude_max
         assert float(self.min) <= float(self.max), "min must be less than or equal to max"
         # Remove unneeded 0s and decimal from floats to make message pretty.
         op1 = "<="
@@ -166,24 +131,23 @@ def __init__(self, message, range_min, range_max, exclude_min=False, exclude_max
         if self.exclude_max:
             op2 = "<"
         expression = f"float('{self.min}') {op1} float(value) {op2} float('{self.max}')"
-        if message is None:
-            message = f"Value ('%s') must {'not ' if negate == 'true' else ''}fulfill {expression}"
         super().__init__(message, expression, negate)
 
+    @staticmethod
+    def simple_range_validator(min: Optional[float], max: Optional[float]):
+        return cast(
+            InRangeParameterValidatorModel,
+            _to_validator(None, InRangeParameterValidatorModel(min=min, max=max, implicit=True)),
+        )
+
 
 class LengthValidator(InRangeValidator):
     """
     Validator that ensures the length of the provided string (value) is in a specific range
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        return cls(elem.get("message"), elem.get("min"), elem.get("max"), elem.get("negate", "false"))
-
-    def __init__(self, message, length_min, length_max, negate):
-        if message is None:
-            message = f"Must {'not ' if negate == 'true' else ''}have length of at least {length_min} and at most {length_max}"
-        super().__init__(message, range_min=length_min, range_max=length_max, negate=negate)
+    def __init__(self, message: str, min: float, max: float, negate: bool):
+        super().__init__(message, min=min, max=max, negate=negate)
 
     def validate(self, value, trans=None):
         if value is None:
@@ -196,16 +160,8 @@ class DatasetOkValidator(Validator):
     Validator that checks if a dataset is in an 'ok' state
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        negate = elem.get("negate", "false")
-        message = elem.get("message")
-        if message is None:
-            if negate == "false":
-                message = "The selected dataset is still being generated, select another dataset or wait until it is completed"
-            else:
-                message = "The selected dataset must not be in state OK"
-        return cls(message, negate)
+    def __init__(self, message: str, negate: bool = False):
+        super().__init__(message, negate=negate)
 
     def validate(self, value, trans=None):
         if value:
@@ -217,13 +173,8 @@ class DatasetEmptyValidator(Validator):
     Validator that checks if a dataset has a positive file size.
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        message = elem.get("message")
-        negate = elem.get("negate", "false")
-        if not message:
-            message = f"The selected dataset is {'non-' if negate == 'true' else ''}empty, this tool expects {'non-' if negate == 'false' else ''}empty files."
-        return cls(message, negate)
+    def __init__(self, message: str, negate: bool = False):
+        super().__init__(message, negate=negate)
 
     def validate(self, value, trans=None):
         if value:
@@ -235,13 +186,8 @@ class DatasetExtraFilesPathEmptyValidator(Validator):
     Validator that checks if a dataset's extra_files_path exists and is not empty.
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        message = elem.get("message")
-        negate = elem.get("negate", "false")
-        if not message:
-            message = f"The selected dataset's extra_files_path directory is {'non-' if negate == 'true' else ''}empty or does {'not ' if negate == 'false' else ''}exist, this tool expects {'non-' if negate == 'false' else ''}empty extra_files_path directories associated with the selected input."
-        return cls(message, negate)
+    def __init__(self, message: str, negate: bool = False):
+        super().__init__(message, negate=negate)
 
     def validate(self, value, trans=None):
         if value:
@@ -255,25 +201,20 @@ class MetadataValidator(Validator):
 
     requires_dataset_metadata = True
 
-    @classmethod
-    def from_element(cls, param, elem):
-        message = elem.get("message")
-        return cls(
-            message=message, check=elem.get("check", ""), skip=elem.get("skip", ""), negate=elem.get("negate", "false")
-        )
-
-    def __init__(self, message=None, check="", skip="", negate="false"):
-        if not message:
-            if not util.asbool(negate):
-                message = "Metadata '%s' missing, click the pencil icon in the history item to edit / save the metadata attributes"
-            else:
-                if check != "":
-                    message = f"At least one of the checked metadata '{check}' is set, click the pencil icon in the history item to edit / save the metadata attributes"
-                elif skip != "":
-                    message = f"At least one of the non skipped metadata '{skip}' is set, click the pencil icon in the history item to edit / save the metadata attributes"
+    def __init__(
+        self,
+        message: str,
+        check: Optional[List[str]] = None,
+        skip: Optional[List[str]] = None,
+        negate: bool = False,
+    ):
         super().__init__(message, negate)
-        self.check = check.split(",") if check else None
-        self.skip = skip.split(",") if skip else None
+        self.check = check
+        self.skip = skip
+
+    @staticmethod
+    def default_metadata_validator() -> "MetadataValidator":
+        return cast(MetadataValidator, _to_validator(None, MetadataParameterValidatorModel(implicit=True)))
 
     def validate(self, value, trans=None):
         if value:
@@ -293,25 +234,10 @@ class MetadataEqualValidator(Validator):
     requires_dataset_metadata = True
 
     def __init__(self, metadata_name=None, value=None, message=None, negate="false"):
-        if not message:
-            if not util.asbool(negate):
-                message = f"Metadata value for '{metadata_name}' must be '{value}', but it is '%s'."
-            else:
-                message = f"Metadata value for '{metadata_name}' must not be '{value}' but it is."
         super().__init__(message, negate)
         self.metadata_name = metadata_name
         self.value = value
 
-    @classmethod
-    def from_element(cls, param, elem):
-        value = elem.get("value", None) or json.loads(elem.get("value_json", "null"))
-        return cls(
-            metadata_name=elem.get("metadata_name", None),
-            value=value,
-            message=elem.get("message", None),
-            negate=elem.get("negate", "false"),
-        )
-
     def validate(self, value, trans=None):
         if value:
             metadata_value = getattr(value.metadata, self.metadata_name)
@@ -325,13 +251,8 @@ class UnspecifiedBuildValidator(Validator):
 
     requires_dataset_metadata = True
 
-    @classmethod
-    def from_element(cls, param, elem):
-        message = elem.get("message")
-        negate = elem.get("negate", "false")
-        if not message:
-            message = f"{'Unspecified' if negate == 'false' else 'Specified'} genome build, click the pencil icon in the history item to {'set' if negate == 'false' else 'remove'} the genome build"
-        return cls(message, negate)
+    def __init__(self, message: str, negate: bool = False):
+        super().__init__(message, negate=negate)
 
     def validate(self, value, trans=None):
         # if value is None, we cannot validate
@@ -348,13 +269,8 @@ class NoOptionsValidator(Validator):
     Validator that checks for empty select list
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        message = elem.get("message")
-        negate = elem.get("negate", "false")
-        if not message:
-            message = f"{'No options' if negate == 'false' else 'Options'} available for selection"
-        return cls(message, negate)
+    def __init__(self, message: str, negate: bool = False):
+        super().__init__(message, negate=negate)
 
     def validate(self, value, trans=None):
         super().validate(value is not None)
@@ -365,19 +281,11 @@ class EmptyTextfieldValidator(Validator):
     Validator that checks for empty text field
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        message = elem.get("message")
-        negate = elem.get("negate", "false")
-        if not message:
-            if negate == "false":
-                message = elem.get("message", "Field requires a value")
-            else:
-                message = elem.get("message", "Field must not set a value")
-        return cls(message, negate)
+    def __init__(self, message: str, negate: bool = False):
+        super().__init__(message, negate=negate)
 
     def validate(self, value, trans=None):
-        super().validate(value != "")
+        EmptyFieldParameterValidatorModel.empty_validate(value, self)
 
 
 class MetadataInFileColumnValidator(Validator):
@@ -391,35 +299,19 @@ class MetadataInFileColumnValidator(Validator):
 
     requires_dataset_metadata = True
 
-    @classmethod
-    def from_element(cls, param, elem):
-        filename = elem.get("filename")
-        assert filename, f"Required 'filename' attribute missing from {elem.get('type')} validator."
-        filename = f"{param.tool.app.config.tool_data_path}/{filename.strip()}"
-        assert os.path.exists(filename), f"File {filename} specified by the 'filename' attribute not found"
-        metadata_name = elem.get("metadata_name")
-        assert metadata_name, f"Required 'metadata_name' attribute missing from {elem.get('type')} validator."
-        metadata_name = metadata_name.strip()
-        metadata_column = int(elem.get("metadata_column", 0))
-        split = elem.get("split", "\t")
-        message = elem.get("message", f"Value for metadata {metadata_name} was not found in {filename}.")
-        line_startswith = elem.get("line_startswith")
-        if line_startswith:
-            line_startswith = line_startswith.strip()
-        negate = elem.get("negate", "false")
-        return cls(filename, metadata_name, metadata_column, message, line_startswith, split, negate)
-
     def __init__(
         self,
-        filename,
-        metadata_name,
-        metadata_column,
-        message="Value for metadata not found.",
-        line_startswith=None,
-        split="\t",
-        negate="false",
+        filename: str,
+        metadata_name: str,
+        metadata_column: int,
+        message: str,
+        line_startswith: Optional[str] = None,
+        split: str = "\t",
+        negate: bool = False,
     ):
         super().__init__(message, negate)
+        assert filename
+        assert os.path.exists(filename), f"File {filename} specified by the 'filename' attribute not found"
         self.metadata_name = metadata_name
         self.valid_values = set()
         with open(filename) as fh:
@@ -445,28 +337,20 @@ class ValueInDataTableColumnValidator(Validator):
     note: this is covered in a framework test (validation_value_in_datatable)
     """
 
-    @classmethod
-    def from_element(cls, param, elem):
-        table_name = elem.get("table_name")
-        assert table_name, f"Required 'table_name' attribute missing from {elem.get('type')} validator."
-        tool_data_table = param.tool.app.tool_data_tables[table_name]
-        column = elem.get("metadata_column", 0)
-        try:
-            column = int(column)
-        except ValueError:
-            pass
-        message = elem.get("message", f"Value was not found in {table_name}.")
-        negate = elem.get("negate", "false")
-        return cls(tool_data_table, column, message, negate)
-
-    def __init__(self, tool_data_table, column, message="Value not found.", negate="false"):
+    def __init__(
+        self,
+        tool_data_table,
+        metadata_column: Union[str, int],
+        message: str,
+        negate: bool = False,
+    ):
         super().__init__(message, negate)
-        self.valid_values = []
+        self.valid_values: List[Any] = []
         self._data_table_content_version = None
         self._tool_data_table = tool_data_table
-        if isinstance(column, str):
-            column = tool_data_table.columns[column]
-        self._column = column
+        if isinstance(metadata_column, str):
+            metadata_column = tool_data_table.columns[metadata_column]
+        self._column = metadata_column
         self._load_values()
 
     def _load_values(self):
@@ -496,7 +380,9 @@ class ValueNotInDataTableColumnValidator(ValueInDataTableColumnValidator):
     note: this is covered in a framework test (validation_value_in_datatable)
     """
 
-    def __init__(self, tool_data_table, metadata_column, message="Value already present.", negate="false"):
+    def __init__(
+        self, tool_data_table, metadata_column: Union[str, int], message="Value already present.", negate="false"
+    ):
         super().__init__(tool_data_table, metadata_column, message, negate)
 
     def validate(self, value, trans=None):
@@ -517,26 +403,13 @@ class MetadataInDataTableColumnValidator(ValueInDataTableColumnValidator):
 
     requires_dataset_metadata = True
 
-    @classmethod
-    def from_element(cls, param, elem):
-        table_name = elem.get("table_name")
-        assert table_name, f"Required 'table_name' attribute missing from {elem.get('type')} validator."
-        tool_data_table = param.tool.app.tool_data_tables[table_name]
-        metadata_name = elem.get("metadata_name")
-        assert metadata_name, f"Required 'metadata_name' attribute missing from {elem.get('type')} validator."
-        metadata_name = metadata_name.strip()
-        # TODO rename to column?
-        metadata_column = elem.get("metadata_column", 0)
-        try:
-            metadata_column = int(metadata_column)
-        except ValueError:
-            pass
-        message = elem.get("message", f"Value for metadata {metadata_name} was not found in {table_name}.")
-        negate = elem.get("negate", "false")
-        return cls(tool_data_table, metadata_name, metadata_column, message, negate)
-
     def __init__(
-        self, tool_data_table, metadata_name, metadata_column, message="Value for metadata not found.", negate="false"
+        self,
+        tool_data_table,
+        metadata_name: str,
+        metadata_column: Union[str, int],
+        message: str,
+        negate: bool = False,
     ):
         super().__init__(tool_data_table, metadata_column, message, negate)
         self.metadata_name = metadata_name
@@ -558,7 +431,12 @@ class MetadataNotInDataTableColumnValidator(MetadataInDataTableColumnValidator):
     requires_dataset_metadata = True
 
     def __init__(
-        self, tool_data_table, metadata_name, metadata_column, message="Value for metadata not found.", negate="false"
+        self,
+        tool_data_table,
+        metadata_name: str,
+        metadata_column: Union[str, int],
+        message: str,
+        negate: bool = False,
     ):
         super().__init__(tool_data_table, metadata_name, metadata_column, message, negate)
 
@@ -580,26 +458,18 @@ class MetadataInRangeValidator(InRangeValidator):
 
     requires_dataset_metadata = True
 
-    @classmethod
-    def from_element(cls, param, elem):
-        metadata_name = elem.get("metadata_name")
-        assert metadata_name, f"Required 'metadata_name' attribute missing from {elem.get('type')} validator."
-        metadata_name = metadata_name.strip()
-        ret = cls(
-            metadata_name,
-            elem.get("message"),
-            elem.get("min"),
-            elem.get("max"),
-            elem.get("exclude_min", "false"),
-            elem.get("exclude_max", "false"),
-            elem.get("negate", "false"),
-        )
-        ret.message = "Metadata: " + ret.message
-        return ret
-
-    def __init__(self, metadata_name, message, range_min, range_max, exclude_min, exclude_max, negate):
+    def __init__(
+        self,
+        metadata_name: str,
+        message: str,
+        min: Optional[float] = None,
+        max: Optional[float] = None,
+        exclude_min: bool = False,
+        exclude_max: bool = False,
+        negate: bool = False,
+    ):
         self.metadata_name = metadata_name
-        super().__init__(message, range_min, range_max, exclude_min, exclude_max, negate)
+        super().__init__(message, min, max, exclude_min, exclude_max, negate)
 
     def validate(self, value, trans=None):
         if value:
@@ -638,3 +508,29 @@ def validate(self, value, trans=None):
 
 deprecated_validator_types = dict(dataset_metadata_in_file=MetadataInFileColumnValidator)
 validator_types.update(deprecated_validator_types)
+
+
+def parse_xml_validators(app, xml_el: util.Element) -> List[Validator]:
+    return to_validators(app, parse_xml_validators_models(xml_el))
+
+
+def to_validators(app, validator_models: List[AnyValidatorModel]) -> List[Validator]:
+    validators = []
+    for validator_model in validator_models:
+        validators.append(_to_validator(app, validator_model))
+    return validators
+
+
+def _to_validator(app, validator_model: AnyValidatorModel) -> Validator:
+    as_dict = validator_model.model_dump()
+    validator_type = as_dict.pop("type")
+    del as_dict["implicit"]
+    if "table_name" in as_dict and app is not None:
+        table_name = as_dict.pop("table_name")
+        tool_data_table = app.tool_data_tables[table_name]
+        as_dict["tool_data_table"] = tool_data_table
+    if "filename" in as_dict and app is not None:
+        filename = as_dict.pop("filename")
+        as_dict["filename"] = f"{app.config.tool_data_path}/{filename}"
+
+    return validator_types[validator_type](**as_dict)
diff --git a/lib/galaxy/tools/stock.py b/lib/galaxy/tools/stock.py
index 1a86354f1370..da890fe13a8f 100644
--- a/lib/galaxy/tools/stock.py
+++ b/lib/galaxy/tools/stock.py
@@ -26,7 +26,7 @@ def stock_tool_sources():
 
 
 def _walk_directory_for_tools(path):
-    if path.is_file() and path.name.endswith(".xml"):
+    if path.is_file() and path.name.endswith(".xml") and "macros" not in path.name and "_conf.xml" not in path.name:
         yield path
     elif path.is_dir():
         for directory in path.iterdir():
diff --git a/lib/galaxy/tools/wrappers.py b/lib/galaxy/tools/wrappers.py
index 01e8e8491bbc..f5d1d6a5a0bb 100644
--- a/lib/galaxy/tools/wrappers.py
+++ b/lib/galaxy/tools/wrappers.py
@@ -19,7 +19,6 @@
     Union,
 )
 
-from packaging.version import Version
 from typing_extensions import TypeAlias
 
 from galaxy.model import (
@@ -33,7 +32,10 @@
 from galaxy.model.metadata import FileParameter
 from galaxy.model.none_like import NoneDataset
 from galaxy.security.object_wrapper import wrap_with_safe_string
-from galaxy.tools.parameters.basic import BooleanToolParameter
+from galaxy.tools.parameters.basic import (
+    BooleanToolParameter,
+    TextToolParameter,
+)
 from galaxy.tools.parameters.wrapped_json import (
     data_collection_input_to_staging_path_and_source_path,
     data_input_to_staging_path_and_source_path,
@@ -126,15 +128,9 @@ def __init__(
         profile: Optional[float] = None,
     ) -> None:
         self.input = input
-        if (
-            value is None
-            and input.type == "text"
-            and input.optional
-            and input.optionality_inferred
-            and (profile is None or Version(str(profile)) < Version("23.0"))
-        ):
+        if value is None and input.type == "text":
             # Tools with old profile versions may treat an optional text parameter as `""`
-            value = ""
+            value = cast(TextToolParameter, input).wrapper_default
         self.value = value
         self._other_values: Dict[str, str] = other_values or {}
 
@@ -806,6 +802,8 @@ def __init__(self, input_datasets: Optional[Dict[str, Any]] = None) -> None:
             self.identifier_key_dict = {}
 
     def identifier(self, dataset_value: str, input_values: Dict[str, str]) -> Optional[str]:
+        if isinstance(dataset_value, list):
+            raise TypeError(f"Expected {dataset_value} to be hashable")
         element_identifier = None
         if identifier_key := self.identifier_key_dict.get(dataset_value, None):
             element_identifier = input_values.get(identifier_key, None)
diff --git a/lib/galaxy/util/permutations.py b/lib/galaxy/util/permutations.py
index 5dd1b11ee8fa..79703ebbaa5b 100644
--- a/lib/galaxy/util/permutations.py
+++ b/lib/galaxy/util/permutations.py
@@ -7,10 +7,7 @@
 with itertools product and permutations. These are open questions.
 """
 
-from typing import (
-    Dict,
-    TypeVar,
-)
+import copy
 
 from galaxy.exceptions import MessageException
 from galaxy.util.bunch import Bunch
@@ -21,47 +18,20 @@
     MULTIPLIED="multiplied",
 )
 
-# generic type of splitting input dictionary
-T = TypeVar("T")
-
 
 class InputMatchedException(MessageException):
     """Indicates problem matching inputs while building up inputs
     permutations."""
 
 
-def expand_multi_inputs(inputs: Dict[str, T], classifier, key_filter=None):
-    key_filter = key_filter or (lambda x: True)
-
-    single_inputs, matched_multi_inputs, multiplied_multi_inputs = __split_inputs(inputs, classifier, key_filter)
-
+def build_combos(single_inputs, matched_multi_inputs, multiplied_multi_inputs, nested):
     # Build up every combination of inputs to be run together.
-    input_combos = __extend_with_matched_combos(single_inputs, matched_multi_inputs)
-    input_combos = __extend_with_multiplied_combos(input_combos, multiplied_multi_inputs)
-
+    input_combos = __extend_with_matched_combos(single_inputs, matched_multi_inputs, nested)
+    input_combos = __extend_with_multiplied_combos(input_combos, multiplied_multi_inputs, nested)
     return input_combos
 
 
-def __split_inputs(inputs: Dict[str, T], classifier, key_filter):
-    key_filter = key_filter or (lambda x: True)
-
-    single_inputs: Dict[str, T] = {}
-    matched_multi_inputs: Dict[str, T] = {}
-    multiplied_multi_inputs: Dict[str, T] = {}
-
-    for input_key in filter(key_filter, inputs):
-        input_type, expanded_val = classifier(input_key)
-        if input_type == input_classification.SINGLE:
-            single_inputs[input_key] = expanded_val
-        elif input_type == input_classification.MATCHED:
-            matched_multi_inputs[input_key] = expanded_val
-        elif input_type == input_classification.MULTIPLIED:
-            multiplied_multi_inputs[input_key] = expanded_val
-
-    return (single_inputs, matched_multi_inputs, multiplied_multi_inputs)
-
-
-def __extend_with_matched_combos(single_inputs, multi_inputs):
+def __extend_with_matched_combos(single_inputs, multi_inputs, nested):
     """
 
     {a => 1, b => 2} and {c => {3, 4}, d => {5, 6}}
@@ -81,7 +51,7 @@ def __extend_with_matched_combos(single_inputs, multi_inputs):
     first_multi_value = multi_inputs.get(first_multi_input_key)
 
     for value in first_multi_value:
-        new_inputs = __copy_and_extend_inputs(single_inputs, first_multi_input_key, value)
+        new_inputs = __copy_and_extend_inputs(single_inputs, first_multi_input_key, value, nested=nested)
         matched_multi_inputs.append(new_inputs)
 
     for multi_input_key, multi_input_values in multi_inputs.items():
@@ -94,12 +64,12 @@ def __extend_with_matched_combos(single_inputs, multi_inputs):
             )
 
         for index, value in enumerate(multi_input_values):
-            matched_multi_inputs[index][multi_input_key] = value
+            state_set_value(matched_multi_inputs[index], multi_input_key, value, nested)
 
     return matched_multi_inputs
 
 
-def __extend_with_multiplied_combos(input_combos, multi_inputs):
+def __extend_with_multiplied_combos(input_combos, multi_inputs, nested):
     combos = input_combos
 
     for multi_input_key, multi_input_value in multi_inputs.items():
@@ -107,7 +77,7 @@ def __extend_with_multiplied_combos(input_combos, multi_inputs):
 
         for combo in combos:
             for input_value in multi_input_value:
-                iter_combo = __copy_and_extend_inputs(combo, multi_input_key, input_value)
+                iter_combo = __copy_and_extend_inputs(combo, multi_input_key, input_value, nested)
                 iter_combos.append(iter_combo)
 
         combos = iter_combos
@@ -115,7 +85,64 @@ def __extend_with_multiplied_combos(input_combos, multi_inputs):
     return combos
 
 
-def __copy_and_extend_inputs(inputs, key, value):
-    new_inputs = dict(inputs)
-    new_inputs[key] = value
+def __copy_and_extend_inputs(inputs, key, value, nested):
+    # can't deepcopy dicts with our models for reason I don't understand,
+    # test_map_over_two_collections_unlinked breaks if I try to combine these two branches of the if
+    new_inputs = state_copy(inputs, nested)
+    state_set_value(new_inputs, key, value, nested)
     return new_inputs
+
+
+def state_copy(inputs, nested):
+    # can't deepcopy dicts with our models for reason I don't understand,
+    # test_map_over_two_collections_unlinked breaks if I try to combine these two branches of the if
+    if nested:
+        state_dict_copy = copy.deepcopy(inputs)
+    else:
+        state_dict_copy = dict(inputs)
+    return state_dict_copy
+
+
+
+def state_set_value(state_dict, key, value, nested):
+    if "|" not in key or not nested:
+        state_dict[key] = value
+    else:
+        first, rest = key.split("|", 1)
+        # repeats?
+        state_set_value(state_dict[first], rest, value, nested)
+
+
+def state_remove_value(state_dict, key, nested):
+    if "|" not in key or not nested:
+        del state_dict[key]
+    else:
+        first, rest = key.split("|", 1)
+        child_dict = state_dict[first]
+        # repeats?
+        if "|" in rest:
+            state_remove_value(child_dict, rest, nested)
+        else:
+            del child_dict[rest]
+            if len(child_dict) == 0:
+                del state_dict[first]
+
+
+def state_get_value(state_dict, key, nested):
+    if "|" not in key or not nested:
+        return state_dict[key]
+    else:
+        first, rest = key.split("|", 1)
+        # repeats?
+        state_get_value(state_dict[first], rest, nested)
+
+
+def is_in_state(state_dict, key, nested):
+    if not state_dict:
+        return False
+    if "|" not in key or not nested:
+        return key in state_dict
+    else:
+        first, rest = key.split("|", 1)
+        # repeats?
+        is_in_state(state_dict.get(first), rest, nested)
diff --git a/lib/galaxy/webapps/galaxy/api/__init__.py b/lib/galaxy/webapps/galaxy/api/__init__.py
index 95ec6cf4069a..8d2db1544981 100644
--- a/lib/galaxy/webapps/galaxy/api/__init__.py
+++ b/lib/galaxy/webapps/galaxy/api/__init__.py
@@ -81,6 +81,11 @@
 from galaxy.schema.fields import DecodedDatabaseIdField
 from galaxy.security.idencoding import IdEncodingHelper
 from galaxy.structured_app import StructuredApp
+from galaxy.tool_util.parameters import (
+    HasToolParameters,
+    to_json_schema_string,
+    ToolState,
+)
 from galaxy.web.framework.decorators import require_admin_message
 from galaxy.webapps.base.controller import BaseAPIController
 from galaxy.webapps.galaxy.api.cbv import cbv
@@ -611,6 +616,14 @@ async def _as_form(**data):
     return cls
 
 
+def json_schema_response_for_tool_state_model(
+    state_type: Type[ToolState], has_parameters: HasToolParameters
+) -> Response:
+    pydantic_model = state_type.parameter_model_for(has_parameters)
+    json_str = to_json_schema_string(pydantic_model)
+    return Response(content=json_str, media_type="application/json")
+
+
 async def try_get_request_body_as_json(request: Request) -> Optional[Any]:
     """Returns the request body as a JSON object if the content type is JSON."""
     if "application/json" in request.headers.get("content-type", ""):
diff --git a/lib/galaxy/webapps/galaxy/api/histories.py b/lib/galaxy/webapps/galaxy/api/histories.py
index 57b18c1f1c17..e1cbdee66d7e 100644
--- a/lib/galaxy/webapps/galaxy/api/histories.py
+++ b/lib/galaxy/webapps/galaxy/api/histories.py
@@ -61,6 +61,7 @@
     ShareWithPayload,
     SharingStatus,
     StoreExportPayload,
+    ToolRequestModel,
     UpdateHistoryPayload,
     WriteStoreToPayload,
 )
@@ -374,6 +375,17 @@ def citations(
     ) -> List[Any]:
         return self.service.citations(trans, history_id)
 
+    @router.get(
+        "/api/histories/{history_id}/tool_requests",
+        summary="Return all the tool requests for the tools submitted to this history.",
+    )
+    def tool_requests(
+        self,
+        history_id: HistoryIDPathParam,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> List[ToolRequestModel]:
+        return self.service.tool_requests(trans, history_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 9eb5efb40938..b99ae5e2cfba 100644
--- a/lib/galaxy/webapps/galaxy/api/jobs.py
+++ b/lib/galaxy/webapps/galaxy/api/jobs.py
@@ -44,6 +44,7 @@
     JobInputAssociation,
     JobInputSummary,
     JobOutputAssociation,
+    JobOutputCollectionAssociation,
     ReportJobErrorPayload,
     SearchJobsPayload,
     ShowFullJobResponse,
@@ -67,11 +68,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 proxy_work_context_for_history
+from .tools import validate_not_protected
 
 log = logging.getLogger(__name__)
 
@@ -155,6 +159,12 @@
     description="Limit listing of jobs to those that match the specified implicit collection job ID. If none, jobs from any implicit collection execution (or from no implicit collection execution) 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",
@@ -207,6 +217,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")
     def index(
         self,
@@ -223,6 +240,7 @@ def index(
         workflow_id: Optional[DecodedDatabaseIdField] = WorkflowIdQueryParam,
         invocation_id: Optional[DecodedDatabaseIdField] = InvocationIdQueryParam,
         implicit_collection_jobs_id: Optional[DecodedDatabaseIdField] = ImplicitCollectionJobsIdQueryParam,
+        tool_request_id: Optional[DecodedDatabaseIdField] = ToolRequestIdQueryParam,
         order_by: JobIndexSortByEnum = SortByQueryParam,
         search: Optional[str] = SearchQueryParam,
         limit: int = LimitQueryParam,
@@ -241,6 +259,7 @@ def index(
             workflow_id=workflow_id,
             invocation_id=invocation_id,
             implicit_collection_jobs_id=implicit_collection_jobs_id,
+            tool_request_id=tool_request_id,
             order_by=order_by,
             search=search,
             limit=limit,
@@ -361,12 +380,14 @@ def outputs(
         self,
         job_id: JobIdPathParam,
         trans: ProvidesUserContext = DependsOnTrans,
-    ) -> List[JobOutputAssociation]:
+    ) -> List[Union[JobOutputAssociation, JobOutputCollectionAssociation]]:
         job = self.service.get_job(trans=trans, job_id=job_id)
         associations = self.service.dictify_associations(trans, job.output_datasets, job.output_library_datasets)
-        output_associations = []
+        output_associations: List[Union[JobOutputAssociation, JobOutputCollectionAssociation]] = []
         for association in associations:
             output_associations.append(JobOutputAssociation(name=association.name, dataset=association.dataset))
+
+        output_associations.extend(self.service.dictify_output_collection_associations(trans, job))
         return output_associations
 
     @router.get(
diff --git a/lib/galaxy/webapps/galaxy/api/tools.py b/lib/galaxy/webapps/galaxy/api/tools.py
index dc27f7c3408e..d2591bf7335a 100644
--- a/lib/galaxy/webapps/galaxy/api/tools.py
+++ b/lib/galaxy/webapps/galaxy/api/tools.py
@@ -12,9 +12,13 @@
 from fastapi import (
     Body,
     Depends,
+    Path,
+    Query,
     Request,
+    Response,
     UploadFile,
 )
+from pydantic import UUID4
 from starlette.datastructures import UploadFile as StarletteUploadFile
 
 from galaxy import (
@@ -24,13 +28,32 @@
 )
 from galaxy.datatypes.data import get_params_and_input_name
 from galaxy.managers.collections import DatasetCollectionManager
-from galaxy.managers.context import ProvidesHistoryContext
+from galaxy.managers.context import (
+    ProvidesHistoryContext,
+    ProvidesUserContext,
+)
 from galaxy.managers.hdas import HDAManager
 from galaxy.managers.histories import HistoryManager
+from galaxy.managers.landing import LandingRequestManager
+from galaxy.managers.tools import ToolRunReference
+from galaxy.model import ToolRequest
 from galaxy.schema.fetch_data import (
     FetchDataFormPayload,
     FetchDataPayload,
 )
+from galaxy.schema.fields import DecodedDatabaseIdField
+from galaxy.schema.schema import (
+    ClaimLandingPayload,
+    CreateToolLandingRequestPayload,
+    ToolLandingRequest,
+    ToolRequestModel,
+)
+from galaxy.tool_util.parameters import (
+    LandingRequestToolState,
+    RequestToolState,
+    TestCaseToolState,
+    ToolParameterT,
+)
 from galaxy.tool_util.verify import ToolTestDescriptionDict
 from galaxy.tools.evaluation import global_tool_errors
 from galaxy.util.zipstream import ZipstreamWrapper
@@ -42,6 +65,7 @@
 )
 from galaxy.webapps.base.controller import UsesVisualizationMixin
 from galaxy.webapps.base.webapp import GalaxyWebTransaction
+from galaxy.webapps.galaxy.services.base import tool_request_to_model
 from galaxy.webapps.galaxy.services.tools import ToolsService
 from . import (
     APIContentTypeRoute,
@@ -49,6 +73,8 @@
     BaseGalaxyAPIController,
     depends,
     DependsOnTrans,
+    json_schema_response_for_tool_state_model,
+    LandingUuidPathParam,
     Router,
 )
 
@@ -73,6 +99,13 @@ 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="")
+
 
 async def get_files(request: Request, files: Optional[List[UploadFile]] = None):
     # FastAPI's UploadFile is a very light wrapper around starlette's UploadFile
@@ -88,6 +121,7 @@ async def get_files(request: Request, files: Optional[List[UploadFile]] = None):
 @router.cbv
 class FetchTools:
     service: ToolsService = depends(ToolsService)
+    landing_manager: LandingRequestManager = depends(LandingRequestManager)
 
     @router.post("/api/tools/fetch", summary="Upload files to Galaxy", route_class_override=JsonApiRoute)
     def fetch_json(self, payload: FetchDataPayload = Body(...), trans: ProvidesHistoryContext = DependsOnTrans):
@@ -106,6 +140,137 @@ def fetch_form(
     ):
         return self.service.create_fetch(trans, payload, files)
 
+    @router.get(
+        "/api/tool_requests/{id}",
+        summary="Get tool request state.",
+    )
+    def get_tool_request(
+        self,
+        id: DecodedDatabaseIdField,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> ToolRequestModel:
+        tool_request = self._get_tool_request_or_raise_not_found(trans, id)
+        return tool_request_to_model(tool_request)
+
+    @router.get(
+        "/api/tool_requests/{id}/state",
+        summary="Get tool request state.",
+    )
+    def tool_request_state(
+        self,
+        id: DecodedDatabaseIdField,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> str:
+        tool_request = self._get_tool_request_or_raise_not_found(trans, id)
+        state = tool_request.state
+        if not state:
+            raise exceptions.InconsistentDatabase()
+        return cast(str, state)
+
+    def _get_tool_request_or_raise_not_found(
+        self, trans: ProvidesHistoryContext, id: DecodedDatabaseIdField
+    ) -> ToolRequest:
+        tool_request: Optional[ToolRequest] = cast(
+            Optional[ToolRequest], trans.app.model.context.query(ToolRequest).get(id)
+        )
+        if tool_request is None:
+            raise exceptions.ObjectNotFound()
+        assert tool_request
+        return tool_request
+
+    @router.post("/api/tool_landings", public=True)
+    def create_landing(
+        self,
+        trans: ProvidesUserContext = DependsOnTrans,
+        tool_landing_request: CreateToolLandingRequestPayload = Body(...),
+    ) -> ToolLandingRequest:
+        return self.landing_manager.create_tool_landing_request(tool_landing_request)
+
+    @router.post("/api/tool_landings/{uuid}/claim")
+    def claim_landing(
+        self,
+        trans: ProvidesUserContext = DependsOnTrans,
+        uuid: UUID4 = LandingUuidPathParam,
+        payload: Optional[ClaimLandingPayload] = Body(...),
+    ) -> ToolLandingRequest:
+        return self.landing_manager.claim_tool_landing_request(trans, uuid, payload)
+
+    @router.get("/api/tool_landings/{uuid}")
+    def get_landing(
+        self,
+        trans: ProvidesUserContext = DependsOnTrans,
+        uuid: UUID4 = LandingUuidPathParam,
+    ) -> ToolLandingRequest:
+        return self.landing_manager.get_tool_landing_request(trans, uuid)
+
+    @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)
+
+    @router.get(
+        "/api/tools/{tool_id}/parameter_request_schema",
+        operation_id="tools__parameter_request_schema",
+        summary="Return a JSON schema description of the tool's inputs for the tool request API that will be added to Galaxy at some point",
+        description="The tool request schema includes validation of map/reduce concepts that can be consumed by the tool execution API and not just the request for a single execution.",
+    )
+    def tool_state_request(
+        self,
+        tool_id: str = ToolIDPathParam,
+        tool_version: Optional[str] = ToolVersionQueryParam,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> Response:
+        tool_run_ref = ToolRunReference(tool_id=tool_id, tool_version=tool_version, tool_uuid=None)
+        inputs = self.service.inputs(trans, tool_run_ref)
+        return json_schema_response_for_tool_state_model(
+            RequestToolState,
+            inputs,
+        )
+
+    @router.get(
+        "/api/tools/{tool_id}/parameter_landing_request_schema",
+        operation_id="tools__parameter_landing_request_schema",
+        summary="Return a JSON schema description of the tool's inputs for the tool landing request API.",
+    )
+    def tool_state_landing_request(
+        self,
+        tool_id: str = ToolIDPathParam,
+        tool_version: Optional[str] = ToolVersionQueryParam,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> Response:
+        tool_run_ref = ToolRunReference(tool_id=tool_id, tool_version=tool_version, tool_uuid=None)
+        inputs = self.service.inputs(trans, tool_run_ref)
+        return json_schema_response_for_tool_state_model(
+            LandingRequestToolState,
+            inputs,
+        )
+
+    @router.get(
+        "/api/tools/{tool_id}/parameter_test_case_xml_schema",
+        operation_id="tools__parameter_test_case_xml_schema",
+        summary="Return a JSON schema description of the tool's inputs for test case construction.",
+    )
+    def tool_state_test_case_xml(
+        self,
+        tool_id: str = ToolIDPathParam,
+        tool_version: Optional[str] = ToolVersionQueryParam,
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> Response:
+        tool_run_ref = ToolRunReference(tool_id=tool_id, tool_version=tool_version, tool_uuid=None)
+        inputs = self.service.inputs(trans, tool_run_ref)
+        return json_schema_response_for_tool_state_model(
+            TestCaseToolState,
+            inputs,
+        )
+
 
 class ToolsController(BaseGalaxyAPIController, UsesVisualizationMixin):
     """
@@ -586,16 +751,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/base.py b/lib/galaxy/webapps/galaxy/services/base.py
index dcf91e80f2f2..423df8f4b96d 100644
--- a/lib/galaxy/webapps/galaxy/services/base.py
+++ b/lib/galaxy/webapps/galaxy/services/base.py
@@ -23,13 +23,19 @@
 )
 from galaxy.managers.context import ProvidesUserContext
 from galaxy.managers.model_stores import create_objects_from_store
-from galaxy.model import User
+from galaxy.model import (
+    ToolRequest,
+    User,
+)
 from galaxy.model.store import (
     get_export_store_factory,
     ModelExportStore,
 )
 from galaxy.schema.fields import EncodedDatabaseIdField
-from galaxy.schema.schema import AsyncTaskResultSummary
+from galaxy.schema.schema import (
+    AsyncTaskResultSummary,
+    ToolRequestModel,
+)
 from galaxy.security.idencoding import IdEncodingHelper
 from galaxy.short_term_storage import (
     ShortTermStorageAllocator,
@@ -193,3 +199,13 @@ def async_task_summary(async_result: AsyncResult) -> AsyncTaskResultSummary:
         name=name,
         queue=queue,
     )
+
+
+def tool_request_to_model(tool_request: ToolRequest) -> ToolRequestModel:
+    as_dict = {
+        "id": tool_request.id,
+        "request": tool_request.request,
+        "state": tool_request.state,
+        "state_message": tool_request.state_message,
+    }
+    return ToolRequestModel.model_validate(as_dict)
diff --git a/lib/galaxy/webapps/galaxy/services/histories.py b/lib/galaxy/webapps/galaxy/services/histories.py
index 32e8a9fa8a1c..764ce5a748a1 100644
--- a/lib/galaxy/webapps/galaxy/services/histories.py
+++ b/lib/galaxy/webapps/galaxy/services/histories.py
@@ -70,6 +70,7 @@
     ShareHistoryWithStatus,
     ShareWithPayload,
     StoreExportPayload,
+    ToolRequestModel,
     WriteStoreToPayload,
 )
 from galaxy.schema.tasks import (
@@ -87,6 +88,7 @@
     model_store_storage_target,
     ServesExportStores,
     ServiceBase,
+    tool_request_to_model,
 )
 from galaxy.webapps.galaxy.services.notifications import NotificationService
 from galaxy.webapps.galaxy.services.sharable import ShareableService
@@ -533,6 +535,13 @@ 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
+        return [tool_request_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 5c39175567bf..e4547da181e4 100644
--- a/lib/galaxy/webapps/galaxy/services/jobs.py
+++ b/lib/galaxy/webapps/galaxy/services/jobs.py
@@ -1,3 +1,4 @@
+import logging
 from enum import Enum
 from typing import (
     Any,
@@ -6,24 +7,81 @@
     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.base import security_check
-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.model import Job
-from galaxy.schema.fields import DecodedDatabaseIdField
-from galaxy.schema.jobs import JobAssociation
-from galaxy.schema.schema import JobIndexQueryPayload
+from galaxy.managers.tools import ToolRunReference
+from galaxy.model import (
+    Job,
+    ToolRequest,
+    ToolSource as ToolSourceModel,
+)
+from galaxy.model.base import transaction
+from galaxy.schema.fields import (
+    DecodedDatabaseIdField,
+    EncodedDatabaseIdField,
+)
+from galaxy.schema.jobs import (
+    JobAssociation,
+    JobOutputCollectionAssociation,
+)
+from galaxy.schema.schema import (
+    AsyncTaskResultSummary,
+    JobIndexQueryPayload,
+)
+from galaxy.schema.tasks import (
+    QueueJobs,
+    ToolSource,
+)
 from galaxy.security.idencoding import IdEncodingHelper
-from galaxy.webapps.galaxy.services.base import ServiceBase
+from galaxy.tool_util.parameters import (
+    decode,
+    RequestToolState,
+)
+from galaxy.webapps.galaxy.services.base import (
+    async_task_summary,
+    ServiceBase,
+)
+from .tools import validate_tool_for_running
+
+log = logging.getLogger(__name__)
+
+
+class JobRequest(BaseModel):
+    tool_id: Optional[str] = Field(default=None, title="tool_id", description="TODO")
+    tool_uuid: Optional[str] = Field(default=None, title="tool_uuid", description="TODO")
+    tool_version: Optional[str] = Field(default=None, title="tool_version", description="TODO")
+    history_id: Optional[DecodedDatabaseIdField] = Field(default=None, title="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(
+        default=None, title="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):
@@ -39,6 +97,7 @@ class JobsService(ServiceBase):
     job_manager: JobManager
     job_search: JobSearch
     hda_manager: hdas.HDAManager
+    history_manager: HistoryManager
 
     def __init__(
         self,
@@ -46,11 +105,13 @@ def __init__(
         job_manager: JobManager,
         job_search: JobSearch,
         hda_manager: hdas.HDAManager,
+        history_manager: HistoryManager,
     ):
         super().__init__(security=security)
         self.job_manager = job_manager
         self.job_search = job_search
         self.hda_manager = hda_manager
+        self.history_manager = history_manager
 
     def show(
         self,
@@ -146,3 +207,62 @@ def __dictify_association(self, trans, job_dataset_association) -> JobAssociatio
             else:
                 dataset_dict = {"src": "ldda", "id": dataset.id}
         return JobAssociation(name=job_dataset_association.name, dataset=dataset_dict)
+
+    def dictify_output_collection_associations(self, trans, job: model.Job) -> List[JobOutputCollectionAssociation]:
+        output_associations: List[JobOutputCollectionAssociation] = []
+        for job_output_collection_association in job.output_dataset_collection_instances:
+            ref_dict = {"src": "hdca", "id": job_output_collection_association.dataset_collection_id}
+            output_associations.append(
+                JobOutputCollectionAssociation(
+                    name=job_output_collection_association.name,
+                    dataset_collection_instance=ref_dict,
+                )
+            )
+        return output_associations
+
+    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_source_model = ToolSourceModel(
+            source=[p.model_dump() for p in tool.parameters],
+            hash="TODO",
+        )
+        tool_request.request = request_internal_state.input_state
+        tool_request.tool_source = tool_source_model
+        tool_request.state = ToolRequest.states.NEW
+        tool_request.history = target_history
+        sa_session = trans.sa_session
+        sa_session.add(tool_source_model)
+        sa_session.add(tool_request)
+        with transaction(sa_session):
+            sa_session.commit()
+        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,
+            tool_request_id=tool_request_id,
+            use_cached_jobs=job_request.use_cached_jobs or False,
+            rerun_remap_job_id=job_request.rerun_remap_job_id,
+        )
+        result = queue_jobs.delay(request=task_request)
+        return JobCreateResponse(
+            **{
+                "tool_request_id": 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 9e2298eae134..80cbe341b3cf 100644
--- a/lib/galaxy/webapps/galaxy/services/tools.py
+++ b/lib/galaxy/webapps/galaxy/services/tools.py
@@ -4,6 +4,7 @@
 from json import dumps
 from typing import (
     Any,
+    cast,
     Dict,
     List,
     Optional,
@@ -23,6 +24,10 @@
     ProvidesUserContext,
 )
 from galaxy.managers.histories import HistoryManager
+from galaxy.managers.tools import (
+    get_tool_from_trans,
+    ToolRunReference,
+)
 from galaxy.model import (
     LibraryDatasetDatasetAssociation,
     PostJobAction,
@@ -34,7 +39,9 @@
     FilesPayload,
 )
 from galaxy.security.idencoding import IdEncodingHelper
+from galaxy.tool_util.parameters import ToolParameterT
 from galaxy.tools import Tool
+from galaxy.tools._types import InputFormatT
 from galaxy.tools.search import ToolBoxSearch
 from galaxy.webapps.galaxy.services._fetch_util import validate_and_normalize_targets
 from galaxy.webapps.galaxy.services.base import ServiceBase
@@ -42,6 +49,19 @@
 log = logging.getLogger(__name__)
 
 
+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_from_trans(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,
@@ -55,6 +75,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_from_trans(trans, tool_ref)
+        return tool.parameters
+
     def create_fetch(
         self,
         trans: ProvidesHistoryContext,
@@ -100,37 +128,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
@@ -166,7 +171,10 @@ def _create(self, trans: ProvidesHistoryContext, payload, **kwd):
             inputs.get("use_cached_job", "false")
         )
         preferred_object_store_id = payload.get("preferred_object_store_id")
-        input_format = str(payload.get("input_format", "legacy"))
+        input_format_raw = str(payload.get("input_format", "legacy"))
+        if input_format_raw not in ["legacy", "21.01"]:
+            raise exceptions.RequestParameterInvalidException(f"invalid input format {input_format_raw}")
+        input_format = cast(InputFormatT, input_format_raw)
         if "data_manager_mode" in payload:
             incoming["__data_manager_mode"] = payload["data_manager_mode"]
         vars = tool.handle_input(
diff --git a/lib/galaxy/workflow/format2.py b/lib/galaxy/workflow/format2.py
new file mode 100644
index 000000000000..a9ddca8073d0
--- /dev/null
+++ b/lib/galaxy/workflow/format2.py
@@ -0,0 +1,36 @@
+from typing import Optional
+
+import yaml
+from gxformat2 import (
+    from_galaxy_native,
+    ImporterGalaxyInterface,
+    ImportOptions,
+    python_to_workflow,
+)
+
+from galaxy.exceptions import MalformedContents
+
+
+def convert_to_format2(as_dict, json_wrapper: bool):
+    return from_galaxy_native(as_dict, None, json_wrapper=json_wrapper)
+
+
+def convert_from_format2(as_dict, workflow_directory: Optional[str]):
+    # Format 2 Galaxy workflow.
+    galaxy_interface = Format2ConverterGalaxyInterface()
+    import_options = ImportOptions()
+    import_options.deduplicate_subworkflows = True
+    try:
+        as_dict = python_to_workflow(
+            as_dict, galaxy_interface, workflow_directory=workflow_directory, import_options=import_options
+        )
+    except yaml.scanner.ScannerError as e:
+        raise MalformedContents(str(e))
+    return as_dict
+
+
+class Format2ConverterGalaxyInterface(ImporterGalaxyInterface):
+    def import_workflow(self, workflow, **kwds):
+        raise NotImplementedError(
+            "Direct format 2 import of nested workflows is not yet implemented, use bioblend client."
+        )
diff --git a/lib/galaxy/workflow/gx_validator.py b/lib/galaxy/workflow/gx_validator.py
new file mode 100644
index 000000000000..3d3a99912c2a
--- /dev/null
+++ b/lib/galaxy/workflow/gx_validator.py
@@ -0,0 +1,64 @@
+""""A validator for Galaxy workflows that is hooked up to Galaxy internals.
+
+The interface is designed to be usable from the tool shed for external tooling,
+but for internal tooling - Galaxy should have its own tool available.
+"""
+
+from typing import (
+    Dict,
+    Optional,
+)
+
+from galaxy.tool_util.models import (
+    parse_tool,
+    ParsedTool,
+)
+from galaxy.tool_util.version import parse_version
+from galaxy.tool_util.version_util import AnyVersionT
+from galaxy.tool_util.workflow_state import (
+    GetToolInfo,
+    validate_workflow as validate_workflow_generic,
+)
+from galaxy.tools.stock import stock_tool_sources
+
+
+class GalaxyGetToolInfo(GetToolInfo):
+    stock_tools_by_version: Dict[str, Dict[AnyVersionT, ParsedTool]]
+    stock_tools_latest_version: Dict[str, AnyVersionT]
+
+    def __init__(self):
+        # todo take in a toolbox in the future...
+        stock_tools: Dict[str, Dict[AnyVersionT, ParsedTool]] = {}
+        stock_tools_latest_version: Dict[str, AnyVersionT] = {}
+        for stock_tool in stock_tool_sources():
+            id = stock_tool.parse_id()
+            version = stock_tool.parse_version()
+            version_object = None
+            if version is not None:
+                version_object = parse_version(version)
+            if id not in stock_tools:
+                stock_tools[id] = {}
+                if version_object is not None:
+                    stock_tools_latest_version[id] = version_object
+            try:
+                stock_tools[id][version_object] = parse_tool(stock_tool)
+            except Exception:
+                pass
+            if version_object and version_object > stock_tools_latest_version[id]:
+                stock_tools_latest_version[id] = version_object
+        self.stock_tools = stock_tools
+        self.stock_tools_latest_version = stock_tools_latest_version
+
+    def get_tool_info(self, tool_id: str, tool_version: Optional[str]) -> ParsedTool:
+        if tool_version is not None:
+            return self.stock_tools[tool_id][parse_version(tool_version)]
+        else:
+            latest_verison = self.stock_tools_latest_version[tool_id]
+            return self.stock_tools[tool_id][latest_verison]
+
+
+GET_TOOL_INFO = GalaxyGetToolInfo()
+
+
+def validate_workflow(as_dict):
+    return validate_workflow_generic(as_dict, get_tool_info=GET_TOOL_INFO)
diff --git a/lib/galaxy_test/api/conftest.py b/lib/galaxy_test/api/conftest.py
index 5c0b36753995..a011532c7af5 100644
--- a/lib/galaxy_test/api/conftest.py
+++ b/lib/galaxy_test/api/conftest.py
@@ -25,6 +25,7 @@
     check_missing_tool,
     DatasetCollectionPopulator,
     DatasetPopulator,
+    DescribeToolInputs,
     get_tool_ids,
     RequiredTool,
     TargetHistory,
@@ -127,6 +128,17 @@ def target_history(
     return TargetHistory(dataset_populator, dataset_collection_populator, history_id)
 
 
+@pytest.fixture
+def required_tools(
+    dataset_populator: DatasetPopulator, history_id: str, required_tool_ids: List[str]
+) -> List[RequiredTool]:
+    tools = []
+    for tool_id in required_tool_ids:
+        tool = RequiredTool(dataset_populator, tool_id, history_id)
+        tools.append(tool)
+    return tools
+
+
 @pytest.fixture
 def required_tool(dataset_populator: DatasetPopulator, history_id: str, required_tool_ids: List[str]) -> RequiredTool:
     if len(required_tool_ids) != 1:
@@ -136,6 +148,11 @@ def required_tool(dataset_populator: DatasetPopulator, history_id: str, required
     return tool
 
 
+@pytest.fixture(params=["legacy", "21.01"])
+def tool_input_format(request) -> Iterator[DescribeToolInputs]:
+    yield DescribeToolInputs(request.param)
+
+
 @pytest.fixture(autouse=True)
 def check_required_tools(anonymous_galaxy_interactor, request):
     for marker in request.node.iter_markers():
diff --git a/lib/galaxy_test/api/test_landing.py b/lib/galaxy_test/api/test_landing.py
index 84057f92097e..748e6afe7623 100644
--- a/lib/galaxy_test/api/test_landing.py
+++ b/lib/galaxy_test/api/test_landing.py
@@ -4,7 +4,14 @@
     Dict,
 )
 
-from galaxy.schema.schema import CreateWorkflowLandingRequestPayload
+from galaxy.schema.schema import (
+    CreateToolLandingRequestPayload,
+    CreateWorkflowLandingRequestPayload,
+)
+from galaxy_test.base.api_asserts import (
+    assert_error_code_is,
+    assert_status_code_is,
+)
 from galaxy_test.base.populators import (
     DatasetPopulator,
     skip_without_tool,
@@ -22,6 +29,32 @@ def setUp(self):
         self.dataset_populator = DatasetPopulator(self.galaxy_interactor)
         self.workflow_populator = WorkflowPopulator(self.galaxy_interactor)
 
+    @skip_without_tool("cat")
+    def test_tool_landing(self):
+        request = CreateToolLandingRequestPayload(
+            tool_id="create_2",
+            tool_version=None,
+            request_state={"sleep_time": 0},
+        )
+        response = self.dataset_populator.create_tool_landing(request)
+        assert response.tool_id == "create_2"
+        assert response.state == "unclaimed"
+        response = self.dataset_populator.claim_tool_landing(response.uuid)
+        assert response.tool_id == "create_2"
+        assert response.state == "claimed"
+
+    @skip_without_tool("gx_int")
+    def test_tool_landing_invalid(self):
+        request = CreateToolLandingRequestPayload(
+            tool_id="gx_int",
+            tool_version=None,
+            request_state={"parameter": "foobar"},
+        )
+        response = self.dataset_populator.create_tool_landing_raw(request)
+        assert_status_code_is(response, 400)
+        assert_error_code_is(response, 400008)
+        assert "Input should be a valid integer" in response.text
+
     @skip_without_tool("cat1")
     def test_workflow_landing(self):
         workflow_id = self.workflow_populator.simple_workflow("test_landing")
diff --git a/lib/galaxy_test/api/test_tool_execute.py b/lib/galaxy_test/api/test_tool_execute.py
index b77ebcbb0cd1..d6cc7c2ef0e5 100644
--- a/lib/galaxy_test/api/test_tool_execute.py
+++ b/lib/galaxy_test/api/test_tool_execute.py
@@ -7,8 +7,11 @@
 files, etc..).
 """
 
+from typing import List
+
 from galaxy_test.base.decorators import requires_tool_id
 from galaxy_test.base.populators import (
+    DescribeToolInputs,
     RequiredTool,
     TargetHistory,
 )
@@ -80,24 +83,15 @@ def test_identifier_in_multiple_reduce(target_history: TargetHistory, required_t
 
 
 @requires_tool_id("identifier_in_conditional")
-def test_identifier_map_over_multiple_input_in_conditional_legacy_format(
-    target_history: TargetHistory, required_tool: RequiredTool
+def test_identifier_map_over_multiple_input_in_conditional(
+    target_history: TargetHistory, required_tool: RequiredTool, tool_input_format: DescribeToolInputs
 ):
     hdca = target_history.with_pair()
-    execute = required_tool.execute.with_inputs(
+    inputs = tool_input_format.when.flat(
         {
             "outer_cond|input1": hdca.src_dict,
         }
-    )
-    execute.assert_has_single_job.assert_has_single_output.with_contents_stripped("forward\nreverse")
-
-
-@requires_tool_id("identifier_in_conditional")
-def test_identifier_map_over_multiple_input_in_conditional_21_01_format(
-    target_history: TargetHistory, required_tool: RequiredTool
-):
-    hdca = target_history.with_pair()
-    execute = required_tool.execute.with_nested_inputs(
+    ).when.nested(
         {
             "outer_cond": {
                 "multi_input": True,
@@ -105,32 +99,44 @@ def test_identifier_map_over_multiple_input_in_conditional_21_01_format(
             },
         }
     )
+    execute = required_tool.execute.with_inputs(inputs)
     execute.assert_has_single_job.assert_has_single_output.with_contents_stripped("forward\nreverse")
 
 
 @requires_tool_id("identifier_multiple_in_repeat")
-def test_identifier_multiple_reduce_in_repeat_new_payload_form(
-    target_history: TargetHistory, required_tool: RequiredTool
+def test_identifier_multiple_reduce_in_repeat(
+    target_history: TargetHistory, required_tool: RequiredTool, tool_input_format: DescribeToolInputs
 ):
     hdca = target_history.with_pair()
-    execute = required_tool.execute.with_nested_inputs(
-        {
-            "the_repeat": [{"the_data": {"input1": hdca.src_dict}}],
-        }
-    )
+    inputs = tool_input_format.when.nested({
+        "the_repeat": [{"the_data": {"input1": hdca.src_dict}}],
+    }).when.flat({
+        "the_repeat_0|the_data|input1": hdca.src_dict,
+    })
+    execute = required_tool.execute.with_inputs(inputs)
     execute.assert_has_single_job.assert_has_single_output.with_contents_stripped("forward\nreverse")
 
 
 @requires_tool_id("output_action_change_format")
-def test_map_over_with_output_format_actions(target_history: TargetHistory, required_tool: RequiredTool):
+def test_map_over_with_output_format_actions(
+    target_history: TargetHistory, required_tool: RequiredTool, tool_input_format: DescribeToolInputs
+):
     hdca = target_history.with_pair()
     for use_action in ["do", "dont"]:
-        execute = required_tool.execute.with_inputs(
+        inputs = tool_input_format.when.flat(
             {
                 "input_cond|dispatch": use_action,
                 "input_cond|input": {"batch": True, "values": [hdca.src_dict]},
             }
+        ).when.nested(
+            {
+                "input_cond": {
+                    "dispatch": use_action,
+                    "input": {"batch": True, "values": [hdca.src_dict]},
+                }
+            }
         )
+        execute = required_tool.execute.with_inputs(inputs)
         execute.assert_has_n_jobs(2).assert_creates_n_implicit_collections(1)
         expected_extension = "txt" if (use_action == "do") else "data"
         execute.assert_has_job(0).with_single_output.with_file_ext(expected_extension)
@@ -218,3 +224,100 @@ def test_optional_repeats_with_mins_filled_id(target_history: TargetHistory, req
     # tool test framework filling in a default. Creating a raw request here
     # verifies that currently select parameters don't require a selection.
     required_tool.execute.assert_has_single_job.with_single_output.containing("false").containing("length: 2")
+
+
+@requires_tool_id("gx_select")
+@requires_tool_id("gx_select_no_options_validation")
+def test_select_first_by_default(required_tools: List[RequiredTool], tool_input_format: DescribeToolInputs):
+    empty = tool_input_format.when.any({})
+    for required_tool in required_tools:
+        required_tool.execute.with_inputs(empty).assert_has_single_job.with_output("output").with_contents_stripped(
+            "--ex1"
+        )
+
+
+@requires_tool_id("gx_select")
+@requires_tool_id("gx_select_no_options_validation")
+@requires_tool_id("gx_select_dynamic_empty")
+@requires_tool_id("gx_select_dynamic_empty_validated")
+def test_select_on_null_errors(required_tools: List[RequiredTool], tool_input_format: DescribeToolInputs):
+    # test_select_first_by_default verifies the first option will just be selected, despite that if an explicit null
+    # is passed, an error (rightfully) occurs. This test verifies that.
+    null_parameter = tool_input_format.when.any({"parameter": None})
+    for required_tool in required_tools:
+        required_tool.execute.with_inputs(null_parameter).assert_fails.with_error_containing("an invalid option")
+
+
+@requires_tool_id("gx_select_dynamic_empty")
+@requires_tool_id("gx_select_dynamic_empty_validated")
+def test_select_empty_causes_error_regardless(
+    required_tools: List[RequiredTool], tool_input_format: DescribeToolInputs
+):
+    # despite selects otherwise selecting defaults - nothing can be done if the select option list is empty
+    empty = tool_input_format.when.any({})
+    for required_tool in required_tools:
+        required_tool.execute.with_inputs(empty).assert_fails.with_error_containing("an invalid option")
+
+
+@requires_tool_id("gx_select_optional")
+@requires_tool_id("gx_select_optional_no_options_validation")
+def test_select_optional_null_by_default(required_tools: List[RequiredTool], tool_input_format: DescribeToolInputs):
+    # test_select_first_by_default shows that required select values will pick an option by default,
+    # this test verify that doesn't occur for optional selects.
+    empty = tool_input_format.when.any({})
+    null_parameter = tool_input_format.when.any({"parameter": None})
+    for required_tool in required_tools:
+        required_tool.execute.with_inputs(empty).assert_has_single_job.with_output("output").with_contents_stripped(
+            "None"
+        )
+        required_tool.execute.with_inputs(null_parameter).assert_has_single_job.with_output(
+            "output"
+        ).with_contents_stripped("None")
+
+
+@requires_tool_id("gx_select_multiple")
+@requires_tool_id("gx_select_multiple_optional")
+def test_select_multiple_does_not_select_first_by_default(
+    required_tools: List[RequiredTool], tool_input_format: DescribeToolInputs
+):
+    # unlike single selects - no selection is forced and these serve as optional by default
+    empty = tool_input_format.when.any({})
+    null_parameter = tool_input_format.when.any({"parameter": None})
+    for required_tool in required_tools:
+        required_tool.execute.with_inputs(empty).assert_has_single_job.with_output("output").with_contents_stripped(
+            "None"
+        )
+        required_tool.execute.with_inputs(null_parameter).assert_has_single_job.with_output(
+            "output"
+        ).with_contents_stripped("None")
+
+
+@requires_tool_id("gx_text")
+@requires_tool_id("gx_text_optional_false")
+def test_null_to_text_tools(required_tools: List[RequiredTool], tool_input_format: DescribeToolInputs):
+    for required_tool in required_tools:
+        execute = required_tool.execute.with_inputs(tool_input_format.when.any({}))
+        execute.assert_has_single_job.with_output("output").with_contents_stripped("")
+        execute.assert_has_single_job.with_output("inputs_json").with_json({"parameter": ""})
+
+        execute = required_tool.execute.with_inputs(tool_input_format.when.any({"parameter": None}))
+        execute.assert_has_single_job.with_output("output").with_contents_stripped("")
+        execute.assert_has_single_job.with_output("inputs_json").with_json({"parameter": ""})
+
+
+@requires_tool_id("gx_text_optional")
+def test_null_to_optinal_text_tool(required_tool: RequiredTool, tool_input_format: DescribeToolInputs):
+    execute = required_tool.execute.with_inputs(tool_input_format.when.any({}))
+    execute.assert_has_single_job.with_output("output").with_contents_stripped("")
+    execute.assert_has_single_job.with_output("inputs_json").with_json({"parameter": None})
+
+    execute = required_tool.execute.with_inputs(tool_input_format.when.any({"parameter": None}))
+    execute.assert_has_single_job.with_output("output").with_contents_stripped("")
+    execute.assert_has_single_job.with_output("inputs_json").with_json({"parameter": None})
+
+
+@requires_tool_id("gx_text_empty_validation")
+def test_null_to_text_tool_with_validation(required_tool: RequiredTool, tool_input_format: DescribeToolInputs):
+    required_tool.execute.with_inputs(tool_input_format.when.any({})).assert_fails()
+    required_tool.execute.with_inputs(tool_input_format.when.any({"parameter": None})).assert_fails()
+    required_tool.execute.with_inputs(tool_input_format.when.any({"parameter": ""})).assert_fails()
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..6956bd2ca393
--- /dev/null
+++ b/lib/galaxy_test/api/test_tool_execution.py
@@ -0,0 +1,141 @@
+"""
+"""
+
+from typing import (
+    Any,
+    Dict,
+)
+
+import requests
+
+from galaxy_test.base.api_asserts import assert_status_code_is_ok
+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, {"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})
+            assert_status_code_is_ok(response)
+            response_json = response.json()
+            tool_request_id = response_json.get("tool_request_id")
+            task_result = response_json["task_result"]
+            history_tool_requests = self.dataset_populator.get_history_tool_requests(history_id)
+            assert tool_request_id in [tr["id"] for tr in history_tool_requests]
+            self.dataset_populator.wait_on_task_object(task_result)
+            state = self.dataset_populator.wait_on_tool_request(tool_request_id)
+            assert state
+            jobs = self.galaxy_interactor.jobs_for_tool_request(tool_request_id)
+            self.dataset_populator.wait_for_jobs(jobs, assert_ok=True)
+
+    @skip_without_tool("gx_data")
+    def test_execution_with_src_urls(self):
+        with self.dataset_populator.test_history() as history_id:
+            response = self._run(
+                "gx_data",
+                history_id,
+                {
+                    "parameter": {
+                        "src": "url",
+                        "url": "https://raw.githubusercontent.com/galaxyproject/planemo/7be1bf5b3971a43eaa73f483125bfb8cabf1c440/tests/data/hello.txt",
+                        "ext": "txt",
+                    }
+                },
+            )
+            assert_status_code_is_ok(response)
+            response_json = response.json()
+            tool_request_id = response_json.get("tool_request_id")
+            task_result = response_json["task_result"]
+            self.dataset_populator.wait_on_task_object(task_result)
+            state = self.dataset_populator.wait_on_tool_request(tool_request_id)
+            assert state, str(self.dataset_populator.get_tool_request(tool_request_id))
+            jobs = self.galaxy_interactor.jobs_for_tool_request(tool_request_id)
+            self.dataset_populator.wait_for_jobs(jobs, assert_ok=True)
+            if len(jobs) != 1:
+                raise Exception(f"Found incorrect number of jobs for tool request - was expecting a single job {jobs}")
+            assert len(jobs) == 1, jobs
+            job_id = jobs[0]["id"]
+            job_outputs = self.galaxy_interactor.job_outputs(job_id)
+            assert len(job_outputs) == 1
+            job_output = job_outputs[0]
+            assert job_output["name"] == "output"
+            content = self.dataset_populator.get_history_dataset_content(history_id, dataset=job_output["dataset"])
+            assert content == "Hello World!"
+
+            # verify input was not left deferred and materialized before the job started
+            input_dataset_details = self.dataset_populator.get_history_dataset_details(history_id, hid=1)
+            assert input_dataset_details["state"] == "ok", input_dataset_details
+
+    @skip_without_tool("gx_data")
+    def test_execution_with_deferred_src_urls(self):
+        with self.dataset_populator.test_history() as history_id:
+            response = self._run(
+                "gx_data",
+                history_id,
+                {
+                    "parameter": {
+                        "src": "url",
+                        "url": "https://raw.githubusercontent.com/galaxyproject/planemo/7be1bf5b3971a43eaa73f483125bfb8cabf1c440/tests/data/hello.txt",
+                        "ext": "txt",
+                        "deferred": True,
+                    }
+                },
+            )
+            assert_status_code_is_ok(response)
+            response_json = response.json()
+            tool_request_id = response_json.get("tool_request_id")
+            task_result = response_json["task_result"]
+            self.dataset_populator.wait_on_task_object(task_result)
+            state = self.dataset_populator.wait_on_tool_request(tool_request_id)
+            assert state, str(self.dataset_populator.get_tool_request(tool_request_id))
+            jobs = self.galaxy_interactor.jobs_for_tool_request(tool_request_id)
+            self.dataset_populator.wait_for_jobs(jobs, assert_ok=True)
+            if len(jobs) != 1:
+                raise Exception(f"Found incorrect number of jobs for tool request - was expecting a single job {jobs}")
+            assert len(jobs) == 1, jobs
+            job_id = jobs[0]["id"]
+            job_outputs = self.galaxy_interactor.job_outputs(job_id)
+            assert len(job_outputs) == 1
+            job_output = job_outputs[0]
+            assert job_output["name"] == "output"
+            content = self.dataset_populator.get_history_dataset_content(history_id, dataset=job_output["dataset"])
+            assert content == "Hello World!"
+
+            # verify input was left deferred and infer must have been materialized just for the job
+            input_dataset_details = self.dataset_populator.get_history_dataset_details(history_id, hid=1)
+            assert input_dataset_details["state"] == "deferred", input_dataset_details
+
+    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/api/test_tools.py b/lib/galaxy_test/api/test_tools.py
index 46c6cdad3473..50b832fa452a 100644
--- a/lib/galaxy_test/api/test_tools.py
+++ b/lib/galaxy_test/api/test_tools.py
@@ -11,6 +11,8 @@
 )
 
 import pytest
+from jsonschema import validate
+from jsonschema.exceptions import ValidationError
 from requests import (
     get,
     put,
@@ -29,7 +31,6 @@
     BaseDatasetCollectionPopulator,
     DatasetCollectionPopulator,
     DatasetPopulator,
-    LibraryPopulator,
     skip_without_tool,
     stage_rules_example,
 )
@@ -261,6 +262,31 @@ def test_legacy_biotools_xref_injection(self):
         assert xref["reftype"] == "bio.tools"
         assert xref["value"] == "bwa"
 
+    @skip_without_tool("gx_int")
+    def test_tool_schemas(self):
+        tool_id = "gx_int"
+
+        def get_jsonschema(state_type: str):
+            schema_url = self._api_url(f"tools/{tool_id}/parameter_{state_type}_schema")
+            schema_response = get(schema_url)
+            schema_response.raise_for_status()
+            return schema_response.json()
+
+        request_schema = get_jsonschema("request")
+        validate(instance={"parameter": 5}, schema=request_schema)
+        with pytest.raises(ValidationError):
+            validate(instance={"parameter": "Foobar"}, schema=request_schema)
+
+        test_case_schema = get_jsonschema("test_case_xml")
+        validate(instance={"parameter": 5}, schema=test_case_schema)
+        with pytest.raises(ValidationError):
+            validate(instance={"parameter": "Foobar"}, schema=test_case_schema)
+
+        landing_schema = get_jsonschema("landing_request")
+        validate(instance={"parameter": 5}, schema=landing_schema)
+        with pytest.raises(ValidationError):
+            validate(instance={"parameter": "Foobar"}, schema=landing_schema)
+
     @skip_without_tool("test_data_source")
     @skip_if_github_down
     def test_data_source_ok_request(self):
@@ -879,57 +905,6 @@ def test_dataset_hidden_after_job_finish(self):
             output_details = self.dataset_populator.get_history_dataset_details(history_id, dataset=output, wait=True)
             assert not output_details["visible"]
 
-    @skip_without_tool("gx_select")
-    def test_select_first_by_default(self):
-        # we have a tool test for this but I wanted to verify it wasn't just the
-        # tool test framework filling in a default. Creating a raw request here
-        # verifies that currently select parameters don't require a selection.
-        with self.dataset_populator.test_history(require_new=False) as history_id:
-            inputs: Dict[str, Any] = {}
-            response = self._run("gx_select", history_id, inputs, assert_ok=True)
-            output = response["outputs"][0]
-            output1_content = self.dataset_populator.get_history_dataset_content(history_id, dataset=output)
-            assert output1_content.strip() == "--ex1"
-
-            inputs = {
-                "parameter": None,
-            }
-            response = self._run("gx_select", history_id, inputs, assert_ok=False)
-            self._assert_status_code_is(response, 400)
-            assert "an invalid option" in response.text
-
-    @skip_without_tool("gx_select_multiple")
-    @skip_without_tool("gx_select_multiple_optional")
-    def test_select_multiple_null_handling(self):
-        with self.dataset_populator.test_history(require_new=False) as history_id:
-            inputs: Dict[str, Any] = {}
-            response = self._run("gx_select_multiple", history_id, inputs, assert_ok=True)
-            output = response["outputs"][0]
-            output1_content = self.dataset_populator.get_history_dataset_content(history_id, dataset=output)
-            assert output1_content.strip() == "None"
-
-            inputs = {}
-            response = self._run("gx_select_multiple_optional", history_id, inputs, assert_ok=True)
-            output = response["outputs"][0]
-            output1_content = self.dataset_populator.get_history_dataset_content(history_id, dataset=output)
-            assert output1_content.strip() == "None"
-
-            inputs = {
-                "parameter": None,
-            }
-            response = self._run("gx_select_multiple", history_id, inputs, assert_ok=True)
-            output = response["outputs"][0]
-            output1_content = self.dataset_populator.get_history_dataset_content(history_id, dataset=output)
-            assert output1_content.strip() == "None"
-
-            inputs = {
-                "parameter": None,
-            }
-            response = self._run("gx_select_multiple_optional", history_id, inputs, assert_ok=True)
-            output = response["outputs"][0]
-            output1_content = self.dataset_populator.get_history_dataset_content(history_id, dataset=output)
-            assert output1_content.strip() == "None"
-
     @skip_without_tool("gx_drill_down_exact")
     @skip_without_tool("gx_drill_down_exact_multiple")
     @skip_without_tool("gx_drill_down_recurse")
@@ -1027,18 +1002,6 @@ def test_data_column_defaults(self):
                 content = self.dataset_populator.get_history_dataset_content(history_id, dataset=output[0])
                 assert "parameter: 1,2" in content
 
-    @skip_without_tool("library_data")
-    def test_library_data_param(self):
-        with self.dataset_populator.test_history(require_new=False) as history_id:
-            ld = LibraryPopulator(self.galaxy_interactor).new_library_dataset("lda_test_library")
-            inputs = {"library_dataset": ld["ldda_id"], "library_dataset_multiple": [ld["ldda_id"], ld["ldda_id"]]}
-            response = self._run("library_data", history_id, inputs, assert_ok=True)
-            output = response["outputs"]
-            output_content = self.dataset_populator.get_history_dataset_content(history_id, dataset=output[0])
-            assert output_content == "TestData\n", output_content
-            output_multiple_content = self.dataset_populator.get_history_dataset_content(history_id, dataset=output[1])
-            assert output_multiple_content == "TestData\nTestData\n", output_multiple_content
-
     @skip_without_tool("cat1")
     def test_run_cat1(self):
         with self.dataset_populator.test_history(require_new=False) as history_id:
diff --git a/lib/galaxy_test/base/populators.py b/lib/galaxy_test/base/populators.py
index e2c9e1544971..76980b94371f 100644
--- a/lib/galaxy_test/base/populators.py
+++ b/lib/galaxy_test/base/populators.py
@@ -792,13 +792,17 @@ def _wait_for_purge():
         return self._get(dataset_url)
 
     def create_tool_landing(self, payload: CreateToolLandingRequestPayload) -> ToolLandingRequest:
-        create_url = "tool_landings"
-        json = payload.model_dump(mode="json")
-        create_response = self._post(create_url, json, json=True, anon=True)
+        create_response = self.create_tool_landing_raw(payload)
         api_asserts.assert_status_code_is(create_response, 200)
         create_response.raise_for_status()
         return ToolLandingRequest.model_validate(create_response.json())
 
+    def create_tool_landing_raw(self, payload: CreateToolLandingRequestPayload) -> Response:
+        create_url = "tool_landings"
+        json = payload.model_dump(mode="json")
+        create_response = self._post(create_url, json, json=True, anon=True)
+        return create_response
+
     def create_workflow_landing(self, payload: CreateWorkflowLandingRequestPayload) -> WorkflowLandingRequest:
         create_url = "workflow_landings"
         json = payload.model_dump(mode="json")
@@ -1515,8 +1519,38 @@ 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):
+        # should this to defer to interactor's copy of this method?
+
+        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 get_tool_request(self, tool_request_id: str) -> Dict[str, Any]:
+        response = self._get(f"tool_requests/{tool_request_id}")
+        api_asserts.assert_status_code_is_ok(response)
+        return response.json()
+
+    def get_history_tool_requests(self, history_id: str) -> List[Dict[str, Any]]:
+        response = self._get(f"histories/{history_id}/tool_requests")
+        api_asserts.assert_status_code_is_ok(response)
+        return response.json()
+
     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):
@@ -3455,6 +3489,17 @@ def with_file_ext(self, expected_ext: str) -> Self:
             raise AssertionError(f"Output dataset had file extension {ext}, not the expected extension {expected_ext}")
         return self
 
+    @property
+    def json(self) -> Any:
+        contents = self.contents
+        return json.loads(contents)
+
+    def with_json(self, expected_json: Any) -> Self:
+        json = self.json
+        if json != expected_json:
+            raise AssertionError(f"Output dataset contianed JSON {json}, not {expected_json} as expected")
+        return self
+
     # aliases that might help make tests more like English in particular cases. Declaring them explicitly
     # instead quick little aliases because of https://github.com/python/mypy/issues/6700
     def assert_contains(self, expected_contents: str) -> Self:
@@ -3579,6 +3624,9 @@ class DescribeFailure:
     def __init__(self, response: Response):
         self._response = response
 
+    def __call__(self) -> Self:
+        return self
+
     def with_status_code(self, code: int) -> Self:
         api_asserts.assert_status_code_is(self._response, code)
         return self
@@ -3603,6 +3651,34 @@ def execute(self) -> "DescribeToolExecution":
         return execution
 
 
+class DescribeToolInputs:
+    _input_format: str = "legacy"
+    _inputs: Optional[Dict[str, Any]]
+
+    def __init__(self, input_format: str):
+        self._input_format = input_format
+        self._inputs = None
+
+    def any(self, inputs: Dict[str, Any]) -> Self:
+        self._inputs = inputs
+        return self
+
+    def flat(self, inputs: Dict[str, Any]) -> Self:
+        if self._input_format == "legacy":
+            self._inputs = inputs
+        return self
+
+    def nested(self, inputs: Dict[str, Any]) -> Self:
+        if self._input_format == "21.01":
+            self._inputs = inputs
+        return self
+
+    # aliases for self to create silly little English sentense... inputs.when.flat().when.legacy()
+    @property
+    def when(self) -> Self:
+        return self
+
+
 class DescribeToolExecution:
     _history_id: Optional[str] = None
     _execute_response: Optional[Response] = None
@@ -3621,8 +3697,13 @@ def in_history(self, has_history_id: Union[str, "TargetHistory"]) -> Self:
             self._history_id = has_history_id._history_id
         return self
 
-    def with_inputs(self, inputs: Dict[str, Any]) -> Self:
-        self._inputs = inputs
+    def with_inputs(self, inputs: Union[DescribeToolInputs, Dict[str, Any]]) -> Self:
+        if isinstance(inputs, DescribeToolInputs):
+            self._inputs = inputs._inputs or {}
+            self._input_format = inputs._input_format
+        else:
+            self._inputs = inputs
+            self._input_format = "legacy"
         return self
 
     def with_nested_inputs(self, inputs: Dict[str, Any]) -> Self:
@@ -3689,12 +3770,24 @@ def assert_has_job(self, job_index: int = 0) -> DescribeJob:
         return DescribeJob(self._dataset_populator, history_id, job["id"])
 
     @property
-    def assert_fails(self) -> DescribeFailure:
+    def that_fails(self) -> DescribeFailure:
         self._ensure_executed()
         execute_response = self._execute_response
         assert execute_response is not None
-        api_asserts.assert_status_code_is_not_ok(execute_response)
-        return DescribeFailure(execute_response)
+        if execute_response.status_code != 200:
+            return DescribeFailure(execute_response)
+        else:
+            response = self._assert_executed_ok()
+            jobs = response["jobs"]
+            for job in jobs:
+                final_state = self._dataset_populator.wait_for_job(job["id"])
+                assert final_state == "error"
+            return DescribeFailure(execute_response)
+
+    # alternative assert_ syntax for cases where it reads better.
+    @property
+    def assert_fails(self) -> DescribeFailure:
+        return self.that_fails
 
 
 class GiHttpMixin:
diff --git a/lib/tool_shed/webapp/api2/tools.py b/lib/tool_shed/webapp/api2/tools.py
index be5d04da9aeb..b8709060eda9 100644
--- a/lib/tool_shed/webapp/api2/tools.py
+++ b/lib/tool_shed/webapp/api2/tools.py
@@ -9,9 +9,11 @@
 
 from galaxy.tool_util.models import ParsedTool
 from galaxy.tool_util.parameters import (
+    LandingRequestToolState,
     RequestToolState,
-    to_json_schema_string,
+    TestCaseToolState,
 )
+from galaxy.webapps.galaxy.api import json_schema_response_for_tool_state_model
 from tool_shed.context import SessionRequestContext
 from tool_shed.managers.tools import (
     parsed_tool_model_cached_for,
@@ -57,11 +59,6 @@
 )
 
 
-def json_schema_response(pydantic_model) -> Response:
-    json_str = to_json_schema_string(pydantic_model)
-    return Response(content=json_str, media_type="application/json")
-
-
 @router.cbv
 class FastAPITools:
     app: ToolShedApp = depends(ToolShedApp)
@@ -158,15 +155,43 @@ def show_tool(
 
     @router.get(
         "/api/tools/{tool_id}/versions/{tool_version}/parameter_request_schema",
-        operation_id="tools__parameter_request_model",
+        operation_id="tools__parameter_request_schema",
         summary="Return a JSON schema description of the tool's inputs for the tool request API that will be added to Galaxy at some point",
         description="The tool request schema includes validation of map/reduce concepts that can be consumed by the tool execution API and not just the request for a single execution.",
     )
-    def tool_state(
+    def tool_state_request(
+        self,
+        trans: SessionRequestContext = DependsOnTrans,
+        tool_id: str = TOOL_ID_PATH_PARAM,
+        tool_version: str = TOOL_VERSION_PATH_PARAM,
+    ) -> Response:
+        parsed_tool = parsed_tool_model_cached_for(trans, tool_id, tool_version)
+        return json_schema_response_for_tool_state_model(RequestToolState, parsed_tool.inputs)
+
+    @router.get(
+        "/api/tools/{tool_id}/versions/{tool_version}/parameter_landing_request_schema",
+        operation_id="tools__parameter_landing_request_schema",
+        summary="Return a JSON schema description of the tool's inputs for the tool landing request API.",
+    )
+    def tool_state_landing_request(
+        self,
+        trans: SessionRequestContext = DependsOnTrans,
+        tool_id: str = TOOL_ID_PATH_PARAM,
+        tool_version: str = TOOL_VERSION_PATH_PARAM,
+    ) -> Response:
+        parsed_tool = parsed_tool_model_cached_for(trans, tool_id, tool_version)
+        return json_schema_response_for_tool_state_model(LandingRequestToolState, parsed_tool.inputs)
+
+    @router.get(
+        "/api/tools/{tool_id}/versions/{tool_version}/parameter_test_case_xml_schema",
+        operation_id="tools__parameter_test_case_xml_schema",
+        summary="Return a JSON schema description of the tool's inputs for test case construction.",
+    )
+    def tool_state_test_case_xml(
         self,
         trans: SessionRequestContext = DependsOnTrans,
         tool_id: str = TOOL_ID_PATH_PARAM,
         tool_version: str = TOOL_VERSION_PATH_PARAM,
     ) -> Response:
         parsed_tool = parsed_tool_model_cached_for(trans, tool_id, tool_version)
-        return json_schema_response(RequestToolState.parameter_model_for(parsed_tool.inputs))
+        return json_schema_response_for_tool_state_model(TestCaseToolState, parsed_tool.inputs)
diff --git a/lib/tool_shed/webapp/frontend/src/schema/schema.ts b/lib/tool_shed/webapp/frontend/src/schema/schema.ts
index 5667b073d0e6..d52683b36513 100644
--- a/lib/tool_shed/webapp/frontend/src/schema/schema.ts
+++ b/lib/tool_shed/webapp/frontend/src/schema/schema.ts
@@ -532,6 +532,23 @@ export interface paths {
         patch?: never
         trace?: never
     }
+    "/api/tools/{tool_id}/versions/{tool_version}/parameter_landing_request_schema": {
+        parameters: {
+            query?: never
+            header?: never
+            path?: never
+            cookie?: never
+        }
+        /** Return a JSON schema description of the tool's inputs for the tool landing request API. */
+        get: operations["tools__parameter_landing_request_schema"]
+        put?: never
+        post?: never
+        delete?: never
+        options?: never
+        head?: never
+        patch?: never
+        trace?: never
+    }
     "/api/tools/{tool_id}/versions/{tool_version}/parameter_request_schema": {
         parameters: {
             query?: never
@@ -543,7 +560,24 @@ export interface paths {
          * Return a JSON schema description of the tool's inputs for the tool request API that will be added to Galaxy at some point
          * @description The tool request schema includes validation of map/reduce concepts that can be consumed by the tool execution API and not just the request for a single execution.
          */
-        get: operations["tools__parameter_request_model"]
+        get: operations["tools__parameter_request_schema"]
+        put?: never
+        post?: never
+        delete?: never
+        options?: never
+        head?: never
+        patch?: never
+        trace?: never
+    }
+    "/api/tools/{tool_id}/versions/{tool_version}/parameter_test_case_xml_schema": {
+        parameters: {
+            query?: never
+            header?: never
+            path?: never
+            cookie?: never
+        }
+        /** Return a JSON schema description of the tool's inputs for test case construction. */
+        get: operations["tools__parameter_test_case_xml_schema"]
         put?: never
         post?: never
         delete?: never
@@ -1386,6 +1420,16 @@ export interface components {
              * @enum {string}
              */
             parameter_type: "gx_directory_uri"
+            /**
+             * Validators
+             * @default []
+             */
+            validators: (
+                | components["schemas"]["LengthParameterValidatorModel"]
+                | components["schemas"]["RegexParameterValidatorModel"]
+                | components["schemas"]["ExpressionParameterValidatorModel"]
+                | components["schemas"]["EmptyFieldParameterValidatorModel"]
+            )[]
         }
         /** DrillDownOptionsDict */
         DrillDownOptionsDict: {
@@ -1440,6 +1484,57 @@ export interface components {
              */
             parameter_type: "gx_drill_down"
         }
+        /** EmptyFieldParameterValidatorModel */
+        EmptyFieldParameterValidatorModel: {
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean
+            /** Message */
+            message?: string | null
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean
+            /**
+             * Type
+             * @default empty_field
+             * @constant
+             * @enum {string}
+             */
+            type: "empty_field"
+        }
+        /**
+         * ExpressionParameterValidatorModel
+         * @description Check if a one line python expression given expression evaluates to True.
+         *
+         *     The expression is given is the content of the validator tag.
+         */
+        ExpressionParameterValidatorModel: {
+            /** Expression */
+            expression: string
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean
+            /** Message */
+            message?: string | null
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean
+            /**
+             * Type
+             * @default expression
+             * @constant
+             * @enum {string}
+             */
+            type: "expression"
+        }
         /** FailedRepositoryUpdateMessage */
         FailedRepositoryUpdateMessage: {
             /** Err Msg */
@@ -1514,6 +1609,11 @@ export interface components {
              * @enum {string}
              */
             parameter_type: "gx_float"
+            /**
+             * Validators
+             * @default []
+             */
+            validators: components["schemas"]["InRangeParameterValidatorModel"][]
             /** Value */
             value?: number | null
         }
@@ -1629,6 +1729,16 @@ export interface components {
              * @enum {string}
              */
             parameter_type: "gx_hidden"
+            /**
+             * Validators
+             * @default []
+             */
+            validators: (
+                | components["schemas"]["LengthParameterValidatorModel"]
+                | components["schemas"]["RegexParameterValidatorModel"]
+                | components["schemas"]["ExpressionParameterValidatorModel"]
+                | components["schemas"]["EmptyFieldParameterValidatorModel"]
+            )[]
             /** Value */
             value: string | null
         }
@@ -1666,6 +1776,42 @@ export interface components {
          * @enum {string}
          */
         ImageType: "Docker" | "Singularity" | "Conda"
+        /** InRangeParameterValidatorModel */
+        InRangeParameterValidatorModel: {
+            /**
+             * Exclude Max
+             * @default false
+             */
+            exclude_max: boolean
+            /**
+             * Exclude Min
+             * @default false
+             */
+            exclude_min: boolean
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean
+            /** Max */
+            max?: number | null
+            /** Message */
+            message?: string | null
+            /** Min */
+            min?: number | null
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean
+            /**
+             * Type
+             * @default in_range
+             * @constant
+             * @enum {string}
+             */
+            type: "in_range"
+        }
         /** InstallInfo */
         InstallInfo: {
             metadata_info?: components["schemas"]["RepositoryMetadataInstallInfo"] | null
@@ -1704,6 +1850,11 @@ export interface components {
              * @enum {string}
              */
             parameter_type: "gx_integer"
+            /**
+             * Validators
+             * @default []
+             */
+            validators: components["schemas"]["InRangeParameterValidatorModel"][]
             /** Value */
             value?: number | null
         }
@@ -1716,6 +1867,32 @@ export interface components {
             /** Value */
             value: string
         }
+        /** LengthParameterValidatorModel */
+        LengthParameterValidatorModel: {
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean
+            /** Max */
+            max?: number | null
+            /** Message */
+            message?: string | null
+            /** Min */
+            min?: number | null
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean
+            /**
+             * Type
+             * @default length
+             * @constant
+             * @enum {string}
+             */
+            type: "length"
+        }
         /** MessageExceptionModel */
         MessageExceptionModel: {
             /** Err Code */
@@ -1723,6 +1900,28 @@ export interface components {
             /** Err Msg */
             err_msg: string
         }
+        /** NoOptionsParameterValidatorModel */
+        NoOptionsParameterValidatorModel: {
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean
+            /** Message */
+            message?: string | null
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean
+            /**
+             * Type
+             * @default no_options
+             * @constant
+             * @enum {string}
+             */
+            type: "no_options"
+        }
         /** Organization */
         Organization: {
             /**
@@ -1800,6 +1999,37 @@ export interface components {
             /** Xrefs */
             xrefs: components["schemas"]["XrefDict"][]
         }
+        /**
+         * RegexParameterValidatorModel
+         * @description Check if a regular expression **matches** the value, i.e. appears
+         *     at the beginning of the value. To enforce a match of the complete value use
+         *     ``$`` at the end of the expression. The expression is given is the content
+         *     of the validator tag. Note that for ``selects`` each option is checked
+         *     separately.
+         */
+        RegexParameterValidatorModel: {
+            /** Expression */
+            expression: string
+            /**
+             * Implicit
+             * @default false
+             */
+            implicit: boolean
+            /** Message */
+            message?: string | null
+            /**
+             * Negate
+             * @default false
+             */
+            negate: boolean
+            /**
+             * Type
+             * @default regex
+             * @constant
+             * @enum {string}
+             */
+            type: "regex"
+        }
         /** RepeatParameterModel */
         RepeatParameterModel: {
             /** Argument */
@@ -2254,6 +2484,8 @@ export interface components {
              * @enum {string}
              */
             parameter_type: "gx_select"
+            /** Validators */
+            validators: components["schemas"]["NoOptionsParameterValidatorModel"][]
         }
         /** Service */
         Service: {
@@ -2366,6 +2598,16 @@ export interface components {
              * @enum {string}
              */
             parameter_type: "gx_text"
+            /**
+             * Validators
+             * @default []
+             */
+            validators: (
+                | components["schemas"]["LengthParameterValidatorModel"]
+                | components["schemas"]["RegexParameterValidatorModel"]
+                | components["schemas"]["ExpressionParameterValidatorModel"]
+                | components["schemas"]["EmptyFieldParameterValidatorModel"]
+            )[]
             /** Value */
             value?: string | null
         }
@@ -4214,7 +4456,93 @@ export interface operations {
             }
         }
     }
-    tools__parameter_request_model: {
+    tools__parameter_landing_request_schema: {
+        parameters: {
+            query?: never
+            header?: never
+            path: {
+                /** @description See also https://ga4gh.github.io/tool-registry-service-schemas/DataModel/#trs-tool-and-trs-tool-version-ids */
+                tool_id: string
+                /** @description The full version string defined on the Galaxy tool wrapper. */
+                tool_version: string
+            }
+            cookie?: never
+        }
+        requestBody?: never
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown
+                }
+                content: {
+                    "application/json": unknown
+                }
+            }
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown
+                }
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"]
+                }
+            }
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown
+                }
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"]
+                }
+            }
+        }
+    }
+    tools__parameter_request_schema: {
+        parameters: {
+            query?: never
+            header?: never
+            path: {
+                /** @description See also https://ga4gh.github.io/tool-registry-service-schemas/DataModel/#trs-tool-and-trs-tool-version-ids */
+                tool_id: string
+                /** @description The full version string defined on the Galaxy tool wrapper. */
+                tool_version: string
+            }
+            cookie?: never
+        }
+        requestBody?: never
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown
+                }
+                content: {
+                    "application/json": unknown
+                }
+            }
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown
+                }
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"]
+                }
+            }
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown
+                }
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"]
+                }
+            }
+        }
+    }
+    tools__parameter_test_case_xml_schema: {
         parameters: {
             query?: never
             header?: never
diff --git a/packages/tool_util/setup.cfg b/packages/tool_util/setup.cfg
index eabca1a6e1b9..9db8b66ff45d 100644
--- a/packages/tool_util/setup.cfg
+++ b/packages/tool_util/setup.cfg
@@ -34,6 +34,7 @@ version = 24.2.dev0
 include_package_data = True
 install_requires =
     galaxy-util>=22.1
+    gxformat2
     conda-package-streaming
     lxml!=4.2.2
     MarkupSafe
diff --git a/test/functional/test_toolbox_pytest.py b/test/functional/test_toolbox_pytest.py
index 896e3609913e..cd6314a9fc85 100644
--- a/test/functional/test_toolbox_pytest.py
+++ b/test/functional/test_toolbox_pytest.py
@@ -1,11 +1,16 @@
 import os
 from typing import (
+    cast,
     List,
     NamedTuple,
 )
 
 import pytest
 
+from galaxy.tool_util.verify.interactor import (
+    DEFAULT_USE_LEGACY_API,
+    UseLegacyApiT,
+)
 from galaxy_test.api._framework import ApiTestCase
 from galaxy_test.driver.driver_util import GalaxyTestDriver
 
@@ -61,4 +66,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 = cast(UseLegacyApiT, os.environ.get("GALAXY_TEST_USE_LEGACY_TOOL_API", DEFAULT_USE_LEGACY_API))
+        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/gx_directory_uri_validation.xml b/test/functional/tools/parameters/gx_directory_uri_validation.xml
new file mode 100644
index 000000000000..7375c298b711
--- /dev/null
+++ b/test/functional/tools/parameters/gx_directory_uri_validation.xml
@@ -0,0 +1,16 @@
+<tool id="gx_directory_uri" name="gx_directory_uri" version="1.0.0">
+    <macros>
+        <import>macros.xml</import>
+    </macros>
+    <command><![CDATA[
+        echo 'parameter: $parameter' > $output
+    ]]></command>
+    <inputs>
+        <param type="directory_uri" name="parameter">
+            <validator type="length" min="10" max="45" />
+            <validator type="expression">'api' in value</validator>
+            <validator type="regex">^.*json$</validator>
+        </param>
+    </inputs>
+    <expand macro="simple_text_output" />
+</tool>
diff --git a/test/functional/tools/parameters/gx_drill_down_code.py b/test/functional/tools/parameters/gx_drill_down_code.py
new file mode 100644
index 000000000000..518cb67c6a7e
--- /dev/null
+++ b/test/functional/tools/parameters/gx_drill_down_code.py
@@ -0,0 +1,24 @@
+def collate_table(path: str) -> list:
+    with open(path, "r") as f:
+        contents = f.read()
+    first_options = []
+    second_options = []
+    values = [
+        {"name": "First Column", "value": "first", "selected": False, "options": first_options},
+        {"name": "Second Column", "value": "second", "selected": False, "options": second_options},
+    ]
+    seen_in_column_1 = set()
+    seen_in_column_2 = set()
+    for line in contents.splitlines():
+        parts = line.split("\t")
+        if len(parts) >= 1:
+            val = parts[0]
+            if val not in seen_in_column_1:
+                first_options.append({"name": val.upper(), "value": val, "selected": False, "options": []})
+                seen_in_column_1.add(val)
+        if len(parts) >= 2:
+            val = parts[1]
+            if val not in seen_in_column_2:
+                second_options.append({"name": val.upper(), "value": val, "selected": False, "options": []})
+                seen_in_column_2.add(val)
+    return values
diff --git a/test/functional/tools/parameters/gx_drill_down_code.xml b/test/functional/tools/parameters/gx_drill_down_code.xml
new file mode 100644
index 000000000000..42ae442574e4
--- /dev/null
+++ b/test/functional/tools/parameters/gx_drill_down_code.xml
@@ -0,0 +1,38 @@
+<tool id="gx_drill_down_code" name="gx_drill_down_code" version="1.0.0">
+    <macros>
+        <import>macros.xml</import>
+    </macros>
+    <code file="gx_drill_down_code.py"/>
+    <command><![CDATA[
+echo "parameter: $parameter" > '$output'
+    ]]></command>
+    <inputs>
+        <param name="ref_parameter" type="data" ext="tabular" >
+        </param>
+g        <param name="parameter" type="drill_down" dynamic_options="collate_table(ref_parameter.dataset.get_file_name())">
+        </param>
+    </inputs>
+    <expand macro="simple_text_output" />
+    <tests>
+        <test>
+            <param name="ref_parameter" value="1.tabular" />
+            <param name="parameter" value="chr22" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="parameter: chr22" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <param name="ref_parameter" value="1.tabular" />
+            <param name="parameter" value="2000" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="parameter: 2000" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+    <help>
+    </help>
+</tool>
diff --git a/test/functional/tools/parameters/gx_float_min_max.xml b/test/functional/tools/parameters/gx_float_min_max.xml
new file mode 100644
index 000000000000..55a4d6fb0881
--- /dev/null
+++ b/test/functional/tools/parameters/gx_float_min_max.xml
@@ -0,0 +1,14 @@
+<tool id="gx_float_validation_range" name="gx_float_validation_range" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" value="1" type="float" min="0.1" max="9.8">
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_float_validation_range.xml b/test/functional/tools/parameters/gx_float_validation_range.xml
new file mode 100644
index 000000000000..8988e92506df
--- /dev/null
+++ b/test/functional/tools/parameters/gx_float_validation_range.xml
@@ -0,0 +1,15 @@
+<tool id="gx_float_validation_range" name="gx_float_validation_range" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" value="1" type="float">
+            <validator type="in_range" min="0.1" max="9.8" exclude_min="false" exclude_max="true" />
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_hidden_validation.xml b/test/functional/tools/parameters/gx_hidden_validation.xml
new file mode 100644
index 000000000000..e40a67aae964
--- /dev/null
+++ b/test/functional/tools/parameters/gx_hidden_validation.xml
@@ -0,0 +1,17 @@
+<tool id="gx_hidden_validation" name="gx_hidden_validation" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" type="hidden" value="http://mycoolsource/api/index.json">
+            <validator type="length" min="10" max="45" />
+            <validator type="expression">'api' in value</validator>
+            <validator type="regex">^.*json$</validator>
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_int_min_max.xml b/test/functional/tools/parameters/gx_int_min_max.xml
new file mode 100644
index 000000000000..c826948d746c
--- /dev/null
+++ b/test/functional/tools/parameters/gx_int_min_max.xml
@@ -0,0 +1,14 @@
+<tool id="gx_int_min_max" name="gx_int_min_max" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" value="1" type="integer" min="0" max="10">
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_int_validation_range.xml b/test/functional/tools/parameters/gx_int_validation_range.xml
new file mode 100644
index 000000000000..5f7862497abf
--- /dev/null
+++ b/test/functional/tools/parameters/gx_int_validation_range.xml
@@ -0,0 +1,15 @@
+<tool id="gx_int_validation_range" name="gx_int_validation_range" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <inputs>
+        <param name="parameter" value="1" type="integer">
+            <validator type="in_range" min="0" max="10" exclude_min="false" exclude_max="true" />
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select_dynamic.xml b/test/functional/tools/parameters/gx_select_dynamic.xml
new file mode 100644
index 000000000000..8959f3d0e3d4
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_dynamic.xml
@@ -0,0 +1,36 @@
+<tool id="gx_select_dynamic" name="gx_select_dynamic" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <code file="gx_select_dynamic_options.py"/>
+    <inputs>
+        <param name="ref_parameter" type="data" ext="txt" >
+        </param>
+        <param name="parameter" type="select" dynamic_options="every_other_word(ref_parameter.dataset.get_file_name())">
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+        <test>
+            <param name="ref_parameter" value="simple_line.txt" />
+            <param name="parameter" value="of" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="of" />
+                </assert_contents>
+            </output>
+        </test>
+        <test>
+            <!-- Selects implicitly default to the first option as the default option.
+            -->
+            <param name="ref_parameter" value="simple_line.txt" />
+            <output name="output">
+                <assert_contents>
+                    <has_line line="This" />
+                </assert_contents>
+            </output>
+        </test>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select_dynamic_empty.py b/test/functional/tools/parameters/gx_select_dynamic_empty.py
new file mode 100644
index 000000000000..6a79a047f3cb
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_dynamic_empty.py
@@ -0,0 +1,8 @@
+from typing import (
+    List,
+    Tuple,
+)
+
+
+def empty_list() -> List[Tuple[str, str, bool]]:
+    return []
diff --git a/test/functional/tools/parameters/gx_select_dynamic_empty.xml b/test/functional/tools/parameters/gx_select_dynamic_empty.xml
new file mode 100644
index 000000000000..7554604033fd
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_dynamic_empty.xml
@@ -0,0 +1,15 @@
+<tool id="gx_select_dynamic_empty" name="gx_select_dynamic_empty" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <code file="gx_select_dynamic_empty.py"/>
+    <inputs>
+        <param name="parameter" type="select" dynamic_options="empty_list()">
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select_dynamic_empty_validated.xml b/test/functional/tools/parameters/gx_select_dynamic_empty_validated.xml
new file mode 100644
index 000000000000..39ffa263174e
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_dynamic_empty_validated.xml
@@ -0,0 +1,16 @@
+<tool id="gx_select_dynamic_empty_validated" name="gx_select_dynamic_empty_validated" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output'
+    ]]></command>
+    <code file="gx_select_dynamic_empty.py"/>
+    <inputs>
+        <param name="parameter" type="select" dynamic_options="empty_list()">
+            <validator type="no_options" message="this is the empty message" />
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select_dynamic_options.py b/test/functional/tools/parameters/gx_select_dynamic_options.py
new file mode 100644
index 000000000000..734174b6da1d
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_dynamic_options.py
@@ -0,0 +1,10 @@
+from typing import (
+    List,
+    Tuple,
+)
+
+
+def every_other_word(path: str) -> List[Tuple[str, str, bool]]:
+    with open(path, "r") as f:
+        contents = f.read()
+    return [(r.strip(), r.strip(), False) for (i, r) in enumerate(contents.split()) if i % 2 == 0]
diff --git a/test/functional/tools/parameters/gx_select_no_options_validation.xml b/test/functional/tools/parameters/gx_select_no_options_validation.xml
new file mode 100644
index 000000000000..217b95b53639
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_no_options_validation.xml
@@ -0,0 +1,20 @@
+<tool id="gx_select_no_options_validation" name="gx_select_no_options_validation" 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>
+            <validator type="no_options" />
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_select_optional_no_options_validation.xml b/test/functional/tools/parameters/gx_select_optional_no_options_validation.xml
new file mode 100644
index 000000000000..6e3e78de0400
--- /dev/null
+++ b/test/functional/tools/parameters/gx_select_optional_no_options_validation.xml
@@ -0,0 +1,20 @@
+<tool id="gx_select_optional_no_options_validation" name="gx_select_optional_no_options_validation" 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>
+            <validator type="no_options" />
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_text.xml b/test/functional/tools/parameters/gx_text.xml
index 16707f63e878..3b9e2e00dfbc 100644
--- a/test/functional/tools/parameters/gx_text.xml
+++ b/test/functional/tools/parameters/gx_text.xml
@@ -1,12 +1,17 @@
 <tool id="gx_text" name="gx_text" version="1.0.0">
     <command><![CDATA[
-echo '$parameter' >> '$output'
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
     ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
     <inputs>
         <param name="parameter" type="text" />
     </inputs>
     <outputs>
         <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
     </outputs>
     <tests>
         <test>
diff --git a/test/functional/tools/parameters/gx_text_empty_validation.xml b/test/functional/tools/parameters/gx_text_empty_validation.xml
new file mode 100644
index 000000000000..76374be72ded
--- /dev/null
+++ b/test/functional/tools/parameters/gx_text_empty_validation.xml
@@ -0,0 +1,20 @@
+<tool id="gx_text_empty_validation" name="gx_text_empty_validation" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
+    ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
+    <inputs>
+        <param name="parameter" type="text">
+            <validator type="empty_field" />
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_text_expression_validation.xml b/test/functional/tools/parameters/gx_text_expression_validation.xml
new file mode 100644
index 000000000000..fe5113ec8fef
--- /dev/null
+++ b/test/functional/tools/parameters/gx_text_expression_validation.xml
@@ -0,0 +1,20 @@
+<tool id="gx_text_expression_validation" name="gx_text_expression_validation" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
+    ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
+    <inputs>
+        <param name="parameter" type="text">
+            <validator type="expression">'foobar' in value</validator>
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_text_length_validation.xml b/test/functional/tools/parameters/gx_text_length_validation.xml
new file mode 100644
index 000000000000..4d5434aa6c58
--- /dev/null
+++ b/test/functional/tools/parameters/gx_text_length_validation.xml
@@ -0,0 +1,20 @@
+<tool id="gx_text_length_validation" name="gx_text_length_validation" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
+    ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
+    <inputs>
+        <param name="parameter" type="text">
+            <validator type="length" min="2" max="10" />
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_text_length_validation_negate.xml b/test/functional/tools/parameters/gx_text_length_validation_negate.xml
new file mode 100644
index 000000000000..4b0b835fe562
--- /dev/null
+++ b/test/functional/tools/parameters/gx_text_length_validation_negate.xml
@@ -0,0 +1,20 @@
+<tool id="gx_text_length_validation" name="gx_text_length_validation" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
+    ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
+    <inputs>
+        <param name="parameter" type="text">
+            <validator type="length" min="2" max="10" negate="true" />
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_text_optional.xml b/test/functional/tools/parameters/gx_text_optional.xml
index 41fe11cea418..ae10d3278376 100644
--- a/test/functional/tools/parameters/gx_text_optional.xml
+++ b/test/functional/tools/parameters/gx_text_optional.xml
@@ -1,12 +1,17 @@
 <tool id="gx_text_optional" name="gx_text_optional" version="1.0.0">
     <command><![CDATA[
-echo '$parameter' >> '$output'
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
     ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
     <inputs>
         <param name="parameter" type="text" optional="true" />
     </inputs>
     <outputs>
         <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
     </outputs>
     <tests>
         <test>
diff --git a/test/functional/tools/parameters/gx_text_optional_false.xml b/test/functional/tools/parameters/gx_text_optional_false.xml
new file mode 100644
index 000000000000..9e29d53fc4ca
--- /dev/null
+++ b/test/functional/tools/parameters/gx_text_optional_false.xml
@@ -0,0 +1,18 @@
+<tool id="gx_text_optional_false" name="gx_text_optional_false" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
+    ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
+    <inputs>
+        <param name="parameter" type="text" optional="false" />
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/functional/tools/parameters/gx_text_regex_validation.xml b/test/functional/tools/parameters/gx_text_regex_validation.xml
new file mode 100644
index 000000000000..2e1bd7325d8a
--- /dev/null
+++ b/test/functional/tools/parameters/gx_text_regex_validation.xml
@@ -0,0 +1,20 @@
+<tool id="gx_text_regex_validation" name="gx_text_regex_validation" version="1.0.0">
+    <command><![CDATA[
+echo '$parameter' >> '$output';
+cat '$inputs' >> $inputs_json;
+    ]]></command>
+    <configfiles>
+        <inputs name="inputs" filename="inputs.json" />
+    </configfiles>
+    <inputs>
+        <param name="parameter" type="text">
+            <validator type="regex">^[actg]*$</validator>
+        </param>
+    </inputs>
+    <outputs>
+        <data name="output" format="txt" />
+        <data name="inputs_json" format="json" />
+    </outputs>
+    <tests>
+    </tests>
+</tool>
diff --git a/test/unit/app/managers/test_landing.py b/test/unit/app/managers/test_landing.py
index 211e1f8010e5..a81146465bff 100644
--- a/test/unit/app/managers/test_landing.py
+++ b/test/unit/app/managers/test_landing.py
@@ -1,3 +1,7 @@
+from typing import (
+    cast,
+    List,
+)
 from uuid import uuid4
 
 from galaxy.exceptions import (
@@ -19,6 +23,11 @@
     ToolLandingRequest,
     WorkflowLandingRequest,
 )
+from galaxy.structured_app import MinimalManagerApp
+from galaxy.tool_util.parameters import (
+    DataParameterModel,
+    ToolParameterT,
+)
 from .base import BaseTestCase
 
 TEST_TOOL_ID = "cat1"
@@ -33,11 +42,35 @@
 CLIENT_SECRET = "mycoolsecret"
 
 
+class MockApp:
+
+    @property
+    def toolbox(self):
+        return MockToolbox()
+
+
+class MockToolbox:
+
+    def get_tool(self, tool_id, tool_uuid, tool_version):
+        return MockTool()
+
+
+class MockTool:
+
+    @property
+    def parameters(self) -> List[ToolParameterT]:
+        return [DataParameterModel(name="input1")]
+
+
 class TestLanding(BaseTestCase):
 
     def setUp(self):
         super().setUp()
-        self.landing_manager = LandingRequestManager(self.trans.sa_session, self.app.security)
+        self.landing_manager = LandingRequestManager(
+            self.trans.sa_session,
+            self.app.security,
+            cast(MinimalManagerApp, MockApp()),
+        )
 
     def test_tool_landing_requests_typical_flow(self):
         landing_request: ToolLandingRequest = self.landing_manager.create_tool_landing_request(self._tool_request)
diff --git a/test/unit/app/tools/test_dynamic_options.py b/test/unit/app/tools/test_dynamic_options.py
index 38626d65b991..05ec365a379e 100644
--- a/test/unit/app/tools/test_dynamic_options.py
+++ b/test/unit/app/tools/test_dynamic_options.py
@@ -6,6 +6,12 @@
 
 
 def get_from_url_option():
+    tool_param = Bunch(
+        tool=Bunch(
+            app=Bunch(),
+        ),
+    )
+
     return DynamicOptions(
         XML(
             """
@@ -26,7 +32,7 @@ def get_from_url_option():
 </options>
 """
         ),
-        Bunch(),
+        tool_param,
     )
 
 
diff --git a/test/unit/app/tools/test_parameter_validation.py b/test/unit/app/tools/test_parameter_validation.py
index a7798927eb65..4b69034fac4b 100644
--- a/test/unit/app/tools/test_parameter_validation.py
+++ b/test/unit/app/tools/test_parameter_validation.py
@@ -220,12 +220,12 @@ def test_InRangeValidator(self):
         p.validate(10)
         with self.assertRaisesRegex(
             ValueError,
-            r"Parameter blah: Value \('15'\) must not fulfill float\('10'\) < float\(value\) <= float\('20'\)",
+            r"Parameter blah: Value \('15'\) must not fulfill \(10 < value <= 20\)",
         ):
             p.validate(15)
         with self.assertRaisesRegex(
             ValueError,
-            r"Parameter blah: Value \('20'\) must not fulfill float\('10'\) < float\(value\) <= float\('20'\)",
+            r"Parameter blah: Value \('20'\) must not fulfill \(10 < value <= 20\)",
         ):
             p.validate(20)
         p.validate(21)
diff --git a/test/unit/app/tools/test_populate_state.py b/test/unit/app/tools/test_populate_state.py
new file mode 100644
index 000000000000..2dad23f37f3f
--- /dev/null
+++ b/test/unit/app/tools/test_populate_state.py
@@ -0,0 +1,82 @@
+from typing import (
+    Any,
+    cast,
+    Dict,
+)
+
+from galaxy.app_unittest_utils.galaxy_mock import MockTrans
+from galaxy.app_unittest_utils.tools_support import UsesTools
+from galaxy.tool_util.unittest_utils import functional_test_tool_path
+from galaxy.tools.parameters import (
+    populate_state,
+    ToolInputsT,
+)
+from galaxy.tools.parameters.basic import (
+    BooleanToolParameter,
+    TextToolParameter,
+)
+from galaxy.tools.parameters.grouping import (
+    Conditional,
+    ConditionalWhen,
+    Repeat,
+)
+from galaxy.util import XML
+from galaxy.util.bunch import Bunch
+from galaxy.util.unittest import TestCase
+
+trans = Bunch(workflow_building_mode=False)
+
+
+def mock_when(**kwd):
+    return cast(ConditionalWhen, Bunch(**kwd))
+
+
+def test_populate_state():
+    a = TextToolParameter(None, XML('<param name="a"/>'))
+    b = Repeat("b")
+    b.min = 0
+    b.max = 1
+    c = TextToolParameter(None, XML('<param name="c"/>'))
+    d = Repeat("d")
+    d.min = 0
+    d.max = 1
+    e = TextToolParameter(None, XML('<param name="e"/>'))
+    f = Conditional("f")
+    g = BooleanToolParameter(None, XML('<param name="g"/>'))
+    h = TextToolParameter(None, XML('<param name="h"/>'))
+    i = TextToolParameter(None, XML('<param name="i"/>'))
+    b.inputs = {"c": c, "d": d}
+    d.inputs = {"e": e, "f": f}
+    f.test_param = g
+    f.cases = [mock_when(value="true", inputs={"h": h}), mock_when(value="false", inputs={"i": i})]
+    inputs = {"a": a, "b": b}
+    flat = {"a": 1, "b_0|c": 2, "b_0|d_0|e": 3, "b_0|d_0|f|h": 4, "b_0|d_0|f|g": True}
+    state: Dict[str, Any] = {}
+    populate_state(trans, cast(ToolInputsT, inputs), flat, state, check=False)
+    assert state["a"] == 1
+    assert state["b"][0]["c"] == 2
+    assert state["b"][0]["d"][0]["e"] == 3
+    assert state["b"][0]["d"][0]["f"]["h"] == 4
+    # now test with input_format='21.01'
+    nested = {"a": 1, "b": [{"c": 2, "d": [{"e": 3, "f": {"h": 4, "g": True}}]}]}
+    state_new: Dict[str, Any] = {}
+    populate_state(trans, cast(ToolInputsT, inputs), nested, state_new, check=False, input_format="21.01")
+    assert state_new["a"] == 1
+    assert state_new["b"][0]["c"] == 2
+    assert state_new["b"][0]["d"][0]["e"] == 3
+    assert state_new["b"][0]["d"][0]["f"]["h"] == 4
+
+
+class TestMetadata(TestCase, UsesTools):
+    def setUp(self):
+        super().setUp()
+        self.setup_app()
+        self.trans = MockTrans(app=self.app)
+
+    def test_boolean_validation(self):
+        source_file_name = functional_test_tool_path("parameters/gx_data_column.xml")
+        tool = self._init_tool_for_path(source_file_name)
+        incoming = {"ref_parameter": {"src": "hda", "id": 89}, "parameter": "m89"}
+        state_new: Dict[str, Any] = {}
+        errors: Dict[str, Any] = {}
+        populate_state(self.trans, tool.inputs, incoming, state_new, errors=errors, check=True, input_format="21.01")
diff --git a/test/unit/app/tools/test_validation_parsing.py b/test/unit/app/tools/test_validation_parsing.py
new file mode 100644
index 000000000000..c13b0973e6a0
--- /dev/null
+++ b/test/unit/app/tools/test_validation_parsing.py
@@ -0,0 +1,41 @@
+from typing import Optional
+
+from galaxy.tool_util.unittest_utils.sample_data import (
+    INVALID_XML_VALIDATORS,
+    VALID_XML_VALIDATORS,
+)
+from galaxy.tools.parameters.validation import parse_xml_validators
+from galaxy.util import XML
+
+
+class MockApp:
+
+    @property
+    def tool_data_tables(self):
+        return {"mycooltable": MockTable()}
+
+
+class MockTable:
+
+    def get_version_fields(self):
+        return (1, [])
+
+
+def test_xml_validation_valid():
+    for xml_validator in VALID_XML_VALIDATORS:
+        _validate_xml_str(xml_validator)
+
+
+def test_xml_validation_invalid():
+    for xml_validator in INVALID_XML_VALIDATORS:
+        exc: Optional[Exception] = None
+        try:
+            _validate_xml_str(xml_validator)
+        except ValueError as e:
+            exc = e
+        assert exc is not None, f"{xml_validator} - validated when it wasn't expected to"
+
+
+def _validate_xml_str(xml_str: str):
+    xml_el = XML(f"<param>{xml_str}</param>")
+    parse_xml_validators(MockApp(), xml_el)
diff --git a/test/unit/tool_util/parameter_specification.yml b/test/unit/tool_util/parameter_specification.yml
index 761a1c3fb680..f444e7189869 100644
--- a/test/unit/tool_util/parameter_specification.yml
+++ b/test/unit/tool_util/parameter_specification.yml
@@ -32,6 +32,18 @@ gx_int:
   job_internal_invalid:
    - parameter: null
    - {}
+  landing_request_valid:
+    - {}
+    - parameter: 5
+  landing_request_invalid:
+    - parameter: "moo"
+    - parameter: "5"
+  landing_request_internal_valid:
+    - {}
+    - parameter: 5
+  landing_request_internal_invalid:
+    - parameter: "moo"
+    - parameter: "5"
   test_case_xml_valid:
     - parameter: 5
     - {}
@@ -71,6 +83,21 @@ gx_boolean:
    - parameter: false
   job_internal_invalid:
    - {}
+  landing_request_valid:
+    - {}
+    - parameter: true
+    - parameter: false
+  landing_request_invalid:
+    - parameter: "true"
+    - parameter: "5"
+  landing_request_internal_valid:
+    - {}
+    - parameter: true
+    - parameter: false
+  landing_request_internal_invalid:
+    - parameter: "moo"
+    - parameter: "true"
+    - parameter: "5"
   workflow_step_valid:
     - parameter: True
     - {}
@@ -102,6 +129,20 @@ gx_int_optional:
    - parameter: null
   job_internal_invalid:
    - {}
+  landing_request_valid:
+    - {}
+    - parameter: 5
+    - parameter: null
+  landing_request_invalid:
+    - parameter: "moo"
+    - parameter: "5"
+  landing_request_internal_valid:
+    - {}
+    - parameter: 5
+    - parameter: null
+  landing_request_internal_invalid:
+    - parameter: "moo"
+    - parameter: "5"
   workflow_step_valid:
    - parameter: 5
    - parameter: null
@@ -132,19 +173,99 @@ gx_int_required: &gx_int_required
    - parameter: 5
   job_internal_invalid:
    - {}
+  # and actual request will require a value but the landing only needs to specify parameters
+  # of interest - forcing users to make the rest of the selections.
+  landing_request_valid:
+    - {}
+    - parameter: 5
+  landing_request_invalid:
+    - parameter: "moo"
+    - parameter: "5"
+  landing_request_internal_valid:
+    - {}
+    - parameter: 5
+  landing_request_internal_invalid:
+    - parameter: "moo"
+    - parameter: "5"
 
 gx_int_required_via_empty_string:
   <<: *gx_int_required
 
+gx_int_validation_range:
+  request_valid:
+  - parameter: 1
+  - parameter: 9
+  request_invalid:
+  - parameter: {}
+  - parameter: {__class__: 'ConnectedValue'}
+  - parameter: -1
+  - parameter: 11
+  - parameter: 10
+  workflow_step_linked_valid:
+   - parameter: {__class__: 'ConnectedValue'}
+
+gx_int_min_max:
+  request_valid:
+  - parameter: 1
+  - parameter: 9
+  - parameter: 10
+  request_invalid:
+  - parameter: -1
+  - parameter: 11
+  workflow_step_linked_valid:
+  - parameter: {__class__: 'ConnectedValue'}
+  workflow_step_linked_invalid:
+  - parameter: -1
+
+gx_text_regex_validation:
+  request_valid:
+  - parameter: acgt
+  - parameter: a
+  - parameter: aaaggttac
+  request_invalid:
+  - parameter: acgu
+  - parameter: nucleic
+  workflow_step_linked_valid:
+   - parameter: {__class__: 'ConnectedValue'}
+
+gx_text_expression_validation:
+  request_valid:
+  - parameter: the code was foobar
+  - parameter: foobar
+  request_invalid:
+  - parameter: the code was not foo bar
+  - parameter: ''
+  workflow_step_linked_valid:
+  - parameter: {__class__: 'ConnectedValue'}
+  workflow_step_linked_invalid:
+  - parameter: ''
+
+gx_text_empty_validation:
+  request_valid:
+  - parameter: foobar
+  - {}
+  request_invalid:
+  - parameter: ''
+  job_internal_valid:
+  - parameter: foobar
+  job_internal_invalid:
+  - {}
+  - parameter: ''
+  workflow_step_linked_valid:
+  - parameter: {__class__: 'ConnectedValue'}
+  workflow_step_linked_invalid:
+  - parameter: ''
+
 gx_text:
   request_valid: &gx_text_request_valid
     - parameter: moocow
     - parameter: 'some spaces'
     - parameter: ''
     - {}
+    # need to explicitly mark these as non-optional
+    - parameter: null
   request_invalid: &gx_text_request_invalid
     - parameter: 5
-    - parameter: null
     - parameter: {}
     - parameter: { "moo": "cow" }
     - parameter: {__class__: 'ConnectedValue'}
@@ -156,22 +277,30 @@ gx_text:
     *gx_text_request_valid
   request_internal_dereferenced_invalid:
     *gx_text_request_invalid
+  landing_request_valid:
+    *gx_text_request_valid
+  landing_request_invalid:
+    *gx_text_request_invalid
+  landing_request_internal_valid:
+    *gx_text_request_valid
+  landing_request_internal_invalid:
+    *gx_text_request_invalid
   job_internal_valid:
     - parameter: moocow
     - parameter: 'some spaces'
     - parameter: ''
+    - parameter: null
   job_internal_invalid:
     - {}
-    - parameter: null
     - parameter: { "moo": "cow" }
   workflow_step_valid:
     - parameter: moocow
     - parameter: 'some spaces'
     - parameter: ''
     - {}
+    - parameter: null
   workflow_step_invalid:
     - parameter: 5
-    - parameter: null
     - parameter: {}
     - parameter: { "moo": "cow" }
     - parameter: {__class__: 'ConnectedValue'}
@@ -181,9 +310,9 @@ gx_text:
     - parameter: ''
     - {}
     - parameter: {__class__: 'ConnectedValue'}
+    - parameter: null
   workflow_step_linked_invalid:
     - parameter: 5
-    - parameter: null
     - parameter: {}
     - parameter: { "moo": "cow" }
     - parameter: {"class": 'ConnectedValue'}
@@ -198,6 +327,18 @@ gx_text_optional:
     - parameter: 5
     - parameter: {}
     - parameter: { "moo": "cow" }
+  landing_request_valid: &gx_text_optional_landing_request_valid
+    - parameter: "moo cow"
+    - {}
+    - parameter: null
+  landing_request_invalid: &gx_text_optional_landing_request_invalid
+    - parameter: 5
+    - parameter: 6
+  landing_request_internal_valid:
+    *gx_text_optional_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_text_optional_landing_request_invalid
+
   workflow_step_valid:
     - parameter: moocow
     - parameter: 'some spaces'
@@ -219,6 +360,21 @@ gx_text_optional:
     - parameter: {}
     - parameter: { "moo": "cow" }
 
+gx_text_length_validation: 
+  request_valid:
+  - parameter: "mytext"
+  - parameter: "mytext123"
+  request_invalid:
+  - parameter: "s"  # too short
+  - parameter: "mytext1231231231sd"  # too long
+
+gx_text_length_validation_negate: 
+  request_valid:
+  - parameter: "m"
+  - parameter: "mytext123mocowdowees"
+  request_invalid:
+  - parameter: "goldilocks"
+
 gx_select:
   request_valid:
   - parameter: "--ex1"
@@ -243,6 +399,18 @@ gx_select:
    *gx_select_request_valid
   request_internal_dereferenced_invalid:
    *gx_select_request_invalid
+  landing_request_valid: &gx_select_landing_request_valid
+    - parameter: "--ex1"
+    - parameter: "ex2"
+    - {}
+  landing_request_invalid: &gx_select_landing_request_invalid
+    - parameter: 5
+    - parameter: null
+    - parameter: "Ex1"
+  landing_request_internal_valid:
+    *gx_select_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_select_landing_request_invalid
   job_internal_valid:
   - parameter: '--ex1'
   - parameter: 'ex2'
@@ -283,6 +451,19 @@ gx_select_optional:
   - parameter: ["ex2"]
   - parameter: {}
   - parameter: 5
+  landing_request_valid: &gx_select_optional_landing_request_valid
+  - parameter: "--ex1"
+  - parameter: "ex2"
+  - parameter: null
+  - {}
+  landing_request_invalid: &gx_select_optional_landing_request_invalid
+  - parameter: 5
+  - parameter: "Ex1"
+  - parameter: {}
+  landing_request_internal_valid:
+    *gx_select_optional_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_select_optional_landing_request_invalid
   job_internal_valid:
   - parameter: '--ex1'
   - parameter: 'ex2'
@@ -326,6 +507,20 @@ gx_select_multiple:
   - parameter: ["Ex1"]
   - parameter: {}
   - parameter: 5
+  landing_request_valid: &gx_select_multiple_landing_request_valid
+  - parameter: ["--ex1"]
+  - parameter: ["ex2"]
+  - parameter: null
+  - {}
+  landing_request_invalid: &gx_select_multiple_landing_request_invalid
+  - parameter: 5
+  - parameter: ["Ex1"]
+  - parameter: {}
+  - parameter: false
+  landing_request_internal_valid:
+    *gx_select_multiple_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_select_multiple_landing_request_invalid
   workflow_step_valid:
   - parameter: ["--ex1"]
   - parameter: ["ex2"]
@@ -370,6 +565,12 @@ gx_select_multiple_optional:
   - parameter: {}
   - parameter: 5
 
+gx_select_no_options_validation:
+  job_internal_valid:
+  - parameter: "--ex1"
+  job_internal_invalid:
+  - {}
+
 gx_genomebuild:
   request_valid:
   - parameter: hg19
@@ -379,6 +580,17 @@ gx_genomebuild:
   request_invalid:
   - parameter: null
   - parameter: 9
+  landing_request_valid: &gx_genomebuild_landing_request_valid
+  - parameter: hg19
+  - parameter: hg18
+  - {}
+  landing_request_invalid: &gx_genomebuild_landing_request_invalid
+  - parameter: null
+  - parameter: 9
+  landing_request_internal_valid:
+    *gx_genomebuild_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_genomebuild_landing_request_invalid
   job_internal_valid:
   - parameter: hg19
   job_internal_invalid:
@@ -394,6 +606,17 @@ gx_genomebuild_optional:
   request_invalid:
   - parameter: 8
   - parameter: true
+  landing_request_valid: &gx_genomebuild_optional_landing_request_valid
+  - parameter: hg19
+  - parameter: hg18
+  - {}
+  - parameter: null
+  landing_request_invalid: &gx_genomebuild_optional_landing_request_invalid
+  - parameter: 9
+  landing_request_internal_valid:
+    *gx_genomebuild_optional_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_genomebuild_optional_landing_request_invalid
   job_internal_valid:
   - parameter: null
   job_internal_invalid:
@@ -415,6 +638,18 @@ gx_directory_uri:
   - parameter: "justsomestring"
   - parameter: true
   - parameter: null
+  landing_request_valid: &gx_directory_uri_landing_request_valid
+  - parameter: "gxfiles://foobar/"
+  - parameter: "gxfiles://foobar"
+  - {}
+  landing_request_invalid: &gx_directory_uri_landing_request_invalid
+  - parameter: true
+  - parameter: null
+  - parameter: 8
+  landing_request_internal_valid:
+    *gx_directory_uri_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_directory_uri_landing_request_invalid
   job_internal_valid:
   - parameter: "gxfiles://foobar/"
   - parameter: "gxfiles://foobar"
@@ -423,6 +658,22 @@ gx_directory_uri:
   - parameter: true
   - parameter: null
 
+gx_directory_uri_validation:
+  request_valid:
+  - parameter: "gxfiles://mycoolsource/api/index.json"
+  request_invalid:
+  - parameter: {__class__: 'ConnectedValue'}
+  - parameter: "gxfiles://tooshort/index.json"
+  - parameter: "gxfiles://mycoolsource/api/wrongex.js"
+  - parameter: "gxfiles://mycoolsource/badexp.json"
+  workflow_step_linked_valid:
+  - parameter: {__class__: 'ConnectedValue'}
+  - parameter: "gxfiles://mycoolsource/api/index.json"
+  workflow_step_linked_invalid:
+  - parameter: "gxfiles://tooshort/index.json"
+  - parameter: "gxfiles://mycoolsource/api/wrongex.js"
+  - parameter: "gxfiles://mycoolsource/badexp.json"
+
 gx_hidden:
   request_valid:
     - parameter: moocow
@@ -435,6 +686,20 @@ gx_hidden:
     - parameter: 5
     - parameter: {}
     - parameter: { "moo": "cow" }
+  landing_request_valid: &gx_hidden_landing_request_valid
+    - parameter: moocow
+    - parameter: 'some spaces'
+    - parameter: ''
+    - {}
+  landing_request_invalid: &gx_hidden_landing_request_invalid
+    - parameter: null
+    - parameter: 5
+    - parameter: {}
+    - parameter: { "moo": "cow" }
+  landing_request_internal_valid:
+    *gx_hidden_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_hidden_landing_request_invalid
   job_internal_valid:
     - parameter: moocow
     - parameter: 'some spaces'
@@ -445,7 +710,7 @@ gx_hidden:
     - parameter: moocow
     - {}
   workflow_step_invalid:
-    - parmaeter: 5
+    - parameter: 5
     - parameter: {}
     - parameter: { "moo": "cow" }
   workflow_step_linked_valid:
@@ -465,12 +730,26 @@ gx_hidden_optional:
     - parameter: 5
     - parameter: {}
     - parameter: { "moo": "cow" }
+  landing_request_valid: &gx_hidden_optional_landing_request_valid
+    - parameter: moocow
+    - parameter: 'some spaces'
+    - parameter: ''
+    - {}
+    - parameter: null
+  landing_request_invalid: &gx_hidden_optional_landing_request_invalid
+    - parameter: 5
+    - parameter: {}
+    - parameter: { "moo": "cow" }
+  landing_request_internal_valid:
+    *gx_hidden_optional_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_hidden_optional_landing_request_invalid
   workflow_step_valid:
     - parameter: moocow
     - {}
     - parameter: null
   workflow_step_invalid:
-    - parmaeter: 5
+    - parameter: 5
     - parameter: {}
     - parameter: { "moo": "cow" }
   workflow_step_linked_valid:
@@ -480,6 +759,22 @@ gx_hidden_optional:
   workflow_step_linked_invalid:
     - parameter: 5
 
+gx_hidden_validation:
+  request_valid:
+  - parameter: "http://mycoolservice.com/api/index.json"
+  request_invalid:
+  - parameter: {__class__: 'ConnectedValue'}
+  - parameter: "http://mycoolservice.com/index.json"
+  - parameter: "http://mycoolservice.com/api/wrongex.js"
+  - parameter: "http://mycoolservice.com/badexp.json"
+  workflow_step_linked_valid:
+  - parameter: {__class__: 'ConnectedValue'}
+  - parameter: "http://mycoolservice.com/api/index.json"
+  workflow_step_linked_invalid:
+  - parameter: "http://mycoolservice.com/index.json"
+  - parameter: "http://mycoolservice.com/api/wrongex.js"
+  - parameter: "http://mycoolservice.com/badexp.json"
+
 gx_float:
   request_valid:
     - parameter: 5
@@ -492,6 +787,30 @@ gx_float:
     - parameter: "5"
     - parameter: "5.0"
     - parameter: { "moo": "cow" }
+  job_internal_valid:
+   - parameter: 5
+   - parameter: 5.0
+  job_internal_invalid:
+   - {}
+   - parameter: "5"
+   - parameter: "5.0"
+   - parameter: null
+  landing_request_valid:
+    - {}
+    - parameter: 5
+    - parameter: 5.0
+  landing_request_invalid:
+    - parameter: "moo"
+    - parameter: "5"
+    - parameter: "5.0"
+  landing_request_internal_valid:
+    - {}
+    - parameter: 5
+    - parameter: 5.0
+  landing_request_internal_invalid:
+    - parameter: "moo"
+    - parameter: "5"
+    - parameter: "5.0"
   test_case_xml_valid:
     - parameter: 5
     - parameter: 5.0
@@ -529,6 +848,32 @@ gx_float_optional:
     - parameter: "5.0"
     - parameter: {}
     - parameter: { "moo": "cow" }
+  job_internal_valid:
+   - parameter: 5
+   - parameter: 5.0
+   - parameter: null
+  job_internal_invalid:
+   - {}
+   - parameter: "5"
+   - parameter: "5.0"
+  landing_request_valid:
+    - {}
+    - parameter: 5
+    - parameter: 5.0
+    - parameter: null
+  landing_request_invalid:
+    - parameter: "moo"
+    - parameter: "5"
+    - parameter: "5.0"
+  landing_request_internal_valid:
+    - {}
+    - parameter: 5
+    - parameter: 5.0
+    - parameter: null
+  landing_request_internal_invalid:
+    - parameter: "moo"
+    - parameter: "5"
+    - parameter: "5.0"
   test_case_xml_valid:
     - parameter: 5
     - parameter: 5.0
@@ -553,6 +898,26 @@ gx_float_optional:
     - parameter: 'foobar'
     - parameter: {__class__: 'ConnectedValue2'}
 
+gx_float_validation_range:
+  request_valid:
+  - parameter: 0.1
+  - parameter: 9.7
+  - parameter: 5
+  request_invalid:
+  - parameter: 10
+  - parameter: 0
+  - parameter: 9.8  # endpoint not included because specified in validator
+
+gx_float_min_max:
+  request_valid:
+  - parameter: 0.1
+  - parameter: 9.7
+  - parameter: 5
+  - parameter: 9.8  # endpoint implicitly included when max attribute set on param
+  request_invalid:
+  - parameter: 10
+  - parameter: 0
+
 gx_color:
   request_valid:
    - parameter: '#aabbcc'
@@ -616,6 +981,24 @@ gx_data:
    # the difference between request internal and request internal dereferenced is that these have been converted
    # to datasets.
    - parameter: {src: url, url: "https://raw.githubusercontent.com/galaxyproject/planemo/7be1bf5b3971a43eaa73f483125bfb8cabf1c440/tests/data/hello.txt", ext: "txt"}
+  landing_request_valid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: {src: url, url: "https://raw.githubusercontent.com/galaxyproject/planemo/7be1bf5b3971a43eaa73f483125bfb8cabf1c440/tests/data/hello.txt", "ext": "txt"}
+   - parameter: {__class__: "Batch", values: [{src: hdca, id: abcdabcd}]}
+   - {}
+   - parameter: {src: url, url: "https://raw.githubusercontent.com/galaxyproject/planemo/7be1bf5b3971a43eaa73f483125bfb8cabf1c440/tests/data/hello.txt", "ext": "txt"}
+  landing_request_invalid:
+   - parameter: {__class__: "Batch", values: [{src: hdca, id: 5}]}
+   - parameter: {src: hda, id: 5}
+   - parameter: {src: hda, id: 0}
+  landing_request_internal_valid:
+   - parameter: {src: hda, id: 5}
+   - parameter: {__class__: "Batch", values: [{src: hdca, id: 5}]}
+   - {}
+   - parameter: {src: url, url: "https://raw.githubusercontent.com/galaxyproject/planemo/7be1bf5b3971a43eaa73f483125bfb8cabf1c440/tests/data/hello.txt", "ext": "txt"}
+  landing_request_internal_invalid:
+   - parameter: {src: hda, id: abcdabcd}
+   - parameter: {__class__: "Batch", values: [{src: hdca, id: abcdabcd}]}
   job_internal_valid:
    - parameter: {src: hda, id: 7}
   job_internal_invalid:
@@ -744,6 +1127,16 @@ gx_data_multiple:
    # the difference between request internal and request internal dereferenced is that these have been converted
    # to datasets.
    - parameter: [{src: url, url: "https://raw.githubusercontent.com/galaxyproject/planemo/7be1bf5b3971a43eaa73f483125bfb8cabf1c440/tests/data/hello.txt", ext: "txt"}]
+  landing_request_valid:
+   - parameter: [{src: hda, id: abcdabcd}]
+   - {}
+  landing_request_invalid:
+   - parameter: [{src: hda, id: 6}]
+  landing_request_internal_valid:
+   - parameter: [{src: hda, id: 6}]
+   - {}
+  landing_request_internal_invalid:
+   - parameter: [{src: hda, id: abcdabcd}]
   job_internal_valid:
    - parameter: {src: hda, id: 5}
    - parameter: [{src: hda, id: 5}, {src: hda, id: 6}]
@@ -824,6 +1217,18 @@ gx_data_collection:
    - parameter: {src: hdca, id: 5}
   request_internal_dereferenced_invalid:
    - parameter: {src: hdca, id: abcdabcd}
+  landing_request_valid:
+   - parameter: {src: hdca, id: abcdabcd}
+   - {}
+  landing_request_invalid:
+   - parameter: {src: hdca, id: 5}
+   - parameter: [{src: hdca, id: abcdabcd}]
+  landing_request_internal_valid:
+   - parameter: {src: hdca, id: 5}
+   - {}
+  landing_request_internal_invalid:
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: [{src: hdca, id: abcdabcd}]
   workflow_step_valid:
   - {}
   workflow_step_invalid:
@@ -909,6 +1314,20 @@ gx_data_collection_optional:
    - parameter: 5
    - parameter: "5"
    - parameter: {}
+  landing_request_valid:
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: null
+   - {}
+  landing_request_invalid:
+   - parameter: {src: hdca, id: 5}
+   - parameter: [{src: hdca, id: abcdabcd}]
+  landing_request_internal_valid:
+   - parameter: {src: hdca, id: 5}
+   - parameter: null
+   - {}
+  landing_request_internal_invalid:
+   - parameter: {src: hdca, id: abcdabcd}
+   - parameter: [{src: hdca, id: abcdabcd}]
   job_internal_valid:
     - parameter: {src: hdca, id: 5}
     - parameter: null
@@ -957,6 +1376,16 @@ gx_conditional_boolean:
     # in that case having an integer_parameter is not acceptable.
     - conditional_parameter: 
         integer_parameter: 5
+  landing_request_valid: &gx_conditional_boolean_landing_request_valid
+    - {}
+  landing_request_invalid: &gx_conditional_boolean_landing_request_invalid
+    - conditional_parameter:
+        test_parameter: false
+        integer_parameter: 1
+  landing_request_internal_valid:
+    *gx_conditional_boolean_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_conditional_boolean_landing_request_invalid
   job_internal_valid:
     - conditional_parameter:
         test_parameter: true
@@ -1106,6 +1535,20 @@ gx_repeat_boolean:
       - { boolean_parameter: false }
       - { boolean_parameter: 4 }
     - parameter: 5
+  landing_request_valid: &gx_repeat_boolean_landing_request_valid
+    - {}
+    - parameter:
+      - { boolean_parameter: true }
+      - { boolean_parameter: false }
+    - parameter: [{}]
+    - parameter: [{}, {}]
+  landing_request_invalid: &gx_repeat_boolean_landing_request_invalid
+    - parameter:
+      - { boolean_parameter: 4 }
+  landing_request_internal_valid:
+    *gx_repeat_boolean_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_repeat_boolean_landing_request_invalid
   job_internal_valid:
     - parameter:
       - { boolean_parameter: true }
@@ -1174,6 +1617,16 @@ gx_repeat_data:
   request_internal_invalid:
     - parameter:
       - { data_parameter: { src: hda, id: abcdabcd } }
+  landing_request_valid: &gx_repeat_data_landing_request_valid
+    - {}
+    # unlike above - in landing mode all parameters are optional so it is find to have an unset data parameters
+    - parameter: [{}]
+  landing_request_invalid: &gx_repeat_data_landing_request_invalid
+    - parameter: 5
+  landing_request_internal_valid:
+    *gx_repeat_data_landing_request_valid
+  landing_request_internal_invalid:
+    *gx_repeat_data_landing_request_invalid
   job_internal_valid:
     - parameter:
       - { data_parameter: { src: hda, id: 5 } }
@@ -1197,6 +1650,22 @@ gx_repeat_data_min:
     - parameter: [{}, {}]
     - parameter: [{}]
     - parameter: 5
+  landing_request_valid:
+  - {}
+  # ignore the min here - can just specify the first set of parameters and I think that should work
+  - parameter:
+    - { data_parameter: {src: hda, id: abcdabcd} }
+  landing_request_invalid:
+  - parameter:
+    - { data_parameter: {src: hda, id: 5} }
+  landing_request_internal_valid:
+  - {}
+  # ignore the min here - can just specify the first set of parameters and I think that should work
+  - parameter:
+    - { data_parameter: {src: hda, id: 5} }
+  landing_request_internal_invalid:
+  - parameter:
+    - { data_parameter: {src: hda, id: abcdabcd} }
   request_internal_valid:
     - parameter:
       - { data_parameter: { src: hda, id: 5 } }
diff --git a/test/unit/tool_util/test_parameter_convert.py b/test/unit/tool_util/test_parameter_convert.py
index f86750026766..7f5deff41e85 100644
--- a/test/unit/tool_util/test_parameter_convert.py
+++ b/test/unit/tool_util/test_parameter_convert.py
@@ -12,6 +12,9 @@
     encode,
     fill_static_defaults,
     input_models_for_tool_source,
+    landing_decode,
+    landing_encode,
+    LandingRequestToolState,
     RequestInternalDereferencedToolState,
     RequestInternalToolState,
     RequestToolState,
@@ -102,6 +105,20 @@ def test_multi_data():
     assert encoded_state.input_state["parameter"][1]["id"] == EXAMPLE_ID_2_ENCODED
 
 
+def test_landing_encode_data():
+    tool_source = tool_source_for("parameters/gx_data")
+    bundle = input_models_for_tool_source(tool_source)
+    request_state = LandingRequestToolState({"parameter": {"src": "hda", "id": EXAMPLE_ID_1_ENCODED}})
+    request_state.validate(bundle)
+    decoded_state = landing_decode(request_state, bundle, _fake_decode)
+    assert decoded_state.input_state["parameter"]["src"] == "hda"
+    assert decoded_state.input_state["parameter"]["id"] == EXAMPLE_ID_1
+
+    encoded_state = landing_encode(decoded_state, bundle, _fake_encode)
+    assert encoded_state.input_state["parameter"]["src"] == "hda"
+    assert encoded_state.input_state["parameter"]["id"] == EXAMPLE_ID_1_ENCODED
+
+
 def test_dereference():
     tool_source = tool_source_for("parameters/gx_data")
     bundle = input_models_for_tool_source(tool_source)
@@ -200,6 +217,19 @@ def test_fill_defaults():
     assert with_defaults["cond"]["cond"] == "single"
     assert with_defaults["cond"]["inner_cond"]["inner_cond"] == "single"
 
+    # dynamic parameters should just stay empty - null would cause runtime to skip over population
+    with_defaults = fill_state_for({}, "parameters/gx_select_dynamic", partial=True)
+    assert "parameter" not in with_defaults
+
+    # dynamic parameters should just stay empty - null would cause runtime to skip over population
+    with_defaults = fill_state_for(
+        {"conditional_parameter": {"test_parameter": False}},
+        "parameters/gx_conditional_boolean_discriminate_on_string_value",
+    )
+    assert "conditional_parameter" in with_defaults
+    assert "boolean_parameter" in with_defaults["conditional_parameter"]
+    assert with_defaults["conditional_parameter"]["boolean_parameter"] is False
+
 
 def _fake_dereference(input: DataRequestUri) -> DataRequestInternalHda:
     return DataRequestInternalHda(id=EXAMPLE_ID_1)
diff --git a/test/unit/tool_util/test_parameter_specification.py b/test/unit/tool_util/test_parameter_specification.py
index dd54ac7276be..ed4b437449b5 100644
--- a/test/unit/tool_util/test_parameter_specification.py
+++ b/test/unit/tool_util/test_parameter_specification.py
@@ -1,9 +1,7 @@
 import sys
 from functools import partial
 from typing import (
-    Any,
     Callable,
-    Dict,
     List,
     Optional,
 )
@@ -15,16 +13,20 @@
 from galaxy.tool_util.parameters import (
     decode,
     encode,
+    RawStateDict,
     RequestInternalToolState,
     RequestToolState,
     ToolParameterBundleModel,
     validate_internal_job,
+    validate_internal_landing_request,
     validate_internal_request,
     validate_internal_request_dereferenced,
+    validate_landing_request,
     validate_request,
     validate_test_case,
     validate_workflow_step,
     validate_workflow_step_linked,
+    ValidationFunctionT,
 )
 from galaxy.tool_util.parameters.json import to_json_schema_string
 from galaxy.tool_util.unittest_utils.parameters import (
@@ -33,9 +35,6 @@
 )
 from galaxy.util.resources import resource_string
 
-RawStateDict = Dict[str, Any]
-
-
 if sys.version_info < (3, 8):  # noqa: UP036
     pytest.skip(reason="Pydantic tool parameter models require python3.8 or higher", allow_module_level=True)
 
@@ -100,6 +99,10 @@ def _test_file(file: str, specification=None, parameter_bundle: Optional[ToolPar
         "request_internal_invalid": _assert_internal_requests_invalid,
         "request_internal_dereferenced_valid": _assert_internal_requests_dereferenced_validate,
         "request_internal_dereferenced_invalid": _assert_internal_requests_dereferenced_invalid,
+        "landing_request_valid": _assert_landing_requests_validate,
+        "landing_request_invalid": _assert_landing_requests_invalid,
+        "landing_request_internal_valid": _assert_internal_landing_requests_validate,
+        "landing_request_internal_invalid": _assert_internal_landing_requests_invalid,
         "job_internal_valid": _assert_internal_jobs_validate,
         "job_internal_invalid": _assert_internal_jobs_invalid,
         "test_case_xml_valid": _assert_test_cases_validate,
@@ -126,139 +129,54 @@ def _for_each(test: Callable, parameters: ToolParameterBundleModel, requests: Li
         test(parameters, request)
 
 
-def _assert_request_validates(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
-    try:
-        validate_request(parameters, request)
-    except RequestParameterInvalidException as e:
-        raise AssertionError(f"Parameters {parameters} failed to validate request {request}. {e}")
-
-
-def _assert_request_invalid(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
-    exc = None
-    try:
-        validate_request(parameters, request)
-    except RequestParameterInvalidException as e:
-        exc = e
-    assert (
-        exc is not None
-    ), f"Parameters {parameters} didn't result in validation error on request {request} as expected."
-
-
-def _assert_internal_request_validates(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
-    try:
-        validate_internal_request(parameters, request)
-    except RequestParameterInvalidException as e:
-        raise AssertionError(f"Parameters {parameters} failed to validate internal request {request}. {e}")
-
+def model_assertion_function_factory(validate_function: ValidationFunctionT, what: str):
 
-def _assert_internal_request_invalid(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
-    exc = None
-    try:
-        validate_internal_request(parameters, request)
-    except RequestParameterInvalidException as e:
-        exc = e
-    assert (
-        exc is not None
-    ), f"Parameters {parameters} didn't result in validation error on internal request {request} as expected."
+    def _assert_validates(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
+        try:
+            validate_function(parameters, request)
+        except RequestParameterInvalidException as e:
+            raise AssertionError(f"Parameters {parameters} failed to validate {what} {request}. {e}")
 
+    def _assert_invalid(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
+        exc = None
+        try:
+            validate_function(parameters, request)
+        except RequestParameterInvalidException as e:
+            exc = e
 
-def _assert_internal_request_dereferenced_validates(
-    parameters: ToolParameterBundleModel, request: RawStateDict
-) -> None:
-    try:
-        validate_internal_request_dereferenced(parameters, request)
-    except RequestParameterInvalidException as e:
-        raise AssertionError(f"Parameters {parameters} failed to validate dereferenced internal request {request}. {e}")
+        if exc is None:
+            raise AssertionError(
+                f"Parameters {parameters} didn't result in validation error on {what} {request} as expected."
+            )
 
-
-def _assert_internal_request_dereferenced_invalid(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
-    exc = None
-    try:
-        validate_internal_request_dereferenced(parameters, request)
-    except RequestParameterInvalidException as e:
-        exc = e
-    assert (
-        exc is not None
-    ), f"Parameters {parameters} didn't result in validation error on dereferenced internal request {request} as expected."
-
-
-def _assert_internal_job_validates(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
-    try:
-        validate_internal_job(parameters, request)
-    except RequestParameterInvalidException as e:
-        raise AssertionError(f"Parameters {parameters} failed to validate internal job description {request}. {e}")
-
-
-def _assert_internal_job_invalid(parameters: ToolParameterBundleModel, request: RawStateDict) -> None:
-    exc = None
-    try:
-        validate_internal_job(parameters, request)
-    except RequestParameterInvalidException as e:
-        exc = e
-    assert (
-        exc is not None
-    ), f"Parameters {parameters} didn't result in validation error on internal job description {request} as expected."
-
-
-def _assert_test_case_validates(parameters: ToolParameterBundleModel, test_case: RawStateDict) -> None:
-    try:
-        validate_test_case(parameters, test_case)
-    except RequestParameterInvalidException as e:
-        raise AssertionError(f"Parameters {parameters} failed to validate test_case {test_case}. {e}")
+    return _assert_validates, _assert_invalid
 
 
-def _assert_test_case_invalid(parameters: ToolParameterBundleModel, test_case: RawStateDict) -> None:
-    exc = None
-    try:
-        validate_test_case(parameters, test_case)
-    except RequestParameterInvalidException as e:
-        exc = e
-    assert (
-        exc is not None
-    ), f"Parameters {parameters} didn't result in validation error on test_case {test_case} as expected."
-
-
-def _assert_workflow_step_validates(parameters: ToolParameterBundleModel, workflow_step: RawStateDict) -> None:
-    try:
-        validate_workflow_step(parameters, workflow_step)
-    except RequestParameterInvalidException as e:
-        raise AssertionError(f"Parameters {parameters} failed to validate workflow step {workflow_step}. {e}")
-
-
-def _assert_workflow_step_invalid(parameters: ToolParameterBundleModel, workflow_step: RawStateDict) -> None:
-    exc = None
-    try:
-        validate_workflow_step(parameters, workflow_step)
-    except RequestParameterInvalidException as e:
-        exc = e
-    assert (
-        exc is not None
-    ), f"Parameters {parameters} didn't result in validation error on workflow step {workflow_step} as expected."
-
-
-def _assert_workflow_step_linked_validates(
-    parameters: ToolParameterBundleModel, workflow_step_linked: RawStateDict
-) -> None:
-    try:
-        validate_workflow_step_linked(parameters, workflow_step_linked)
-    except RequestParameterInvalidException as e:
-        raise AssertionError(
-            f"Parameters {parameters} failed to validate linked workflow step {workflow_step_linked}. {e}"
-        )
-
-
-def _assert_workflow_step_linked_invalid(
-    parameters: ToolParameterBundleModel, workflow_step_linked: RawStateDict
-) -> None:
-    exc = None
-    try:
-        validate_workflow_step_linked(parameters, workflow_step_linked)
-    except RequestParameterInvalidException as e:
-        exc = e
-    assert (
-        exc is not None
-    ), f"Parameters {parameters} didn't result in validation error on linked workflow step {workflow_step_linked} as expected."
-
+_assert_request_validates, _assert_request_invalid = model_assertion_function_factory(validate_request, "request")
+_assert_internal_request_validates, _assert_internal_request_invalid = model_assertion_function_factory(
+    validate_internal_request, "internal request"
+)
+_assert_internal_request_dereferenced_validates, _assert_internal_request_dereferenced_invalid = (
+    model_assertion_function_factory(validate_internal_request_dereferenced, "dereferenced internal request")
+)
+_assert_internal_job_validates, _assert_internal_job_invalid = model_assertion_function_factory(
+    validate_internal_job, "internal job description"
+)
+_assert_test_case_validates, _assert_test_case_invalid = model_assertion_function_factory(
+    validate_test_case, "XML derived test case"
+)
+_assert_workflow_step_validates, _assert_workflow_step_invalid = model_assertion_function_factory(
+    validate_workflow_step, "workflow step tool state (unlinked)"
+)
+_assert_workflow_step_linked_validates, _assert_workflow_step_linked_invalid = model_assertion_function_factory(
+    validate_workflow_step_linked, "linked workflow step tool state"
+)
+_assert_landing_request_validates, _assert_landing_request_invalid = model_assertion_function_factory(
+    validate_landing_request, "landing request"
+)
+_assert_internal_landing_request_validates, _assert_internal_landing_request_invalid = model_assertion_function_factory(
+    validate_internal_landing_request, " internallanding request"
+)
 
 _assert_requests_validate = partial(_for_each, _assert_request_validates)
 _assert_requests_invalid = partial(_for_each, _assert_request_invalid)
@@ -274,6 +192,10 @@ def _assert_workflow_step_linked_invalid(
 _assert_workflow_steps_invalid = partial(_for_each, _assert_workflow_step_invalid)
 _assert_workflow_steps_linked_validate = partial(_for_each, _assert_workflow_step_linked_validates)
 _assert_workflow_steps_linked_invalid = partial(_for_each, _assert_workflow_step_linked_invalid)
+_assert_landing_requests_validate = partial(_for_each, _assert_landing_request_validates)
+_assert_landing_requests_invalid = partial(_for_each, _assert_landing_request_invalid)
+_assert_internal_landing_requests_validate = partial(_for_each, _assert_internal_landing_request_validates)
+_assert_internal_landing_requests_invalid = partial(_for_each, _assert_internal_landing_request_invalid)
 
 
 def decode_val(val: str) -> int:
diff --git a/test/unit/tool_util/test_parameter_validator_models.py b/test/unit/tool_util/test_parameter_validator_models.py
new file mode 100644
index 000000000000..17af98f2ce6c
--- /dev/null
+++ b/test/unit/tool_util/test_parameter_validator_models.py
@@ -0,0 +1,28 @@
+from typing import Optional
+
+from galaxy.tool_util.parser.parameter_validators import parse_xml_validators
+from galaxy.tool_util.unittest_utils.sample_data import (
+    INVALID_XML_VALIDATORS,
+    VALID_XML_VALIDATORS,
+)
+from galaxy.util import XML
+
+
+def test_xml_validation_valid():
+    for xml_validator in VALID_XML_VALIDATORS:
+        _validate_xml_str(xml_validator)
+
+
+def test_xml_validation_invalid():
+    for xml_validator in INVALID_XML_VALIDATORS:
+        exc: Optional[Exception] = None
+        try:
+            _validate_xml_str(xml_validator)
+        except ValueError as e:
+            exc = e
+        assert exc is not None, f"{xml_validator} - validated when it wasn't expected to"
+
+
+def _validate_xml_str(xml_str: str):
+    xml_el = XML(f"<param>{xml_str}</param>")
+    parse_xml_validators(xml_el)
diff --git a/test/unit/tool_util/workflow_state/test_workflow_state_helpers.py b/test/unit/tool_util/workflow_state/test_workflow_state_helpers.py
new file mode 100644
index 000000000000..e8544e22fbb2
--- /dev/null
+++ b/test/unit/tool_util/workflow_state/test_workflow_state_helpers.py
@@ -0,0 +1,23 @@
+from galaxy.tool_util.parameters import repeat_inputs_to_array
+
+
+def test_repeat_inputs_to_array():
+    rval = repeat_inputs_to_array(
+        "repeatfoo",
+        {
+            "moo": "cow",
+        },
+    )
+    assert not rval
+    test_state: dict = {
+        "moo": "cow",
+        "repeatfoo_0|moocow": ["moo"],
+        "repeatfoo_2|moocow": ["cow"],
+    }
+    rval = repeat_inputs_to_array("repeatfoo", test_state)
+    assert len(rval) == 3
+    assert "repeatfoo_0|moocow" in rval[0]
+    assert "repeatfoo_0|moocow" not in rval[1]
+    assert "repeatfoo_0|moocow" not in rval[2]
+    assert "repeatfoo_2|moocow" not in rval[1]
+    assert "repeatfoo_2|moocow" in rval[2]
diff --git a/test/unit/workflows/invalid/extra_attribute.gxwf.yml b/test/unit/workflows/invalid/extra_attribute.gxwf.yml
new file mode 100644
index 000000000000..6ae50799394c
--- /dev/null
+++ b/test/unit/workflows/invalid/extra_attribute.gxwf.yml
@@ -0,0 +1,15 @@
+class: GalaxyWorkflow
+inputs:
+  input:
+    type: int
+outputs:
+  output:
+    outputSource: the_step/output
+steps:
+  the_step:
+    tool_id: gx_int
+    tool_version: "1.0.0"
+    state:
+      parameter2: 6
+    in:
+      parameter: input
diff --git a/test/unit/workflows/invalid/missing_link.gxwf.yml b/test/unit/workflows/invalid/missing_link.gxwf.yml
new file mode 100644
index 000000000000..526b40f6f502
--- /dev/null
+++ b/test/unit/workflows/invalid/missing_link.gxwf.yml
@@ -0,0 +1,11 @@
+class: GalaxyWorkflow
+inputs:
+  input:
+    type: data
+outputs:
+  output:
+    outputSource: the_step/output
+steps:
+  the_step:
+    tool_id: gx_data
+    tool_version: "1.0.0"
diff --git a/test/unit/workflows/invalid/wrong_link_name.gxwf.yml b/test/unit/workflows/invalid/wrong_link_name.gxwf.yml
new file mode 100644
index 000000000000..f0e0e8d12004
--- /dev/null
+++ b/test/unit/workflows/invalid/wrong_link_name.gxwf.yml
@@ -0,0 +1,13 @@
+class: GalaxyWorkflow
+inputs:
+  input:
+    type: int
+outputs:
+  output:
+    outputSource: the_step/output
+steps:
+  the_step:
+    tool_id: gx_int
+    tool_version: "1.0.0"
+    in:
+      parameterx: input
diff --git a/test/unit/workflows/test_convert.py b/test/unit/workflows/test_convert.py
new file mode 100644
index 000000000000..4567e9afd275
--- /dev/null
+++ b/test/unit/workflows/test_convert.py
@@ -0,0 +1,35 @@
+from galaxy.workflow.format2 import (
+    convert_from_format2,
+    convert_to_format2,
+)
+
+WORKFLOW_WITH_OUTPUTS = """
+class: GalaxyWorkflow
+inputs:
+  input1: data
+outputs:
+  wf_output_1:
+    outputSource: first_cat/out_file1
+steps:
+  first_cat:
+    tool_id: cat1
+    in:
+      input1: input1
+      queries_0|input2: input1
+"""
+
+
+def test_convert_from_simple():
+    as_dict = {"yaml_content": WORKFLOW_WITH_OUTPUTS}
+    ga_format = convert_from_format2(as_dict, None)
+    assert ga_format["a_galaxy_workflow"] == "true"
+    assert ga_format["format-version"] == "0.1"
+
+
+def test_convert_to_simple():
+    as_dict = {"yaml_content": WORKFLOW_WITH_OUTPUTS}
+    ga_format = convert_from_format2(as_dict, None)
+
+    as_dict = convert_to_format2(ga_format, True)
+    assert "yaml_content" in as_dict
+    assert "yaml_content" not in as_dict
diff --git a/test/unit/workflows/test_workflow_state_conversion.py b/test/unit/workflows/test_workflow_state_conversion.py
new file mode 100644
index 000000000000..e73b73b6aa55
--- /dev/null
+++ b/test/unit/workflows/test_workflow_state_conversion.py
@@ -0,0 +1,16 @@
+from galaxy.tool_util.workflow_state.convert import (
+    convert_state_to_format2,
+    Format2State,
+)
+from galaxy.workflow.gx_validator import GET_TOOL_INFO
+from .test_workflow_validation import base_package_workflow_as_dict
+
+
+def convert_state(native_step_dict: dict) -> Format2State:
+    return convert_state_to_format2(native_step_dict, GET_TOOL_INFO)
+
+
+def test_simple_convert():
+    workflow_dict = base_package_workflow_as_dict("test_workflow_1.ga")
+    cat_step = workflow_dict["steps"]["2"]
+    convert_state(cat_step)
diff --git a/test/unit/workflows/test_workflow_validation.py b/test/unit/workflows/test_workflow_validation.py
new file mode 100644
index 000000000000..33c93ede6df5
--- /dev/null
+++ b/test/unit/workflows/test_workflow_validation.py
@@ -0,0 +1,80 @@
+import os
+from typing import Optional
+
+from gxformat2.yaml import ordered_load
+
+from galaxy.util import galaxy_directory
+from galaxy.workflow.gx_validator import validate_workflow
+
+TEST_WORKFLOW_DIRECTORY = os.path.join(galaxy_directory(), "lib", "galaxy_test", "workflow")
+TEST_BASE_DATA_DIRECTORY = os.path.join(galaxy_directory(), "lib", "galaxy_test", "base", "data")
+SCRIPT_DIRECTORY = os.path.abspath(os.path.dirname(__file__))
+
+
+def test_validate_simple_functional_test_case_workflow():
+    validate_workflow(framework_test_workflow_as_dict("multiple_versions"))
+    validate_workflow(framework_test_workflow_as_dict("zip_collection"))
+    validate_workflow(framework_test_workflow_as_dict("empty_collection_sort"))
+    validate_workflow(framework_test_workflow_as_dict("flatten_collection"))
+    validate_workflow(framework_test_workflow_as_dict("flatten_collection_over_execution"))
+
+
+def test_validate_native_workflows():
+    validate_workflow(base_package_workflow_as_dict("test_workflow_two_random_lines.ga"))
+    # disconnected input...
+    # validate_workflow(base_package_workflow_as_dict("test_workflow_topoambigouity.ga"))
+    # double nested JSON?
+    # validate_workflow(base_package_workflow_as_dict("test_Workflow_map_reduce_pause.ga"))
+    # handle subworkflows...
+    # validate_workflow(base_package_workflow_as_dict("test_subworkflow_with_integer_input.ga"))
+    # handle gx_text....
+    # validate_workflow(base_package_workflow_as_dict("test_workflow_batch.ga"))
+
+
+def test_validate_unit_test_workflows():
+    validate_workflow(unit_test_workflow_as_dict("valid/simple_int"))
+    validate_workflow(unit_test_workflow_as_dict("valid/simple_data"))
+
+
+def test_invalidate_with_extra_attribute():
+    e = _assert_validation_failure("invalid/extra_attribute")
+    assert "parameter2" in str(e)
+
+
+def test_invalidate_with_wrong_link_name():
+    e = _assert_validation_failure("invalid/wrong_link_name")
+    assert "parameterx" in str(e)
+
+
+def test_invalidate_with_missing_link():
+    e = _assert_validation_failure("invalid/missing_link")
+    assert "parameter" in str(e)
+    assert "type=missing" in str(e)
+
+
+def _assert_validation_failure(workflow_name: str) -> Exception:
+    as_dict = unit_test_workflow_as_dict(workflow_name)
+    exc: Optional[Exception] = None
+    try:
+        validate_workflow(as_dict)
+    except Exception as e:
+        exc = e
+    assert exc, f"Target workflow ({workflow_name}) did not failure validation as expected."
+    return exc
+
+
+def base_package_workflow_as_dict(file_name: str) -> dict:
+    return _load(os.path.join(TEST_BASE_DATA_DIRECTORY, file_name))
+
+
+def unit_test_workflow_as_dict(workflow_name: str) -> dict:
+    return _load(os.path.join(SCRIPT_DIRECTORY, f"{workflow_name}.gxwf.yml"))
+
+
+def framework_test_workflow_as_dict(workflow_name: str) -> dict:
+    return _load(os.path.join(TEST_WORKFLOW_DIRECTORY, f"{workflow_name}.gxwf.yml"))
+
+
+def _load(path: str) -> dict:
+    with open(path) as f:
+        return ordered_load(f)
diff --git a/test/unit/workflows/test_workflow_validation_helpers.py b/test/unit/workflows/test_workflow_validation_helpers.py
new file mode 100644
index 000000000000..af74e2b32a5f
--- /dev/null
+++ b/test/unit/workflows/test_workflow_validation_helpers.py
@@ -0,0 +1,13 @@
+from galaxy.workflow.gx_validator import GET_TOOL_INFO
+
+
+def test_get_tool():
+    parsed_tool = GET_TOOL_INFO.get_tool_info("cat1", "1.0.0")
+    assert parsed_tool
+    assert parsed_tool.id == "cat1"
+    assert parsed_tool.version == "1.0.0"
+
+    parsed_tool = GET_TOOL_INFO.get_tool_info("cat1", None)
+    assert parsed_tool
+    assert parsed_tool.id == "cat1"
+    assert parsed_tool.version == "1.0.0"
diff --git a/test/unit/workflows/valid/simple_data.gxwf.yml b/test/unit/workflows/valid/simple_data.gxwf.yml
new file mode 100644
index 000000000000..44f0a90f3dd9
--- /dev/null
+++ b/test/unit/workflows/valid/simple_data.gxwf.yml
@@ -0,0 +1,13 @@
+class: GalaxyWorkflow
+inputs:
+  input:
+    type: data
+outputs:
+  output:
+    outputSource: the_step/output
+steps:
+  the_step:
+    tool_id: gx_data
+    tool_version: "1.0.0"
+    in:
+      parameter: input
diff --git a/test/unit/workflows/valid/simple_int.gxwf.yml b/test/unit/workflows/valid/simple_int.gxwf.yml
new file mode 100644
index 000000000000..d7c53f78d0a6
--- /dev/null
+++ b/test/unit/workflows/valid/simple_int.gxwf.yml
@@ -0,0 +1,13 @@
+class: GalaxyWorkflow
+inputs:
+  input:
+    type: int
+outputs:
+  output:
+    outputSource: the_step/output
+steps:
+  the_step:
+    tool_id: gx_int
+    tool_version: "1.0.0"
+    in:
+      parameter: input