orchestrator-core 4.5.3__py3-none-any.whl → 4.6.0rc2__py3-none-any.whl

orchestrator/search/retrieval/pagination.py

@@ -11,42 +11,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import array
 import base64
-from dataclasses import dataclass
+from uuid import UUID
 
 from pydantic import BaseModel
 
+from orchestrator.db import SearchQueryTable, db
 from orchestrator.search.core.exceptions import InvalidCursorError
-from orchestrator.search.schemas.parameters import BaseSearchParameters
-from orchestrator.search.schemas.results import SearchResult
-
-
-@dataclass
-class PaginationParams:
-    """Parameters for pagination in search queries."""
-
-    page_after_score: float | None = None
-    page_after_id: str | None = None
-    q_vec_override: list[float] | None = None
-
-
-def floats_to_b64(v: list[float]) -> str:
-    a = array.array("f", v)
-    return base64.urlsafe_b64encode(a.tobytes()).decode("ascii")
-
-
-def b64_to_floats(s: str) -> list[float]:
-    raw = base64.urlsafe_b64decode(s.encode("ascii"))
-    a = array.array("f")
-    a.frombytes(raw)
-    return list(a)
+from orchestrator.search.schemas.parameters import SearchParameters
+from orchestrator.search.schemas.results import SearchResponse
 
 
 class PageCursor(BaseModel):
     score: float
     id: str
-    q_vec_b64: str
+    query_id: UUID
 
     def encode(self) -> str:
         """Encode the cursor data into a URL-safe Base64 string."""
@@ -63,34 +42,45 @@ class PageCursor(BaseModel):
             raise InvalidCursorError("Invalid pagination cursor") from e
 
 
-async def process_pagination_cursor(cursor: str | None, search_params: BaseSearchParameters) -> PaginationParams:
-    """Process pagination cursor and return pagination parameters."""
-    if cursor:
-        c = PageCursor.decode(cursor)
-        return PaginationParams(
-            page_after_score=c.score,
-            page_after_id=c.id,
-            q_vec_override=b64_to_floats(c.q_vec_b64),
-        )
-    if search_params.vector_query:
-        from orchestrator.search.core.embedding import QueryEmbedder
-
-        q_vec_override = await QueryEmbedder.generate_for_text_async(search_params.vector_query)
-        return PaginationParams(q_vec_override=q_vec_override)
-    return PaginationParams()
-
-
-def create_next_page_cursor(
-    search_results: list[SearchResult], pagination_params: PaginationParams, limit: int
+def encode_next_page_cursor(
+    search_response: SearchResponse,
+    cursor: PageCursor | None,
+    search_params: SearchParameters,
 ) -> str | None:
-    """Create next page cursor if there are more results."""
-    has_next_page = len(search_results) == limit and limit > 0
-    if has_next_page:
-        last_item = search_results[-1]
-        cursor_data = PageCursor(
-            score=float(last_item.score),
-            id=last_item.entity_id,
-            q_vec_b64=floats_to_b64(pagination_params.q_vec_override or []),
-        )
-        return cursor_data.encode()
-    return None
+    """Create next page cursor if there are more results.
+
+    On first page, saves the query to database and includes query_id in cursor
+    for subsequent pages to ensure consistent parameters across pagination.
+
+    Args:
+        search_response: SearchResponse containing results and query_embedding
+        cursor: Current page cursor (None for first page, PageCursor for subsequent pages)
+        search_params: Search parameters to save for pagination consistency
+
+    Returns:
+        Encoded cursor for next page, or None if no more results
+    """
+    from orchestrator.search.retrieval.query_state import SearchQueryState
+
+    has_next_page = len(search_response.results) == search_params.limit and search_params.limit > 0
+    if not has_next_page:
+        return None
+
+    # If this is the first page, save query state to database
+    if cursor is None:
+        query_state = SearchQueryState(parameters=search_params, query_embedding=search_response.query_embedding)
+        search_query = SearchQueryTable.from_state(state=query_state)
+
+        db.session.add(search_query)
+        db.session.commit()
+        query_id = search_query.query_id
+    else:
+        query_id = cursor.query_id
+
+    last_item = search_response.results[-1]
+    cursor_data = PageCursor(
+        score=float(last_item.score),
+        id=last_item.entity_id,
+        query_id=query_id,
+    )
+    return cursor_data.encode()

orchestrator/search/retrieval/query_state.py

@@ -0,0 +1,61 @@
+# Copyright 2019-2025 SURF, GÉANT.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from orchestrator.db import SearchQueryTable, db
+from orchestrator.search.core.exceptions import QueryStateNotFoundError
+from orchestrator.search.schemas.parameters import SearchParameters
+
+
+class SearchQueryState(BaseModel):
+    """State of a search query including parameters and embedding.
+
+    This model provides a complete snapshot of what was searched and how.
+    Used for both agent and regular API searches.
+    """
+
+    parameters: SearchParameters = Field(discriminator="entity_type")
+    query_embedding: list[float] | None = Field(default=None, description="The embedding vector for semantic search")
+
+    model_config = ConfigDict(from_attributes=True)
+
+    @classmethod
+    def load_from_id(cls, query_id: UUID | str) -> "SearchQueryState":
+        """Load query state from database by query_id.
+
+        Args:
+            query_id: UUID or string UUID of the saved query
+
+        Returns:
+            SearchQueryState loaded from database
+
+        Raises:
+            ValueError: If query_id format is invalid
+            QueryStateNotFoundError: If query not found in database
+        """
+        if isinstance(query_id, UUID):
+            query_uuid = query_id
+        else:
+            try:
+                query_uuid = UUID(query_id)
+            except (ValueError, TypeError) as e:
+                raise ValueError(f"Invalid query_id format: {query_id}") from e
+
+        search_query = db.session.query(SearchQueryTable).filter_by(query_id=query_uuid).first()
+        if not search_query:
+            raise QueryStateNotFoundError(f"Query {query_uuid} not found in database")
+
+        return cls.model_validate(search_query)

orchestrator/search/retrieval/retrievers/base.py

@@ -20,7 +20,7 @@ from sqlalchemy import BindParameter, Numeric, Select, literal
 from orchestrator.search.core.types import FieldType, SearchMetadata
 from orchestrator.search.schemas.parameters import BaseSearchParameters
 
-from ..pagination import PaginationParams
+from ..pagination import PageCursor
 
 logger = structlog.get_logger(__name__)
 
@@ -41,62 +41,48 @@ class Retriever(ABC):
     ]
 
     @classmethod
