synth-ai 0.2.14__py3-none-any.whl → 0.2.17__py3-none-any.whl

synth_ai/tracing_v3/storage/base.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Any, Optional
+from typing import Any
 
 from ..abstractions import SessionTrace
 
@@ -28,7 +28,7 @@ class TraceStorage(ABC):
         pass
 
     @abstractmethod
-    async def get_session_trace(self, session_id: str) -> Optional[dict[str, Any]]:
+    async def get_session_trace(self, session_id: str) -> dict[str, Any] | None:
         """Retrieve a session trace by ID.
 
         Args:
@@ -40,7 +40,7 @@ class TraceStorage(ABC):
         pass
 
     @abstractmethod
-    async def query_traces(self, query: str, params: Optional[dict[str, Any]] = None) -> Any:
+    async def query_traces(self, query: str, params: dict[str, Any] | None = None) -> Any:
         """Execute a query and return results.
 
         Args:
@@ -55,9 +55,9 @@ class TraceStorage(ABC):
     @abstractmethod
     async def get_model_usage(
         self,
-        start_date: Optional[datetime] = None,
-        end_date: Optional[datetime] = None,
-        model_name: Optional[str] = None,
+        start_date: datetime | None = None,
+        end_date: datetime | None = None,
+        model_name: str | None = None,
     ) -> Any:
         """Get model usage statistics.
 
@@ -95,8 +95,8 @@ class TraceStorage(ABC):
         self,
         session_id: str,
         *,
-        created_at: Optional[datetime] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        created_at: datetime | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> None:
         """Ensure a session row exists for the given session id."""
         pass
@@ -108,10 +108,10 @@ class TraceStorage(ABC):
         *,
         step_id: str,
         step_index: int,
-        turn_number: Optional[int] = None,
-        started_at: Optional[datetime] = None,
-        completed_at: Optional[datetime] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        turn_number: int | None = None,
+        started_at: datetime | None = None,
+        completed_at: datetime | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> int:
         """Ensure a timestep row exists and return its database id."""
         pass
@@ -121,9 +121,9 @@ class TraceStorage(ABC):
         self,
         session_id: str,
         *,
-        timestep_db_id: Optional[int],
+        timestep_db_id: int | None,
         event: Any,
-        metadata_override: Optional[dict[str, Any]] = None,
+        metadata_override: dict[str, Any] | None = None,
     ) -> int:
         """Insert an event and return its database id."""
         pass
@@ -133,12 +133,12 @@ class TraceStorage(ABC):
         self,
         session_id: str,
         *,
-        timestep_db_id: Optional[int],
+        timestep_db_id: int | None,
         message_type: str,
         content: Any,
-        event_time: Optional[float] = None,
-        message_time: Optional[int] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        event_time: float | None = None,
+        message_time: int | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> int:
         """Insert a message row linked to a session/timestep."""
         pass
@@ -151,7 +151,7 @@ class TraceStorage(ABC):
         total_reward: int,
         achievements_count: int,
         total_steps: int,
-        reward_metadata: Optional[dict] = None,
+        reward_metadata: dict | None = None,
     ) -> int:
         """Record an outcome reward for a session."""
         pass
@@ -162,13 +162,13 @@ class TraceStorage(ABC):
         session_id: str,
         *,
         event_id: int,
-        message_id: Optional[int] = None,
-        turn_number: Optional[int] = None,
+        message_id: int | None = None,
+        turn_number: int | None = None,
         reward_value: float = 0.0,
-        reward_type: Optional[str] = None,
-        key: Optional[str] = None,
-        annotation: Optional[dict[str, Any]] = None,
-        source: Optional[str] = None,
+        reward_type: str | None = None,
+        key: str | None = None,
+        annotation: dict[str, Any] | None = None,
+        source: str | None = None,
     ) -> int:
         """Record a reward tied to a specific event."""
         pass
@@ -178,8 +178,8 @@ class TraceStorage(ABC):
         self,
         experiment_id: str,
         name: str,
-        description: Optional[str] = None,
-        configuration: Optional[dict[str, Any]] = None,
+        description: str | None = None,
+        configuration: dict[str, Any] | None = None,
     ) -> str:
         """Create a new experiment."""
         raise NotImplementedError("Experiment management not supported by this backend")
@@ -189,14 +189,14 @@ class TraceStorage(ABC):
         raise NotImplementedError("Experiment management not supported by this backend")
 
     async def get_sessions_by_experiment(
-        self, experiment_id: str, limit: Optional[int] = None
+        self, experiment_id: str, limit: int | None = None
     ) -> list[dict[str, Any]]:
         """Get all sessions for an experiment."""
         raise NotImplementedError("Experiment management not supported by this backend")
 
     # Batch operations
     async def batch_insert_sessions(
-        self, traces: list[SessionTrace], batch_size: Optional[int] = 1000
+        self, traces: list[SessionTrace], batch_size: int | None = 1000
     ) -> list[str]:
         """Batch insert multiple session traces.
 

