orchestrator-core 4.6.0rc1__tar.gz → 4.6.0rc3__tar.gz

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-core
-Version: 4.6.0rc1
+Version: 4.6.0rc3
 Summary: This is the orchestrator workflow engine.
 Author-email: SURF <automation-beheer@surf.nl>
 Requires-Python: >=3.11,<3.14

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "4.6.0rc1"
+__version__ = "4.6.0rc3"
 
 
 from structlog import get_logger

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/orchestrator/agentic_app.py

@@ -26,7 +26,7 @@ from orchestrator.cli.main import app as cli_app
 from orchestrator.llm_settings import LLMSettings, llm_settings
 
 if TYPE_CHECKING:
-    from pydantic_ai.models.openai import OpenAIModel
+    from pydantic_ai.models.openai import OpenAIChatModel
 
 logger = get_logger(__name__)
 
@@ -36,7 +36,7 @@ class LLMOrchestratorCore(OrchestratorCore):
         self,
         *args: Any,
         llm_settings: LLMSettings = llm_settings,
-        agent_model: "OpenAIModel | str | None" = None,
+        agent_model: "OpenAIChatModel | str | None" = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the `LLMOrchestratorCore` class.

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/orchestrator/api/api_v1/endpoints/agent.py

@@ -20,7 +20,6 @@ from pydantic_ai.agent import Agent
 from starlette.responses import Response
 from structlog import get_logger
 
-from orchestrator.llm_settings import llm_settings
 from orchestrator.search.agent import build_agent_instance
 from orchestrator.search.agent.state import SearchState
 
@@ -29,12 +28,12 @@ logger = get_logger(__name__)
 
 
 @cache
-def get_agent() -> Agent[StateDeps[SearchState], str]:
+def get_agent(request: Request) -> Agent[StateDeps[SearchState], str]:
     """Dependency to provide the agent instance.
 
     The agent is built once and cached for the lifetime of the application.
     """
-    return build_agent_instance(llm_settings.AGENT_MODEL)
+    return build_agent_instance(request.app.agent_model)
 
 
 @router.post("/")

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/orchestrator/cli/scheduler.py

@@ -12,26 +12,23 @@
 # limitations under the License.
 
 
-import logging
 import time
 
 import typer
 
 from orchestrator.schedules.scheduler import (
-    get_paused_scheduler,
+    get_all_scheduler_tasks,
+    get_scheduler,
+    get_scheduler_task,
 )
 
-log = logging.getLogger(__name__)
-
 app: typer.Typer = typer.Typer()
 
 
 @app.command()
 def run() -> None:
     """Start scheduler and loop eternally to keep thread alive."""
-    with get_paused_scheduler() as scheduler:
-        scheduler.resume()
-
+    with get_scheduler():
         while True:
             time.sleep(1)
 