-    async def from_params(
+    async def route(
         cls,
         params: BaseSearchParameters,
-        pagination_params: PaginationParams,
+        cursor: PageCursor | None,
+        query_embedding: list[float] | None = None,
     ) -> "Retriever":
-        """Create the appropriate retriever instance from search parameters.
+        """Route to the appropriate retriever instance based on search parameters.
+
+        Selects the retriever type based on available search criteria:
+        - Hybrid: both embedding and fuzzy term available
+        - Semantic: only embedding available
+        - Fuzzy: only text term available (or fallback when embedding generation fails)
+        - Structured: only filters available
 
         Args:
-            params (BaseSearchParameters): Search parameters including vector queries, fuzzy terms, and filters.
-            pagination_params (PaginationParams): Pagination parameters for cursor-based paging.
+            params: Search parameters including vector queries, fuzzy terms, and filters
+            cursor: Pagination cursor for cursor-based paging
+            query_embedding: Query embedding for semantic search, or None if not available
 
         Returns:
-            Retriever: A concrete retriever instance (semantic, fuzzy, hybrid, or structured).
+            A concrete retriever instance based on available search criteria
         """
-
         from .fuzzy import FuzzyRetriever
         from .hybrid import RrfHybridRetriever
         from .semantic import SemanticRetriever
         from .structured import StructuredRetriever
 
         fuzzy_term = params.fuzzy_term
-        q_vec = await cls._get_query_vector(params.vector_query, pagination_params.q_vec_override)
-
-        # If semantic search was attempted but failed, fall back to fuzzy with the full query
-        fallback_fuzzy_term = fuzzy_term
-        if q_vec is None and params.vector_query is not None and params.query is not None:
-            fallback_fuzzy_term = params.query
-
-        if q_vec is not None and fallback_fuzzy_term is not None:
-            return RrfHybridRetriever(q_vec, fallback_fuzzy_term, pagination_params)
-        if q_vec is not None:
-            return SemanticRetriever(q_vec, pagination_params)
-        if fallback_fuzzy_term is not None:
-            return FuzzyRetriever(fallback_fuzzy_term, pagination_params)
-
-        return StructuredRetriever(pagination_params)
-
-    @classmethod
-    async def _get_query_vector(
-        cls, vector_query: str | None, q_vec_override: list[float] | None
-    ) -> list[float] | None:
-        """Get query vector either from override or by generating from text."""
-        if q_vec_override:
-            return q_vec_override
-
-        if not vector_query:
-            return None
 
-        from orchestrator.search.core.embedding import QueryEmbedder
+        # If vector_query exists but embedding generation failed, fall back to fuzzy search with full query
+        if query_embedding is None and params.vector_query is not None and params.query is not None:
+            fuzzy_term = params.query
 
-        q_vec = await QueryEmbedder.generate_for_text_async(vector_query)
-        if not q_vec:
-            logger.warning("Embedding generation failed; using non-semantic retriever")
-            return None
+        # Select retriever based on available search criteria
+        if query_embedding is not None and fuzzy_term is not None:
+            return RrfHybridRetriever(query_embedding, fuzzy_term, cursor)
+        if query_embedding is not None:
+            return SemanticRetriever(query_embedding, cursor)
+        if fuzzy_term is not None:
+            return FuzzyRetriever(fuzzy_term, cursor)
 
-        return q_vec
+        return StructuredRetriever(cursor)
 
     @abstractmethod
     def apply(self, candidate_query: Select) -> Select:

orchestrator/search/retrieval/retrievers/fuzzy.py

@@ -17,17 +17,16 @@ from sqlalchemy.sql.expression import ColumnElement
 from orchestrator.db.models import AiSearchIndex
 from orchestrator.search.core.types import SearchMetadata
 
-from ..pagination import PaginationParams
+from ..pagination import PageCursor
 from .base import Retriever
 
 
 class FuzzyRetriever(Retriever):
     """Ranks results based on the max of fuzzy text similarity scores."""
 
-    def __init__(self, fuzzy_term: str, pagination_params: PaginationParams) -> None:
+    def __init__(self, fuzzy_term: str, cursor: PageCursor | None) -> None:
         self.fuzzy_term = fuzzy_term
-        self.page_after_score = pagination_params.page_after_score
-        self.page_after_id = pagination_params.page_after_id
+        self.cursor = cursor
 
     def apply(self, candidate_query: Select) -> Select:
         cand = candidate_query.subquery()
@@ -42,6 +41,7 @@ class FuzzyRetriever(Retriever):
         combined_query = (
             select(
                 AiSearchIndex.entity_id,
+                AiSearchIndex.entity_title,
                 score,
                 func.first_value(AiSearchIndex.value)
                 .over(partition_by=AiSearchIndex.entity_id, order_by=[similarity_expr.desc(), AiSearchIndex.path.asc()])
@@ -58,12 +58,13 @@ class FuzzyRetriever(Retriever):
                     literal(self.fuzzy_term).op("<%")(AiSearchIndex.value),
                 )
             )
-            .distinct(AiSearchIndex.entity_id)
+            .distinct(AiSearchIndex.entity_id, AiSearchIndex.entity_title)
         )
         final_query = combined_query.subquery("ranked_fuzzy")
 
         stmt = select(
             final_query.c.entity_id,
+            final_query.c.entity_title,
             final_query.c.score,
             final_query.c.highlight_text,
             final_query.c.highlight_path,
@@ -81,13 +82,13 @@ class FuzzyRetriever(Retriever):
         self, stmt: Select, score_column: ColumnElement, entity_id_column: ColumnElement
     ) -> Select:
         """Apply standard score + entity_id pagination."""
-        if self.page_after_score is not None and self.page_after_id is not None:
+        if self.cursor is not None:
             stmt = stmt.where(
                 or_(
-                    score_column < self.page_after_score,
+                    score_column < self.cursor.score,
                     and_(
-                        score_column == self.page_after_score,
-                        entity_id_column > self.page_after_id,
+                        score_column == self.cursor.score,
+                        entity_id_column > self.cursor.id,
                     ),
                 )
             )

orchestrator/search/retrieval/retrievers/hybrid.py

@@ -20,7 +20,7 @@ from sqlalchemy.types import TypeEngine
 from orchestrator.db.models import AiSearchIndex
 from orchestrator.search.core.types import SearchMetadata
 
-from ..pagination import PaginationParams
+from ..pagination import PageCursor
 from .base import Retriever
 
 
@@ -127,14 +127,13 @@ class RrfHybridRetriever(Retriever):
         self,
         q_vec: list[float],
         fuzzy_term: str,
-        pagination_params: PaginationParams,
+        cursor: PageCursor | None,
         k: int = 60,
         field_candidates_limit: int = 100,
     ) -> None:
         self.q_vec = q_vec
         self.fuzzy_term = fuzzy_term
-        self.page_after_score = pagination_params.page_after_score
-        self.page_after_id = pagination_params.page_after_id
+        self.cursor = cursor
         self.k = k
         self.field_candidates_limit = field_candidates_limit
 
@@ -154,6 +153,7 @@ class RrfHybridRetriever(Retriever):
         field_candidates = (
             select(
                 AiSearchIndex.entity_id,
+                AiSearchIndex.entity_title,
                 AiSearchIndex.path,
                 AiSearchIndex.value,
                 sem_val,
@@ -178,9 +178,10 @@ class RrfHybridRetriever(Retriever):
         entity_scores = (
             select(
                 field_candidates.c.entity_id,
+                field_candidates.c.entity_title,
                 func.avg(field_candidates.c.semantic_distance).label("avg_semantic_distance"),
                 func.avg(field_candidates.c.fuzzy_score).label("avg_fuzzy_score"),
-            ).group_by(field_candidates.c.entity_id)
+            ).group_by(field_candidates.c.entity_id, field_candidates.c.entity_title)
         ).cte("entity_scores")
 
         entity_highlights = (
@@ -204,6 +205,7 @@ class RrfHybridRetriever(Retriever):
         ranked = (
             select(
                 entity_scores.c.entity_id,
+                entity_scores.c.entity_title,
                 entity_scores.c.avg_semantic_distance,
                 entity_scores.c.avg_fuzzy_score,
                 entity_highlights.c.highlight_text,
@@ -242,6 +244,7 @@ class RrfHybridRetriever(Retriever):
 
         stmt = select(
             ranked.c.entity_id,
+            ranked.c.entity_title,
             score,
             ranked.c.highlight_text,
             ranked.c.highlight_path,
@@ -262,12 +265,12 @@ class RrfHybridRetriever(Retriever):
         entity_id_column: ColumnElement,
     ) -> Select:
         """Keyset paginate by fused score + id."""
-        if self.page_after_score is not None and self.page_after_id is not None:
-            score_param = self._quantize_score_for_pagination(self.page_after_score)
+        if self.cursor is not None:
+            score_param = self._quantize_score_for_pagination(self.cursor.score)
             stmt = stmt.where(
                 or_(
                     score_column < score_param,
-                    and_(score_column == score_param, entity_id_column > self.page_after_id),
+                    and_(score_column == score_param, entity_id_column > self.cursor.id),
                 )
             )
         return stmt

orchestrator/search/retrieval/retrievers/semantic.py

@@ -17,17 +17,16 @@ from sqlalchemy.sql.expression import ColumnElement
 from orchestrator.db.models import AiSearchIndex
 from orchestrator.search.core.types import SearchMetadata
 
-from ..pagination import PaginationParams
+from ..pagination import PageCursor
 from .base import Retriever
 
 
 class SemanticRetriever(Retriever):
     """Ranks results based on the minimum semantic vector distance."""
 
-    def __init__(self, vector_query: list[float], pagination_params: PaginationParams) -> None:
+    def __init__(self, vector_query: list[float], cursor: PageCursor | None) -> None:
         self.vector_query = vector_query
-        self.page_after_score = pagination_params.page_after_score
-        self.page_after_id = pagination_params.page_after_id
+        self.cursor = cursor
 
     def apply(self, candidate_query: Select) -> Select:
         cand = candidate_query.subquery()
@@ -49,6 +48,7 @@ class SemanticRetriever(Retriever):
         combined_query = (
             select(
                 AiSearchIndex.entity_id,
+                AiSearchIndex.entity_title,
                 score,
                 func.first_value(AiSearchIndex.value)
                 .over(partition_by=AiSearchIndex.entity_id, order_by=[dist.asc(), AiSearchIndex.path.asc()])
@@ -60,12 +60,13 @@ class SemanticRetriever(Retriever):
             .select_from(AiSearchIndex)
             .join(cand, cand.c.entity_id == AiSearchIndex.entity_id)
             .where(AiSearchIndex.embedding.isnot(None))
-            .distinct(AiSearchIndex.entity_id)
+            .distinct(AiSearchIndex.entity_id, AiSearchIndex.entity_title)
         )
         final_query = combined_query.subquery("ranked_semantic")
 
         stmt = select(
             final_query.c.entity_id,
+            final_query.c.entity_title,
             final_query.c.score,
             final_query.c.highlight_text,
             final_query.c.highlight_path,
@@ -83,12 +84,12 @@ class SemanticRetriever(Retriever):
         self, stmt: Select, score_column: ColumnElement, entity_id_column: ColumnElement
     ) -> Select:
         """Apply semantic score pagination with precise Decimal handling."""
-        if self.page_after_score is not None and self.page_after_id is not None:
-            score_param = self._quantize_score_for_pagination(self.page_after_score)
+        if self.cursor is not None:
+            score_param = self._quantize_score_for_pagination(self.cursor.score)
             stmt = stmt.where(
                 or_(
                     score_column < score_param,
-                    and_(score_column == score_param, entity_id_column > self.page_after_id),
+                    and_(score_column == score_param, entity_id_column > self.cursor.id),
                 )
             )
         return stmt

orchestrator/search/retrieval/retrievers/structured.py

@@ -15,22 +15,22 @@ from sqlalchemy import Select, literal, select
 
 from orchestrator.search.core.types import SearchMetadata
 
-from ..pagination import PaginationParams
+from ..pagination import PageCursor
 from .base import Retriever
 
 
 class StructuredRetriever(Retriever):
     """Applies a dummy score for purely structured searches with no text query."""
 
-    def __init__(self, pagination_params: PaginationParams) -> None:
-        self.page_after_id = pagination_params.page_after_id
+    def __init__(self, cursor: PageCursor | None) -> None:
+        self.cursor = cursor
 
     def apply(self, candidate_query: Select) -> Select:
         cand = candidate_query.subquery()
-        stmt = select(cand.c.entity_id, literal(1.0).label("score")).select_from(cand)
+        stmt = select(cand.c.entity_id, cand.c.entity_title, literal(1.0).label("score")).select_from(cand)
 
-        if self.page_after_id:
-            stmt = stmt.where(cand.c.entity_id > self.page_after_id)
+        if self.cursor is not None:
+            stmt = stmt.where(cand.c.entity_id > self.cursor.id)
 
         return stmt.order_by(cand.c.entity_id.asc())
 

orchestrator/search/schemas/parameters.py

@@ -12,9 +12,9 @@
 # limitations under the License.
 
 import uuid
-from typing import Any, Literal
+from typing import Any, ClassVar, Literal
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, TypeAdapter
 
 from orchestrator.search.core.types import ActionType, EntityType
 from orchestrator.search.filters import FilterTree
@@ -23,6 +23,9 @@ from orchestrator.search.filters import FilterTree
 class BaseSearchParameters(BaseModel):
     """Base model with common search parameters."""
 
+    DEFAULT_EXPORT_LIMIT: ClassVar[int] = 1000
+    MAX_EXPORT_LIMIT: ClassVar[int] = 10000
+
     action: ActionType = Field(default=ActionType.SELECT, description="The action to perform.")
     entity_type: EntityType
 
@@ -33,14 +36,18 @@ class BaseSearchParameters(BaseModel):
     )
 
     limit: int = Field(default=10, ge=1, le=30, description="Maximum number of search results to return.")
+    export_limit: int = Field(
+        default=DEFAULT_EXPORT_LIMIT, ge=1, le=MAX_EXPORT_LIMIT, description="Maximum number of results to export."
+    )
     model_config = ConfigDict(extra="forbid")
 
     @classmethod
-    def create(cls, entity_type: EntityType, **kwargs: Any) -> "BaseSearchParameters":
-        try:
-            return PARAMETER_REGISTRY[entity_type](entity_type=entity_type, **kwargs)
-        except KeyError:
-            raise ValueError(f"No search parameter class found for entity type: {entity_type.value}")
+    def create(cls, **kwargs: Any) -> "SearchParameters":
+        """Create the correct search parameter subclass instance based on entity_type."""
+        from orchestrator.search.schemas.parameters import SearchParameters
+
+        adapter: TypeAdapter = TypeAdapter(SearchParameters)
+        return adapter.validate_python(kwargs)
 
     @property
     def vector_query(self) -> str | None:
@@ -121,9 +128,6 @@ class ProcessSearchParameters(BaseSearchParameters):
     )
 
 
-PARAMETER_REGISTRY: dict[EntityType, type[BaseSearchParameters]] = {
-    EntityType.SUBSCRIPTION: SubscriptionSearchParameters,
-    EntityType.PRODUCT: ProductSearchParameters,
-    EntityType.WORKFLOW: WorkflowSearchParameters,
-    EntityType.PROCESS: ProcessSearchParameters,
-}
+SearchParameters = (
+    SubscriptionSearchParameters | ProductSearchParameters | WorkflowSearchParameters | ProcessSearchParameters
+)

orchestrator/search/schemas/results.py

@@ -15,7 +15,7 @@ from typing import Literal
 
 from pydantic import BaseModel, ConfigDict
 
-from orchestrator.search.core.types import FilterOp, SearchMetadata, UIType
+from orchestrator.search.core.types import EntityType, FilterOp, SearchMetadata, UIType
 
 
 class MatchingField(BaseModel):
@@ -30,6 +30,8 @@ class SearchResult(BaseModel):
     """Represents a single search result item."""
 
     entity_id: str
+    entity_type: EntityType
+    entity_title: str
     score: float
     perfect_match: int = 0
     matching_field: MatchingField | None = None
@@ -40,6 +42,7 @@ class SearchResponse(BaseModel):
 
     results: list[SearchResult]
     metadata: SearchMetadata
+    query_embedding: list[float] | None = None
 
 
 class ValueSchema(BaseModel):

orchestrator/settings.py

@@ -57,6 +57,7 @@ class AppSettings(BaseSettings):
     EXECUTOR: str = ExecutorType.THREADPOOL
     WORKFLOWS_SWAGGER_HOST: str = "localhost"
     WORKFLOWS_GUI_URI: str = "http://localhost:3000"
+    BASE_URL: str = "http://localhost:8080"  # Base URL for the API (used for generating export URLs)
     DATABASE_URI: PostgresDsn = "postgresql://nwa:nwa@localhost/orchestrator-core"  # type: ignore
     MAX_WORKERS: int = 5
     MAIL_SERVER: str = "localhost"

orchestrator/utils/auth.py

@@ -1,9 +1,10 @@
 from collections.abc import Callable
-from typing import TypeAlias
+from typing import TypeAlias, TypeVar
 
 from oauth2_lib.fastapi import OIDCUserModel
 
 # This file is broken out separately to avoid circular imports.
 
 # Can instead use "type Authorizer = ..." in later Python versions.
-Authorizer: TypeAlias = Callable[[OIDCUserModel | None], bool]
+T = TypeVar("T", bound=OIDCUserModel)
+Authorizer: TypeAlias = Callable[[T | None], bool]

{orchestrator_core-4.5.3.dist-info → orchestrator_core-4.6.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.5.3
+Version: 4.6.0rc2
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
 Requires-Python: >=3.11,<3.14
@@ -42,7 +42,7 @@ Requires-Dist: itsdangerous>=2.2.0
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: more-itertools~=10.7.0
 Requires-Dist: nwa-stdlib~=1.9.2
-Requires-Dist: oauth2-lib>=2.4.1
+Requires-Dist: oauth2-lib==2.4.2
 Requires-Dist: orjson==3.10.18
 Requires-Dist: pgvector>=0.4.1
 Requires-Dist: prometheus-client==0.22.1
@@ -63,7 +63,7 @@ Requires-Dist: structlog>=25.4.0
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: typer==0.15.4
 Requires-Dist: uvicorn[standard]~=0.34.0
-Requires-Dist: pydantic-ai-slim ==0.7.0 ; extra == "agent"
+Requires-Dist: pydantic-ai-slim >=1.3.0 ; extra == "agent"
 Requires-Dist: ag-ui-protocol>=0.1.8 ; extra == "agent"
 Requires-Dist: litellm>=1.75.7 ; extra == "agent"
 Requires-Dist: celery~=5.5.1 ; extra == "celery"