Merge branch 'release_26.0' into dev

Author: mvdbeek

client/src/components/History/HistoryList.vue

@@ -93,6 +93,7 @@ const limit = ref(24);
 const offset = ref(0);
 const loading = ref(true);
 const overlay = ref(false);
+let loadGeneration = 0;
 const filterText = ref("");
 const totalHistories = ref(0);
 const showAdvanced = ref(false);
@@ -220,6 +221,8 @@ function onToggleDeleted() {
  * @param {boolean} silent - Whether to skip loading indicators
  */
 async function load(overlayLoading: boolean = false, silent: boolean = false) {
+    const thisGeneration = ++loadGeneration;
+
     if (!silent) {
         if (overlayLoading) {
             overlay.value = true;
@@ -243,32 +246,37 @@ async function load(overlayLoading: boolean = false, silent: boolean = false) {
     };
 
     try {
-        if (myView.value) {
-            const { data, total } = await getMyHistories(options);
+        let data;
+        let total;
 
-            historiesLoaded.value = data;
-            totalHistories.value = total;
+        if (myView.value) {
+            ({ data, total } = await getMyHistories(options));
         } else if (sharedView.value) {
-            const { data, total } = await getSharedHistories(options);
-
-            historiesLoaded.value = data;
-            totalHistories.value = total;
+            ({ data, total } = await getSharedHistories(options));
         } else if (publishedView.value) {
-            const { data, total } = await getPublishedHistories(options);
-
-            historiesLoaded.value = data;
-            totalHistories.value = total;
+            ({ data, total } = await getPublishedHistories(options));
         } else if (archivedView.value) {
-            const { data, total } = await getArchivedHistories(options);
+            ({ data, total } = await getArchivedHistories(options));
+        }
 
+        if (thisGeneration !== loadGeneration) {
+            return;
+        }
+
+        if (data !== undefined) {
             historiesLoaded.value = data;
-            totalHistories.value = total;
+            totalHistories.value = total!;
         }
     } catch (error) {
+        if (thisGeneration !== loadGeneration) {
+            return;
+        }
         Toast.error(`Failed to load histories: ${errorMessageAsString(error)}`);
     } finally {
-        loading.value = false;
-        overlay.value = false;
+        if (thisGeneration === loadGeneration) {
+            loading.value = false;
+            overlay.value = false;
+        }
     }
 }
 

lib/galaxy/agents/error_analysis.py

@@ -4,13 +4,15 @@
 
 import logging
 import re
+from functools import partial
 from pathlib import Path
 from typing import (
     Any,
     Literal,
     Optional,
 )
 
+import anyio
 from pydantic import BaseModel
 from pydantic_ai import Agent
 
@@ -94,7 +96,9 @@ async def get_job_details(self, job_id: int) -> dict[str, Any]:
             if not self.deps.job_manager:
                 return {"error": "Job manager not available"}
 
-            job = self.deps.job_manager.get_accessible_job(self.deps.trans, job_id)
+            job = await anyio.to_thread.run_sync(
+                partial(self.deps.job_manager.get_accessible_job, self.deps.trans, job_id)
+            )
             if not job:
                 return {"error": f"Job {job_id} not found or not accessible"}
 

lib/galaxy/tools/parameters/basic.py

@@ -512,12 +512,12 @@ def from_json(self, value, trans, other_values=None):
     def to_python(self, value, app):
         try:
             return int(value)
-        except (TypeError, ValueError) as err:
+        except (TypeError, ValueError):
             if contains_workflow_parameter(value):
                 return value
             if not value and self.optional:
                 return None
-            raise err
+            raise ParameterValueError("an integer is required", self.name, value)
 
     def get_initial_value(self, trans, other_values):
         if self.value is not None and self.value != "":
@@ -585,12 +585,12 @@ def from_json(self, value, trans, other_values=None):
     def to_python(self, value, app):
         try:
             return float(value)
-        except (TypeError, ValueError) as err:
+        except (TypeError, ValueError):
             if contains_workflow_parameter(value):
                 return value
             if not value and self.optional:
                 return None
-            raise err
+            raise ParameterValueError("a float is required", self.name, value)
 
     def get_initial_value(self, trans, other_values):
         if self.value is None:

lib/galaxy/webapps/galaxy/api/agents.py

@@ -2,11 +2,13 @@
 
 import logging
 import time
+from functools import partial
 from typing import (
     Any,
     Optional,
 )
 
+import anyio
 from fastapi import Body
 
 from galaxy.exceptions import ConfigurationError
@@ -154,16 +156,20 @@ async def analyze_error(
             # Save chat exchange for feedback tracking if requested or if job_id provided
             if bool(save_exchange) or job_id:
                 if job_id:
-                    job = self.job_manager.get_accessible_job(trans, job_id)
+                    job = await anyio.to_thread.run_sync(partial(self.job_manager.get_accessible_job, trans, job_id))
                     if job:
-                        existing = self.chat_manager.get(trans, job.id)
+                        existing = await anyio.to_thread.run_sync(partial(self.chat_manager.get, trans, job.id))
                         if not existing:
-                            exchange = self.chat_manager.create(trans, job.id, response.content)
+                            exchange = await anyio.to_thread.run_sync(
+                                partial(self.chat_manager.create, trans, job.id, response.content)
+                            )
                             response.metadata["exchange_id"] = exchange.id
                 elif trans.user:
                     # Create general chat exchange for non-job error analysis
                     result = {"response": response.content, "agent_response": response.model_dump()}
-                    exchange = self.chat_manager.create_general_chat(trans, query, result, "error_analysis")
+                    exchange = await anyio.to_thread.run_sync(
+                        partial(self.chat_manager.create_general_chat, trans, query, result, "error_analysis")
+                    )
                     response.metadata["exchange_id"] = exchange.id
 
             return response
@@ -200,7 +206,9 @@ async def create_custom_tool(
             # Save chat exchange for feedback tracking if requested
             if bool(save_exchange) and trans.user:
                 result = {"response": response.content, "agent_response": response.model_dump()}
-                exchange = self.chat_manager.create_general_chat(trans, query, result, "custom_tool")
+                exchange = await anyio.to_thread.run_sync(
+                    partial(self.chat_manager.create_general_chat, trans, query, result, "custom_tool")
+                )
                 response.metadata["exchange_id"] = exchange.id
 
             return response

lib/galaxy/webapps/galaxy/api/chat.py

@@ -5,13 +5,15 @@
 import json
 import logging
 import time
+from functools import partial
 from typing import (
     Annotated,
     Any,
     Optional,
     Union,
 )
 
+import anyio
 from fastapi import (
     Body,
     Path,
@@ -59,8 +61,10 @@
 # Keep OpenAI as a fallback option
 try:
     import openai
+    from openai import AsyncOpenAI
 except ImportError:
     openai = None  # type: ignore[assignment]
+    AsyncOpenAI = None  # type: ignore[assignment,misc]
 
 log = logging.getLogger(__name__)
 
@@ -152,9 +156,9 @@ async def query(
         job = None
         if job_id:
             # Job-based chat - check for existing responses (unless regenerate requested)
-            job = self.job_manager.get_accessible_job(trans, job_id)
+            job = await anyio.to_thread.run_sync(partial(self.job_manager.get_accessible_job, trans, job_id))
             if job and not regenerate:
-                existing_response = self.chat_manager.get(trans, job.id)
+                existing_response = await anyio.to_thread.run_sync(partial(self.chat_manager.get, trans, job.id))
                 if existing_response and existing_response.messages[0]:
                     return ChatResponse(
                         response=existing_response.messages[0].message,
@@ -176,7 +180,9 @@ async def query(
 
                 # If we have an exchange_id, ALWAYS load conversation history from database (source of truth)
                 if exchange_id:
-                    db_history = self.chat_manager.get_chat_history(trans, exchange_id, format_for_pydantic_ai=False)
+                    db_history = await anyio.to_thread.run_sync(
+                        partial(self.chat_manager.get_chat_history, trans, exchange_id, format_for_pydantic_ai=False)
+                    )
                     if db_history:
                         full_context["conversation_history"] = db_history
                     else:
@@ -197,13 +203,15 @@ async def query(
                 self._ensure_ai_configured()
                 # For legacy, use context_type from query_context if it exists
                 context_type = query_context.get("context_type") if isinstance(query_context, dict) else None
-                answer = self._get_ai_response(query_text, trans, context_type)
+                answer = await self._get_ai_response(query_text, trans, context_type)
                 result["response"] = answer
 
             # Save chat exchange to database
             if job:
                 # Job-based chat
-                exchange = self.chat_manager.create(trans, job.id, str(result["response"]))
+                exchange = await anyio.to_thread.run_sync(
+                    partial(self.chat_manager.create, trans, job.id, str(result["response"]))
+                )
                 result["exchange_id"] = exchange.id
             elif trans.user:
                 # Use the exchange_id we already extracted at the beginning
@@ -217,7 +225,9 @@ async def query(
                         "agent_response": agent_resp.model_dump() if agent_resp else None,
                     }
                     message_content = json.dumps(conversation_data)
-                    self.chat_manager.add_message(trans, exchange_id, message_content)
+                    await anyio.to_thread.run_sync(
+                        partial(self.chat_manager.add_message, trans, exchange_id, message_content)
+                    )
                     result["exchange_id"] = exchange_id
                 else:
                     # Create new exchange for first message
@@ -227,7 +237,9 @@ async def query(
                         "response": result.get("response", ""),
                         "agent_response": agent_resp.model_dump() if agent_resp else None,
                     }
-                    exchange = self.chat_manager.create_general_chat(trans, query_text, storable_result, agent_type)
+                    exchange = await anyio.to_thread.run_sync(
+                        partial(self.chat_manager.create_general_chat, trans, query_text, storable_result, agent_type)
+                    )
                     result["exchange_id"] = exchange.id
 
             result["processing_time"] = time.time() - start_time
@@ -421,7 +433,7 @@ def _ensure_ai_configured(self):
         if self.config.ai_api_key is None:
             raise ConfigurationError("AI API key is not configured for this instance.")
 
-    def _get_ai_response(self, query: str, trans: ProvidesUserContext, context_type: Optional[str] = None) -> str:
+    async def _get_ai_response(self, query: str, trans: ProvidesUserContext, context_type: Optional[str] = None) -> str:
         """Get response from AI using pydantic-ai Agent"""
         system_prompt = self._get_system_prompt()
         username = trans.user.username if trans.user else "Anonymous User"
@@ -432,8 +444,8 @@ def _get_ai_response(self, query: str, trans: ProvidesUserContext, context_type:
             full_system_prompt = f"{system_prompt}\n\nYou will address the user as {username}"
             agent: Agent[None, str] = Agent(model_name, system_prompt=full_system_prompt)
 
-            # Get response from the agent
-            result = agent.run_sync(query)
+            # Get response from the agent (async)
+            result = await agent.run(query)
             return result.output
         except UnexpectedModelBehavior as e:
             log.error(f"Unexpected model behavior: {e}")
@@ -442,10 +454,10 @@ def _get_ai_response(self, query: str, trans: ProvidesUserContext, context_type:
             log.error(f"Error using pydantic-ai Agent: {e}")
             # Try fallback to direct OpenAI if available
             if openai is not None:
-                return self._call_openai_directly(query, system_prompt, username)
+                return await self._call_openai_directly(query, system_prompt, username)
             raise
 
-    def _call_openai_directly(self, query: str, system_prompt: str, username: str) -> str:
+    async def _call_openai_directly(self, query: str, system_prompt: str, username: str) -> str:
         """Direct OpenAI API call as fallback"""
         try:
             messages: list[dict[str, str]] = [
@@ -456,7 +468,8 @@ def _call_openai_directly(self, query: str, system_prompt: str, username: str) -
                 },
                 {"role": "user", "content": query},
             ]
-            response = openai.chat.completions.create(
+            client = AsyncOpenAI()
+            response = await client.chat.completions.create(
                 model=self.config.ai_model,
                 messages=messages,  # type: ignore[arg-type]
             )

lib/galaxy/webapps/galaxy/api/proxy.py

@@ -1,13 +1,15 @@
 """
-API Controller to handle remote zip operations.
+API Controller to proxy remote files.
 """
 
 import logging
+from functools import partial
 from urllib.parse import (
     urljoin,
     urlparse,
 )
 
+import anyio
 import httpx
 from fastapi import (
     Query,
@@ -71,7 +73,7 @@ async def proxy(self, request: Request, url: str = URLQueryParam, trans: Provide
         if trans.anonymous:
             raise UserRequiredException("Anonymous users are not allowed to access this endpoint")
 
-        self._validate_url_and_access(url, trans)
+        await anyio.to_thread.run_sync(partial(self._validate_url_and_access, url, trans))
 
         headers: dict[str, str] = {}
         if "range" in request.headers:
@@ -151,7 +153,7 @@ async def _handle_redirects_validation(
                 # Handle relative URLs by resolving them against the current URL
                 redirect_url = urljoin(current_url, redirect_location)
 
-                self._validate_url_and_access(redirect_url, trans)
+                await anyio.to_thread.run_sync(partial(self._validate_url_and_access, redirect_url, trans))
 
                 # Close current response and follow the validated redirect
                 await response.aclose()

test/unit/app/tools/test_parameter_validation.py

@@ -5,6 +5,7 @@
     History,
     HistoryDatasetAssociation,
 )
+from galaxy.tools.parameters.basic import ParameterValueError
 from galaxy.util import galaxy_directory
 from .util import BaseParameterTestCase
 
@@ -415,3 +416,15 @@ def test_RegexValidator_global_flag_inline(self):
         p.validate("select id from job where id = 1;")
         with self.assertRaises(ValueError):
             p.validate("not sql")
+
+    def test_integer_to_python_raises_parameter_value_error(self):
+        p = self._parameter_for(xml='<param name="num" type="integer" value="10" />')
+        assert p.to_python(42, self.app) == 42
+        with self.assertRaises(ParameterValueError):
+            p.to_python(None, self.app)
+
+    def test_float_to_python_raises_parameter_value_error(self):
+        p = self._parameter_for(xml='<param name="num" type="float" value="1.0" />')
+        assert p.to_python(3.14, self.app) == 3.14
+        with self.assertRaises(ParameterValueError):
+            p.to_python(None, self.app)