@@ -42,27 +39,23 @@ def show_schedule() -> None:
 
     in cli underscore is replaced by a dash `show-schedule`
     """
-    with get_paused_scheduler() as scheduler:
-        jobs = scheduler.get_jobs()
-
-    for job in jobs:
-        typer.echo(f"[{job.id}] Next run: {job.next_run_time} | Trigger: {job.trigger}")
+    for task in get_all_scheduler_tasks():
+        typer.echo(f"[{task.id}] Next run: {task.next_run_time} | Trigger: {task.trigger}")
 
 
 @app.command()
-def force(job_id: str) -> None:
-    """Force the execution of (a) scheduler(s) based on a job_id."""
-    with get_paused_scheduler() as scheduler:
-        job = scheduler.get_job(job_id)
+def force(task_id: str) -> None:
+    """Force the execution of (a) scheduler(s) based on a task_id."""
+    task = get_scheduler_task(task_id)
 
-    if not job:
-        typer.echo(f"Job '{job_id}' not found.")
+    if not task:
+        typer.echo(f"Task '{task_id}' not found.")
         raise typer.Exit(code=1)
 
-    typer.echo(f"Running job [{job.id}] now...")
+    typer.echo(f"Running Task [{task.id}] now...")
     try:
-        job.func(*job.args or (), **job.kwargs or {})
-        typer.echo("Job executed successfully.")
+        task.func(*task.args or (), **task.kwargs or {})
+        typer.echo("Task executed successfully.")
     except Exception as e:
-        typer.echo(f"Job execution failed: {e}")
+        typer.echo(f"Task execution failed: {e}")
         raise typer.Exit(code=1)

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/orchestrator/llm_settings.py

@@ -10,14 +10,31 @@
 # 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 typing import Annotated
+
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings
 from structlog import get_logger
 
 logger = get_logger(__name__)
 
+EMBEDDING_DIMENSION_MIN = 200
+EMBEDDING_DIMENSION_MAX = 2000
+EMBEDDING_DIMENSION_DEFAULT = 1536
+
+EMBEDDING_DIMENSION_FIELD = Annotated[
+    int,
+    Field(
+        ge=EMBEDDING_DIMENSION_MIN,
+        le=EMBEDDING_DIMENSION_MAX,
+        default=EMBEDDING_DIMENSION_DEFAULT,
+        description="Embedding dimension: when embeddings are generated at a higher resolution than this setting, the least significant numbers will be truncated",
+    ),
+]
+
 
 class LLMSettings(BaseSettings):
+
     # Feature flags for LLM functionality
     SEARCH_ENABLED: bool = False  # Enable search/indexing with embeddings
     AGENT_ENABLED: bool = False  # Enable agentic functionality
@@ -27,7 +44,7 @@ class LLMSettings(BaseSettings):
     AGENT_MODEL_VERSION: str = "2025-01-01-preview"
     OPENAI_API_KEY: str = ""  # Change per provider (Azure, etc).
     # Embedding settings
-    EMBEDDING_DIMENSION: int = 1536
+    EMBEDDING_DIMENSION: EMBEDDING_DIMENSION_FIELD = 1536
     EMBEDDING_MODEL: str = "openai/text-embedding-3-small"  # See litellm docs for supported models.
     EMBEDDING_SAFE_MARGIN_PERCENT: float = Field(
         0.1, description="Safety margin as a percentage (e.g., 0.1 for 10%) for token budgeting.", ge=0, le=1

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/orchestrator/schedules/scheduler.py

@@ -17,16 +17,16 @@ from datetime import datetime
 from typing import Any, Generator
 
 from apscheduler.executors.pool import ThreadPoolExecutor
-from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
+from apscheduler.jobstores.sqlalchemy import Job, SQLAlchemyJobStore
 from apscheduler.schedulers.background import BackgroundScheduler
 from more_itertools import partition
 from pydantic import BaseModel
 
+from orchestrator.db import db
 from orchestrator.db.filters import Filter
 from orchestrator.db.filters.filters import CallableErrorHandler
 from orchestrator.db.sorting import Sort
 from orchestrator.db.sorting.sorting import SortOrder
-from orchestrator.settings import app_settings
 from orchestrator.utils.helpers import camel_to_snake, to_camel
 
 executors = {
@@ -40,18 +40,37 @@ scheduler = BackgroundScheduler(executors=executors, job_defaults=job_defaults)
 
 
 @contextmanager
-def get_paused_scheduler() -> Generator[BackgroundScheduler, Any, None]:
+def get_scheduler_store() -> Generator[SQLAlchemyJobStore, Any, None]:
+    store = SQLAlchemyJobStore(engine=db.engine)
     try:
-        scheduler.add_jobstore(SQLAlchemyJobStore(url=str(app_settings.DATABASE_URI)))
-    except ValueError:
-        pass
-    scheduler.start(paused=True)
-
-    try:
-        yield scheduler
+        yield store
     finally:
-        scheduler.shutdown()
-        scheduler._jobstores["default"].engine.dispose()
+        store.shutdown()
+
+
+def get_all_scheduler_tasks() -> list[Job]:
+    with get_scheduler_store() as scheduler_store:
+        return scheduler_store.get_all_jobs()
+
+
+def get_scheduler_task(job_id: str) -> Job | None:
+    with get_scheduler_store() as scheduler_store:
+        return scheduler_store.lookup_job(job_id)
+
+
+@contextmanager
+def get_scheduler(paused: bool = False) -> Generator[BackgroundScheduler, Any, None]:
+    with get_scheduler_store() as store:
+        try:
+            scheduler.add_jobstore(store)
+        except ValueError:
+            pass
+        scheduler.start(paused=paused)
+
+        try:
+            yield scheduler
+        finally:
+            scheduler.shutdown()
 
 
 class ScheduledTask(BaseModel):
@@ -149,9 +168,7 @@ def get_scheduler_tasks(
     sort_by: list[Sort] | None = None,
     error_handler: CallableErrorHandler = default_error_handler,
 ) -> tuple[list[ScheduledTask], int]:
-    with get_paused_scheduler() as pauzed_scheduler:
-        scheduled_tasks = pauzed_scheduler.get_jobs()
-
+    scheduled_tasks = get_all_scheduler_tasks()
     scheduled_tasks = filter_scheduled_tasks(scheduled_tasks, error_handler, filter_by)
     scheduled_tasks = sort_scheduled_tasks(scheduled_tasks, error_handler, sort_by)
 

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/orchestrator/search/agent/agent.py

@@ -16,7 +16,7 @@ from typing import Any
 import structlog
 from pydantic_ai.ag_ui import StateDeps
 from pydantic_ai.agent import Agent
-from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.models.openai import OpenAIChatModel
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.toolsets import FunctionToolset
 
@@ -28,12 +28,12 @@ logger = structlog.get_logger(__name__)
 
 
 def build_agent_instance(
-    model: str | OpenAIModel, agent_tools: list[FunctionToolset[Any]] | None = None
+    model: str | OpenAIChatModel, agent_tools: list[FunctionToolset[Any]] | None = None
 ) -> Agent[StateDeps[SearchState], str]:
     """Build and configure the search agent instance.
 
     Args:
-        model: The LLM model to use (string or OpenAIModel instance)
+        model: The LLM model to use (string or OpenAIChatModel instance)
         agent_tools: Optional list of additional toolsets to include
 
     Returns:

{orchestrator_core-4.6.0rc1 → orchestrator_core-4.6.0rc3}/orchestrator/search/core/embedding.py

@@ -42,7 +42,7 @@ class EmbeddingIndexer:
                 max_retries=llm_settings.LLM_MAX_RETRIES,
             )
             data = sorted(resp.data, key=lambda e: e["index"])
-            return [row["embedding"] for row in data]
+            return [row["embedding"][: llm_settings.EMBEDDING_DIMENSION] for row in data]
         except (llm_exc.APIError, llm_exc.APIConnectionError, llm_exc.RateLimitError, llm_exc.Timeout) as e:
             logger.error("Embedding request failed", error=str(e))
             return [[] for _ in texts]
@@ -67,7 +67,7 @@ class QueryEmbedder:
                 timeout=5.0,
                 max_retries=0,  # No retries, prioritize speed.
             )
-            return resp.data[0]["embedding"]
+            return resp.data[0]["embedding"][: llm_settings.EMBEDDING_DIMENSION]
         except Exception as e:
             logger.error("Async embedding generation failed", error=str(e))
             return []