synth_ai/tracing_v3/storage/config.py

@@ -3,7 +3,7 @@
 import os
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Optional
+from typing import Any
 
 
 class StorageBackend(str, Enum):
@@ -14,7 +14,7 @@ class StorageBackend(str, Enum):
     POSTGRES = "postgres"  # Future support
 
 
-def _is_enabled(value: Optional[str]) -> bool:
+def _is_enabled(value: str | None) -> bool:
     if value is None:
         return False
     return value.lower() in {"1", "true", "yes", "on"}
@@ -25,7 +25,7 @@ class StorageConfig:
     """Configuration for storage backend."""
 
     backend: StorageBackend = StorageBackend.TURSO_NATIVE
-    connection_string: Optional[str] = None
+    connection_string: str | None = None
 
     # Turso-specific settings
     turso_url: str = os.getenv("TURSO_DATABASE_URL", "sqlite+libsql://http://127.0.0.1:8080")

synth_ai/tracing_v3/turso/daemon.py

@@ -7,7 +7,6 @@ import time
 
 import requests
 from requests import RequestException
-from typing import Any, Optional
 
 from ..config import CONFIG
 
@@ -17,9 +16,9 @@ class SqldDaemon:
 
     def __init__(
         self,
-        db_path: Optional[str] = None,
-        http_port: Optional[int] = None,
-        binary_path: Optional[str] = None,
+        db_path: str | None = None,
+        http_port: int | None = None,
+        binary_path: str | None = None,
     ):
         """Initialize sqld daemon manager.
 
@@ -31,7 +30,7 @@ class SqldDaemon:
         self.db_path = db_path or CONFIG.sqld_db_path
         self.http_port = http_port or CONFIG.sqld_http_port
         self.binary_path = binary_path or self._find_binary()
-        self.process: Optional[Any] = None
+        self.process: subprocess.Popen[str] | None = None
 
     def _find_binary(self) -> str:
         """Find sqld binary in PATH."""
@@ -85,7 +84,7 @@ class SqldDaemon:
                 pass
 
             # Check if process crashed
-            if self.process.poll() is not None:
+            if self.process and self.process.poll() is not None:
                 stdout, stderr = self.process.communicate()
                 raise RuntimeError(
                     f"sqld daemon failed to start:\nstdout: {stdout}\nstderr: {stderr}"
@@ -124,10 +123,10 @@ class SqldDaemon:
 
 
 # Convenience functions
-_daemon: Optional[SqldDaemon] = None
+_daemon: SqldDaemon | None = None
 
 
-def start_sqld(db_path: Optional[str] = None, port: Optional[int] = None) -> SqldDaemon:
+def start_sqld(db_path: str | None = None, port: int | None = None) -> SqldDaemon:
     """Start a global sqld daemon instance."""
     global _daemon
     if _daemon and _daemon.is_running():
@@ -146,6 +145,6 @@ def stop_sqld():
         _daemon = None
 
 
-def get_daemon() -> Optional[SqldDaemon]:
+def get_daemon() -> SqldDaemon | None:
     """Get the global daemon instance."""
     return _daemon

synth_ai/tracing_v3/turso/native_manager.py

@@ -13,7 +13,7 @@ import logging
 import re
 from collections.abc import Callable
 from dataclasses import asdict, dataclass
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any, cast
 
 import libsql
@@ -378,8 +378,10 @@ class NativeLibsqlTraceManager(TraceStorage):
         session_exists = await self._session_exists(trace.session_id)
         _logger.info(f"[TRACE_DEBUG] Session exists: {session_exists}")
         
+        step_id_map: dict[str, int] = {}
+        
         if session_exists:
-            _logger.warning(f"[TRACE_DEBUG] Session {trace.session_id} already exists, need to save messages anyway!")
+            _logger.warning(f"[TRACE_DEBUG] Session {trace.session_id} already exists, skipping events/timesteps, only updating messages!")
             # Don't return early - we need to save messages!
             # Just update metadata
             async with self._op_lock:
@@ -390,10 +392,9 @@ class NativeLibsqlTraceManager(TraceStorage):
                     (_json_dumps(trace.metadata or {}), trace.session_id),
                 )
                 conn.commit()
-            # Continue to save messages instead of returning
-
-        if not session_exists:
-            created_at = trace.created_at or datetime.now(timezone.utc)
+            # Skip events and timesteps to ensure idempotency
+        else:
+            created_at = trace.created_at or datetime.now(UTC)
 
             async with self._op_lock:
                 conn = self._conn
@@ -417,73 +418,76 @@ class NativeLibsqlTraceManager(TraceStorage):
                     ),
                 )
                 conn.commit()
-                _logger.info(f"[TRACE_DEBUG] Session row inserted")
-
-        step_id_map: dict[str, int] = {}
+                _logger.info("[TRACE_DEBUG] Session row inserted")
 
-        for step in trace.session_time_steps:
-            step_db_id = await self.ensure_timestep(
-                trace.session_id,
-                step_id=step.step_id,
-                step_index=step.step_index,
-                turn_number=step.turn_number,
-                started_at=step.timestamp,
-                completed_at=step.completed_at,
-                metadata=step.step_metadata or {},
-            )
-            step_id_map[step.step_id] = step_db_id
-
-        for event in trace.event_history:
-            step_ref = None
-            metadata = event.metadata or {}
-            if isinstance(metadata, dict):
-                step_ref = metadata.get("step_id")
-            timestep_db_id = step_id_map.get(step_ref) if step_ref else None
-            await self.insert_event_row(
-                trace.session_id,
-                timestep_db_id=timestep_db_id,
-                event=event,
-                metadata_override=event.metadata or {},
-            )
+            # Only insert timesteps and events if this is a new session
+            for step in trace.session_time_steps:
+                step_db_id = await self.ensure_timestep(
+                    trace.session_id,
+                    step_id=step.step_id,
+                    step_index=step.step_index,
+                    turn_number=step.turn_number,
+                    started_at=step.timestamp,
+                    completed_at=step.completed_at,
+                    metadata=step.step_metadata or {},
+                )
+                step_id_map[step.step_id] = step_db_id
+
+            for event in trace.event_history:
+                step_ref = None
+                metadata = event.metadata or {}
+                if isinstance(metadata, dict):
+                    step_ref = metadata.get("step_id")
+                timestep_db_id = step_id_map.get(step_ref) if step_ref else None
+                await self.insert_event_row(
+                    trace.session_id,
+                    timestep_db_id=timestep_db_id,
+                    event=event,
+                    metadata_override=event.metadata or {},
+                )
 
         import logging as _logging
         _logger = _logging.getLogger(__name__)
-        _logger.info(f"[TRACE_DEBUG] insert_session_trace: saving {len(trace.markov_blanket_message_history)} messages")
+        _logger.info(f"[TRACE_DEBUG] insert_session_trace: saving {len(trace.markov_blanket_message_history)} messages (session_exists={session_exists})")
         
-        for idx, msg in enumerate(trace.markov_blanket_message_history):
-            metadata = dict(getattr(msg, "metadata", {}) or {})
-            step_ref = metadata.get("step_id")
-            content_value = msg.content
-            if isinstance(msg.content, SessionMessageContent):
-                if msg.content.json_payload:
-                    metadata.setdefault("json_payload", msg.content.json_payload)
-                    content_value = msg.content.json_payload
-                else:
-                    content_value = msg.content.as_text()
-                    if msg.content.text:
-                        metadata.setdefault("text", msg.content.text)
-            elif not isinstance(content_value, str):
+        # Only insert messages if this is a new session (for idempotency)
+        if not session_exists:
+            for idx, msg in enumerate(trace.markov_blanket_message_history):
+                metadata = dict(getattr(msg, "metadata", {}) or {})
+                step_ref = metadata.get("step_id")
+                content_value = msg.content
+                if isinstance(msg.content, SessionMessageContent):
+                    if msg.content.json_payload:
+                        metadata.setdefault("json_payload", msg.content.json_payload)
+                        content_value = msg.content.json_payload
+                    else:
+                        content_value = msg.content.as_text()
+                        if msg.content.text:
+                            metadata.setdefault("text", msg.content.text)
+                elif not isinstance(content_value, str):
+                    try:
+                        content_value = json.dumps(content_value, ensure_ascii=False)
+                    except (TypeError, ValueError):
+                        content_value = str(content_value)
+
+                _logger.info(f"[TRACE_DEBUG]   Message {idx+1}: type={msg.message_type}, content_len={len(str(content_value))}")
+                
                 try:
-                    content_value = json.dumps(content_value, ensure_ascii=False)
-                except (TypeError, ValueError):
-                    content_value = str(content_value)
-
-            _logger.info(f"[TRACE_DEBUG]   Message {idx+1}: type={msg.message_type}, content_len={len(str(content_value))}")
-            
-            try:
-                await self.insert_message_row(
-                    trace.session_id,
-                    timestep_db_id=step_id_map.get(step_ref) if step_ref else None,
-                    message_type=msg.message_type,
-                    content=content_value,
-                    event_time=msg.time_record.event_time,
-                    message_time=msg.time_record.message_time,
-                    metadata=metadata,
-                )
-                _logger.info(f"[TRACE_DEBUG]   Message {idx+1}: saved successfully")
-            except Exception as exc:
-                _logger.error(f"[TRACE_DEBUG]   Message {idx+1}: FAILED TO SAVE: {exc}", exc_info=True)
-                raise
+                    await self.insert_message_row(
+                        trace.session_id,
+                        timestep_db_id=step_id_map.get(step_ref) if step_ref else None,
+                        message_type=msg.message_type,
+                        content=content_value,
+                        event_time=msg.time_record.event_time,
+                        message_time=msg.time_record.message_time,
+                        metadata=metadata,
+                    )
+                    _logger.info(f"[TRACE_DEBUG]   Message {idx+1}: saved successfully")
+                except Exception as exc:
+                    _logger.error(f"[TRACE_DEBUG]   Message {idx+1}: FAILED TO SAVE: {exc}", exc_info=True)
+                    raise
+        else:
+            _logger.info("[TRACE_DEBUG] Skipping message insertion for existing session (idempotency)")
 
         async with self._op_lock:
             conn = self._conn
@@ -806,7 +810,7 @@ class NativeLibsqlTraceManager(TraceStorage):
     ) -> None:
         await self.initialize()
 
-        created_at_val = (created_at or datetime.now(timezone.utc)).isoformat()
+        created_at_val = (created_at or datetime.now(UTC)).isoformat()
         metadata_json = _json_dumps(metadata or {})
 
         async with self._op_lock:
@@ -838,7 +842,7 @@ class NativeLibsqlTraceManager(TraceStorage):
     ) -> int:
         await self.initialize()
 
-        started_at_val = (started_at or datetime.now(timezone.utc)).isoformat()
+        started_at_val = (started_at or datetime.now(UTC)).isoformat()
         completed_at_val = completed_at.isoformat() if completed_at else None
         metadata_json = _json_dumps(metadata or {})
 
@@ -927,7 +931,11 @@ class NativeLibsqlTraceManager(TraceStorage):
         if isinstance(event, LMCAISEvent):
             call_records = None
             if getattr(event, "call_records", None):
-                call_records = [asdict(record) for record in event.call_records]
+                # Handle both dataclass instances and dicts (from deserialization)
+                call_records = [
+                    asdict(record) if not isinstance(record, dict) else record
+                    for record in event.call_records
+                ]
             payload.update(
                 {
                     "event_type": "cais",
@@ -1150,7 +1158,7 @@ class NativeLibsqlTraceManager(TraceStorage):
                     total_reward,
                     achievements_count,
                     total_steps,
-                    datetime.now(timezone.utc).isoformat(),
+                    datetime.now(UTC).isoformat(),
                     _json_dumps(reward_metadata),
                 ),
             )
@@ -1202,7 +1210,7 @@ class NativeLibsqlTraceManager(TraceStorage):
                     key,
                     _json_dumps(annotation),
                     source,
-                    datetime.now(timezone.utc).isoformat(),
+                    datetime.now(UTC).isoformat(),
                 ),
             )
             conn.commit()

synth_ai/tracing_v3/utils.py

@@ -5,13 +5,13 @@ from __future__ import annotations
 import hashlib
 import json
 import uuid
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any
 
 
 def iso_now() -> str:
     """Get current timezone.utc time as ISO format string."""
-    return datetime.now(timezone.utc).isoformat()
+    return datetime.now(UTC).isoformat()
 
 
 def json_dumps(obj: Any) -> str:

synth_ai/utils/__init__.py

@@ -0,0 +1,101 @@
+from . import task_app_state
+from .base_url import PROD_BASE_URL_DEFAULT, get_backend_from_env, get_learning_v2_base_url
+from .cli import PromptedChoiceOption, PromptedChoiceType, print_next_step
+from .env import mask_str, resolve_env_var, write_env_var_to_dotenv, write_env_var_to_json
+from .http import AsyncHttpClient, HTTPError, http_request
+from .modal import (
+    ensure_modal_installed,
+    ensure_task_app_ready,
+    find_asgi_apps,
+    is_local_demo_url,
+    is_modal_public_url,
+    normalize_endpoint_url,
+)
+from .process import ensure_local_port_available, popen_capture, popen_stream, popen_stream_capture
+from .sqld import SQLD_VERSION, find_sqld_binary, install_sqld
+from .task_app_discovery import AppChoice, discover_eval_config_paths, select_app_choice
+from .task_app_env import ensure_env_credentials, ensure_port_free, preflight_env_key
+from .task_app_state import (
+    DEFAULT_TASK_APP_SECRET_NAME,
+    current_task_app_id,
+    load_demo_dir,
+    load_template_id,
+    now_iso,
+    persist_api_key,
+    persist_demo_dir,
+    persist_env_api_key,
+    persist_task_url,
+    persist_template_id,
+    read_task_app_config,
+    record_task_app,
+    resolve_task_app_entry,
+    task_app_config_path,
+    task_app_id_from_path,
+    update_task_app_entry,
+    write_task_app_config,
+)
+from .user_config import (
+    USER_CONFIG_PATH,
+    load_user_config,
+    load_user_env,
+    save_user_config,
+    update_user_config,
+)
+
+__all__ = [
+    "AppChoice",
+    "AsyncHttpClient",
+    "DEFAULT_TASK_APP_SECRET_NAME",
+    "HTTPError",
+    "PROD_BASE_URL_DEFAULT",
+    "PromptedChoiceOption",
+    "PromptedChoiceType",
+    "SQLD_VERSION",
+    "USER_CONFIG_PATH",
+    "current_task_app_id",
+    "discover_eval_config_paths",
+    "ensure_env_credentials",
+    "ensure_local_port_available",
+    "ensure_modal_installed",
+    "ensure_port_free",
+    "ensure_task_app_ready",
+    "find_asgi_apps",
+    "find_sqld_binary",
+    "get_backend_from_env",
+    "get_learning_v2_base_url",
+    "http_request",
+    "install_sqld",
+    "is_local_demo_url",
+    "is_modal_public_url",
+    "load_demo_dir",
+    "load_template_id",
+    "load_user_config",
+    "load_user_env",
+    "mask_str",
+    "normalize_endpoint_url",
+    "now_iso",
+    "persist_api_key",
+    "persist_demo_dir",
+    "persist_env_api_key",
+    "persist_task_url",
+    "persist_template_id",
+    "popen_capture",
+    "popen_stream",
+    "popen_stream_capture",
+    "preflight_env_key",
+    "print_next_step",
+    "read_task_app_config",
+    "record_task_app",
+    "resolve_env_var",
+    "resolve_task_app_entry",
+    "save_user_config",
+    "select_app_choice",
+    "task_app_config_path",
+    "task_app_id_from_path",
+    "task_app_state",
+    "update_task_app_entry",
+    "update_user_config",
+    "write_env_var_to_dotenv",
+    "write_env_var_to_json",
+    "write_task_app_config",
+]

synth_ai/utils/base_url.py

@@ -0,0 +1,94 @@
+"""
+Base URL resolution for learning-v2 and related backend APIs.
+
+Default to production, allow overrides via environment variables:
+- LEARNING_V2_BASE_URL (highest precedence)
+- SYNTH_BASE_URL (legacy)
+- SYNTH_LOCAL_BASE_URL
+- SYNTH_DEV_BASE_URL
+- SYNTH_PROD_BASE_URL (fallback if none provided)
+
+Normalization: ensure the returned URL ends with "/api".
+"""
+
+import os
+from typing import Literal
+
+PROD_BASE_URL_DEFAULT = "https://agent-learning.onrender.com"
+
+
+def _normalize_base(url: str) -> str:
+    url = url.strip()
+    if url.endswith("/v1"):
+        url = url[:-3]
+    url = url.rstrip("/")
+    if not url.endswith("/api"):
+        url = f"{url}/api"
+    return url
+
+
+def get_learning_v2_base_url(mode: Literal["dev", "prod"] = "prod") -> str:
+    if mode == "prod":
+        prod = os.getenv("SYNTH_PROD_BASE_URL") or PROD_BASE_URL_DEFAULT
+        return _normalize_base(prod)
+    env_url = os.getenv("LEARNING_V2_BASE_URL")
+    if env_url:
+        return _normalize_base(env_url)
+
+    legacy = os.getenv("SYNTH_BASE_URL")
+    if legacy:
+        return _normalize_base(legacy)
+
+    local = os.getenv("SYNTH_LOCAL_BASE_URL")
+    if local:
+        return _normalize_base(local)
+
+    dev = os.getenv("SYNTH_DEV_BASE_URL")
+    if dev:
+        return _normalize_base(dev)
+
+    raise ValueError("No base URL configured. Set one of: LEARNING_V2_BASE_URL, SYNTH_BASE_URL, SYNTH_LOCAL_BASE_URL, SYNTH_DEV_BASE_URL")
+
+
+def _resolve_override_mode() -> str:
+    ov = (os.getenv("SYNTH_BACKEND_URL_OVERRIDE", "") or "").strip().lower()
+    if ov in {"local", "dev", "prod"}:
+        return ov
+    return "prod"
+
+
+def get_backend_from_env() -> tuple[str, str]:
+    direct_override = (os.getenv("BACKEND_OVERRIDE") or "").strip()
+    if direct_override:
+        base = direct_override.rstrip("/")
+        if base.endswith("/api"):
+            base = base[: -len("/api")]
+        api_key = os.getenv("SYNTH_API_KEY", "").strip()
+        return base, api_key
+
+    mode = _resolve_override_mode()
+    if mode == "local":
+        base = os.getenv("LOCAL_BACKEND_URL", "http://localhost:8000")
+        key = os.getenv("TESTING_LOCAL_SYNTH_API_KEY", "")
+        return base.rstrip("/"), key
+    if mode == "dev":
+        base = os.getenv("DEV_BACKEND_URL", "") or "http://localhost:8000"
+        key = os.getenv("DEV_SYNTH_API_KEY", "")
+        return base.rstrip("/"), key
+    base = os.getenv("PROD_BACKEND_URL", f"{PROD_BASE_URL_DEFAULT}")
+    base = base.rstrip("/")
+    if base.endswith("/api"):
+        base = base[: -len("/api")]
+    key = (
+        os.getenv("PROD_SYNTH_API_KEY", "")
+        or os.getenv("TESTING_PROD_SYNTH_API_KEY", "")
+        or os.getenv("SYNTH_API_KEY", "")
+    )
+    return base, key
+
+
+__all__ = [
+    "PROD_BASE_URL_DEFAULT",
+    "get_backend_from_env",
+    "get_learning_v2_base_url",
+]