synth-ai 0.2.2.dev0__py3-none-any.whl → 0.2.3__py3-none-any.whl

synth_ai/lm/vendors/openai_standard_responses.py

@@ -0,0 +1,243 @@
+"""
+OpenAI Responses API extensions for OpenAIStandard vendor.
+
+This module contains the Responses API and Harmony encoding methods
+that extend the OpenAIStandard class functionality.
+"""
+
+from typing import Any, Dict, List, Optional
+import uuid
+from pydantic import BaseModel
+
+from synth_ai.lm.tools.base import BaseTool
+from synth_ai.lm.vendors.base import BaseLMResponse
+from synth_ai.lm.vendors.retries import MAX_BACKOFF
+import backoff
+
+
+def _silent_backoff_handler(_details):
+    """No-op handler to keep stdout clean while still allowing visibility via logging if desired."""
+    pass
+
+
+DEFAULT_EXCEPTIONS_TO_RETRY = (
+    Exception,  # Will be more specific when imported
+)
+
+
+class OpenAIResponsesAPIMixin:
+    """Mixin class providing Responses API functionality for OpenAI vendors."""
+    
+    async def _hit_api_async_responses(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        lm_config: Dict[str, Any],
+        previous_response_id: Optional[str] = None,
+        use_ephemeral_cache_only: bool = False,
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
+        """Use OpenAI Responses API for supported models."""
+        
+        print(f"🔍 RESPONSES API: Called for model {model}")
+        print(f"🔍 RESPONSES API: previous_response_id = {previous_response_id}")
+        
+        # Check if the client has responses attribute
+        if not hasattr(self.async_client, 'responses'):
+            print("🔍 RESPONSES API: Client doesn't have responses attribute, using fallback")
+            # Fallback - use chat completions with simulated response_id
+            response = await self._hit_api_async(
+                model=model,
+                messages=messages,
+                lm_config=lm_config,
+                use_ephemeral_cache_only=use_ephemeral_cache_only,
+                tools=tools,
+            )
+            
+            # Add Responses API fields
+            if not response.response_id:
+                import uuid
+                response.response_id = str(uuid.uuid4())
+            response.api_type = "responses"
+            return response
+        
+        # Use the official Responses API
+        try:
+            # Common API call params for Responses API
+            api_params = {
+                "model": model,
+            }
+            
+            # For Responses API, we use 'input' parameter
+            if previous_response_id:
+                # Continue existing thread
+                api_params["previous_response_id"] = previous_response_id
+                # Only pass the new user input
+                if messages and len(messages) > 0:
+                    # Get the last user message content
+                    last_message = messages[-1]
+                    api_params["input"] = last_message.get("content", "")
+            else:
+                # Start new thread - combine system and user messages into input
+                if messages and len(messages) > 0:
+                    # Combine messages into a single input string
+                    input_parts = []
+                    for msg in messages:
+                        role = msg.get("role", "")
+                        content = msg.get("content", "")
+                        if role == "system":
+                            input_parts.append(f"System: {content}")
+                        elif role == "user":
+                            input_parts.append(f"User: {content}")
+                        elif role == "assistant":
+                            input_parts.append(f"Assistant: {content}")
+                    api_params["input"] = "\n".join(input_parts)
+            
+            # Add tools if provided
+            if tools and all(isinstance(tool, BaseTool) for tool in tools):
+                api_params["tools"] = [tool.to_openai_tool() for tool in tools]
+            elif tools:
+                api_params["tools"] = tools
+            
+            # Add other parameters from lm_config if needed
+            if "max_tokens" in lm_config:
+                api_params["max_tokens"] = lm_config["max_tokens"]
+            
+            print(f"🔍 RESPONSES API: Calling with params: {list(api_params.keys())}")
+            
+            # Call the Responses API
+            response = await self.async_client.responses.create(**api_params)
+            
+            print(f"🔍 RESPONSES API: Response received, type: {type(response)}")
+            
+            # Extract fields from response
+            output_text = getattr(response, 'output_text', getattr(response, 'content', ''))
+            reasoning_obj = getattr(response, 'reasoning', None)
+            response_id = getattr(response, 'id', None)
+            
+            # Debug reasoning type (only first time)
+            if reasoning_obj and not hasattr(self, '_reasoning_logged'):
+                print(f"🔍 RESPONSES API: Reasoning type: {type(reasoning_obj)}")
+                print(f"🔍 RESPONSES API: Reasoning attributes: {[x for x in dir(reasoning_obj) if not x.startswith('_')]}")
+                self._reasoning_logged = True
+            
+            # Handle reasoning - it might be an object or a string
+            reasoning = None
+            if reasoning_obj:
+                if isinstance(reasoning_obj, str):
+                    # Synth backend returns full reasoning as string
+                    reasoning = reasoning_obj
+                else:
+                    # OpenAI returns a Reasoning object
+                    # Try to get summary first, but preserve entire object if no summary
+                    if hasattr(reasoning_obj, 'summary') and reasoning_obj.summary:
+                        reasoning = reasoning_obj.summary
+                    else:
+                        # Preserve the full object structure as JSON
+                        # This includes effort level and any other fields
+                        if hasattr(reasoning_obj, 'model_dump_json'):
+                            reasoning = reasoning_obj.model_dump_json()
+                        elif hasattr(reasoning_obj, 'to_dict'):
+                            import json
+                            reasoning = json.dumps(reasoning_obj.to_dict())
+                        else:
+                            reasoning = str(reasoning_obj)
+            
+            # Handle tool calls if present
+            tool_calls = None
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                tool_calls = [
+                    {
+                        "id": tc.id,
+                        "type": tc.type,
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": tc.function.arguments,
+                        },
+                    }
+                    for tc in response.tool_calls
+                ]
+            
+            print(f"🔍 RESPONSES API: Extracted response_id = {response_id}")
+            
+            return BaseLMResponse(
+                raw_response=output_text,
+                response_id=response_id,
+                reasoning=reasoning,
+                api_type="responses",
+                tool_calls=tool_calls,
+            )
+            
+        except (AttributeError, Exception) as e:
+            print(f"🔍 RESPONSES API: Error calling Responses API: {e}")
+            # No fallback - raise the error
+            raise
+
+    async def _hit_api_async_harmony(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        lm_config: Dict[str, Any],
+        previous_response_id: Optional[str] = None,
+        use_ephemeral_cache_only: bool = False,
+        tools: Optional[List[BaseTool]] = None,
+    ) -> BaseLMResponse:
+        """Use Harmony encoding for OSS-GPT models."""
+        if not self.harmony_available:
+            raise ImportError("openai-harmony package required for OSS-GPT models. Install with: pip install openai-harmony")
+        
+        from openai_harmony import Message, Role, Conversation
+        
+        # Convert messages to Harmony format
+        harmony_messages = []
+        for msg in messages:
+            role = Role.SYSTEM if msg["role"] == "system" else (
+                Role.USER if msg["role"] == "user" else Role.ASSISTANT
+            )
+            content = msg["content"]
+            # Handle multimodal content
+            if isinstance(content, list):
+                # Extract text content for now
+                text_parts = [part.get("text", "") for part in content if part.get("type") == "text"]
+                content = " ".join(text_parts)
+            harmony_messages.append(Message.from_role_and_content(role, content))
+        
+        conv = Conversation.from_messages(harmony_messages)
+        tokens = self.harmony_enc.render_conversation_for_completion(conv, Role.ASSISTANT)
+        
+        # For now, we'll need to integrate with Synth GPU endpoint
+        # This would require the actual endpoint to be configured
+        # Placeholder for actual Synth GPU call
+        import aiohttp
+        import os
+        
+        synth_gpu_endpoint = os.getenv("SYNTH_GPU_HARMONY_ENDPOINT")
+        if not synth_gpu_endpoint:
+            raise ValueError("SYNTH_GPU_HARMONY_ENDPOINT environment variable not set")
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{synth_gpu_endpoint}/v1/completions",
+                json={
+                    "model": model,
+                    "prompt": tokens,
+                    "max_tokens": lm_config.get("max_tokens", 4096),
+                    "temperature": lm_config.get("temperature", 0.8),
+                }
+            ) as resp:
+                result = await resp.json()
+        
+        # Parse response using Harmony
+        response_tokens = result.get("choices", [{}])[0].get("text", "")
+        parsed = self.harmony_enc.parse_messages_from_completion_tokens(response_tokens, Role.ASSISTANT)
+        
+        if parsed:
+            assistant_msg = parsed[-1].content_text() if hasattr(parsed[-1], 'content_text') else str(parsed[-1])
+        else:
+            assistant_msg = response_tokens
+        
+        return BaseLMResponse(
+            raw_response=assistant_msg,
+            response_id=previous_response_id or str(uuid.uuid4()),
+            api_type="harmony",
+        )

synth_ai/lm/vendors/synth_client.py

@@ -47,6 +47,73 @@ class AsyncSynthClient:
                 },
             )
 
+    async def responses_create(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        previous_response_id: Optional[str] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = "auto",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Create response using Synth Responses API.
+        
+        Args:
+            model: Model identifier
+            messages: List of message dicts with 'role' and 'content'
+            previous_response_id: Optional ID of previous response for thread management
+            tools: List of available tools
+            tool_choice: How to choose tools
+            **kwargs: Additional parameters
+            
+        Returns:
+            Responses API-compatible response dict
+        """
+        await self._ensure_client()
+        
+        # Build payload for Responses API
+        payload = {
+            "model": model,
+            "messages": messages,
+        }
+        
+        # Add optional parameters
+        if previous_response_id is not None:
+            payload["previous_response_id"] = previous_response_id
+        if tools is not None:
+            payload["tools"] = tools
+            payload["tool_choice"] = tool_choice
+            
+        # Add any additional kwargs
+        payload.update(kwargs)
+        
+        # Retry logic
+        for attempt in range(self.config.max_retries):
+            try:
+                url = f"{self.config.get_base_url_without_v1()}/v1/responses"
+                response = await self._client.post(url, json=payload)
+                
+                if response.status_code == 200:
+                    return response.json()
+                    
+                # Handle rate limits with exponential backoff
+                if response.status_code == 429:
+                    wait_time = 2**attempt
+                    await asyncio.sleep(wait_time)
+                    continue
+                    
+                # Other errors
+                response.raise_for_status()
+                
+            except Exception as e:
+                if attempt == self.config.max_retries - 1:
+                    logger.error(f"Failed after {self.config.max_retries} attempts: {e}")
+                    raise
+                await asyncio.sleep(2**attempt)
+                
+        raise Exception(f"Failed to create response after {self.config.max_retries} attempts")
+
     async def chat_completions_create(
         self,
         model: str,
@@ -118,12 +185,32 @@ class AsyncSynthClient:
         # Retry logic
         for attempt in range(self.config.max_retries):
             try:
-                response = await self._client.post(
-                    f"{self.config.get_base_url_without_v1()}/v1/chat/completions", json=payload
-                )
-
+                url = f"{self.config.get_base_url_without_v1()}/v1/chat/completions"
+                print(f"🔍 SYNTH DEBUG: Making request to URL: {url}")
+                print(f"🔍 SYNTH DEBUG: Payload keys: {list(payload.keys())}")
+                if 'tools' in payload:
+                    print(f"🔍 SYNTH DEBUG: Tools in payload: {len(payload['tools'])} tools")
+                    print(f"🔍 SYNTH DEBUG: First tool: {json.dumps(payload['tools'][0], indent=2)}")
+                
+                response = await self._client.post(url, json=payload)
+                
+                print(f"🔍 SYNTH DEBUG: Response status: {response.status_code}")
+                
                 if response.status_code == 200:
-                    return response.json()
+                    result = response.json()
+                    print(f"🔍 SYNTH DEBUG: Response keys: {list(result.keys())}")
+                    if 'choices' in result and result['choices']:
+                        choice = result['choices'][0]
+                        print(f"🔍 SYNTH DEBUG: Choice keys: {list(choice.keys())}")
+                        if 'message' in choice:
+                            message = choice['message']
+                            print(f"🔍 SYNTH DEBUG: Message keys: {list(message.keys())}")
+                            if 'tool_calls' in message:
+                                print(f"🔍 SYNTH DEBUG: Tool calls: {message['tool_calls']}")
+                            else:
+                                print(f"🔍 SYNTH DEBUG: No tool_calls in message")
+                                print(f"🔍 SYNTH DEBUG: Message content: {message.get('content', 'N/A')[:200]}...")
+                    return result
 
                 # Handle rate limits with exponential backoff
                 if response.status_code == 429:
@@ -191,6 +278,69 @@ class SyncSynthClient:
                 },
             )
 
+    def responses_create(
+        self,
+        model: str,
+        messages: List[Dict[str, Any]],
+        previous_response_id: Optional[str] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = "auto",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Create response using Synth Responses API (sync version).
+        
+        See AsyncSynthClient.responses_create for full parameter documentation.
+        """
+        self._ensure_client()
+        
+        # Build payload for Responses API
+        payload = {
+            "model": model,
+            "messages": messages,
+        }
+        
+        # Add optional parameters
+        if previous_response_id is not None:
+            payload["previous_response_id"] = previous_response_id
+        if tools is not None:
+            payload["tools"] = tools
+            payload["tool_choice"] = tool_choice
+            
+        # Add any additional kwargs
+        payload.update(kwargs)
+        
+        # Retry logic
+        for attempt in range(self.config.max_retries):
+            try:
+                response = self._client.post(
+                    f"{self.config.get_base_url_without_v1()}/v1/responses", json=payload
+                )
+                
+                if response.status_code == 200:
+                    return response.json()
+                    
+                # Handle rate limits
+                if response.status_code == 429:
+                    wait_time = 2**attempt
+                    logger.warning(f"Rate limited, waiting {wait_time}s...")
+                    import time
+                    time.sleep(wait_time)
+                    continue
+                    
+                # Other errors
+                error_msg = f"API error {response.status_code}: {response.text}"
+                logger.error(error_msg)
+                raise Exception(error_msg)
+                
+            except httpx.TimeoutException:
+                if attempt < self.config.max_retries - 1:
+                    logger.warning(f"Timeout on attempt {attempt + 1}, retrying...")
+                    continue
+                raise
+                
+        raise Exception(f"Failed after {self.config.max_retries} attempts")
+
     def chat_completions_create(
         self, model: str, messages: List[Dict[str, Any]], **kwargs
     ) -> Dict[str, Any]:

synth_ai/lm/warmup.py

@@ -6,6 +6,8 @@ Handles model preloading and warmup polling.
 import httpx
 import asyncio
 import logging
+import sys
+import time
 from typing import Optional, Dict, Any
 from datetime import datetime, timedelta
 from .config import SynthConfig
@@ -46,9 +48,10 @@ _warmup_status = WarmupStatus()
 async def warmup_synth_model(
     model_name: str,
     config: Optional[SynthConfig] = None,
-    max_attempts: int = 30,
+    max_attempts: Optional[int] = None,
     force: bool = False,
     verbose: bool = True,
+    gpu_preference: Optional[str] = None,
 ) -> bool:
     """
     Warm up a model on the Synth backend using fire-and-forget approach.
@@ -73,6 +76,8 @@ async def warmup_synth_model(
 
     async with httpx.AsyncClient() as client:
         headers = {"Authorization": f"Bearer {config.api_key}"}
+        if gpu_preference:
+            headers["X-GPU-Preference"] = gpu_preference
 
         # Step 1: Start warmup (fire and forget)
         try:
@@ -84,8 +89,11 @@ async def warmup_synth_model(
 
             if response.status_code == 200:
                 response_data = response.json()
-                if response_data.get("status") in ["warming", "already_warming", "already_warmed"]:
+                if response_data.get("status") in ["warming", "already_warming"]:
                     pass
+                elif response_data.get("status") == "already_warmed":
+                    _warmup_status.mark_warm(model_name)
+                    return True
                 else:
                     logger.warning(f"Unexpected warmup response: {response_data}")
             else:
@@ -98,8 +106,13 @@ async def warmup_synth_model(
             logger.warning(f"Warmup start failed: {e}")
             return False
 
-        # Step 2: Poll status until ready
-        for attempt in range(max_attempts):
+        # Step 2: Poll status until ready (indefinite by default)
+        spinner = "|/-\\"
+        spin_idx = 0
+        start_time = time.time()
+        attempt = 0
+        while True:
+            attempt += 1
             try:
                 response = await client.get(
                     f"{config.get_base_url_without_v1()}/warmup/status/{model_name}",
@@ -113,34 +126,58 @@ async def warmup_synth_model(
 
                     if status == "warmed":
                         _warmup_status.mark_warm(model_name)
+                        # Final spinner line as success
+                        elapsed = int(time.time() - start_time)
+                        sys.stdout.write(f"\r✅ Warmed {model_name} in {elapsed}s        \n")
+                        sys.stdout.flush()
                         return True
                     elif status == "failed":
                         error = status_data.get("error", "Unknown error")
                         logger.error(f"❌ Warmup failed for {model_name}: {error}")
+                        sys.stdout.write(f"\r❌ Warmup failed: {error}            \n")
+                        sys.stdout.flush()
                         return False
-                    elif status == "warming":
-                        # Still warming up, continue polling
-                        pass
-                    elif status == "not_started":
-                        # Warmup hasn't started yet, continue polling
-                        pass
                     else:
-                        logger.warning(f"Unknown warmup status: {status}")
+                        # Treat unknown statuses (e.g., "cold") as still warming
+                        elapsed = int(time.time() - start_time)
+                        wheel = spinner[spin_idx % len(spinner)]
+                        spin_idx += 1
+                        label = status or "pending"
+                        sys.stdout.write(
+                            f"\r⏳ Warming {model_name} [{wheel}] status={label} elapsed={elapsed}s"
+                        )
+                        sys.stdout.flush()
 
                 # Short sleep between status checks
                 await asyncio.sleep(2.0)
 
             except httpx.TimeoutException:
-                if verbose:
-                    logger.warning(f"Status check {attempt + 1} timed out")
+                # Continue polling; update spinner line
+                elapsed = int(time.time() - start_time)
+                wheel = spinner[spin_idx % len(spinner)]
+                spin_idx += 1
+                sys.stdout.write(
+                    f"\r⏳ Warming {model_name} [{wheel}] status=timeout elapsed={elapsed}s"
+                )
+                sys.stdout.flush()
                 await asyncio.sleep(1.0)
             except Exception as e:
-                if verbose:
-                    logger.warning(f"Status check {attempt + 1} failed: {e}")
+                # Continue polling; update spinner line with error label
+                elapsed = int(time.time() - start_time)
+                wheel = spinner[spin_idx % len(spinner)]
+                spin_idx += 1
+                sys.stdout.write(
+                    f"\r⏳ Warming {model_name} [{wheel}] status=error elapsed={elapsed}s"
+                )
+                sys.stdout.flush()
                 await asyncio.sleep(1.0)
 
-        logger.error(f"Failed to warm up {model_name} after {max_attempts} status checks")
-        return False
+            # Optional max_attempts for callers who want a cap
+            if max_attempts is not None and attempt >= max_attempts:
+                logger.error(f"Failed to warm up {model_name} after {max_attempts} status checks")
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+                return False
 
 
 def get_warmup_status() -> WarmupStatus:

synth_ai/tracing/__init__.py

@@ -0,0 +1,18 @@
+import sys as _sys
+import importlib as _importlib
+
+_pkg = _importlib.import_module('synth_ai.v0.tracing')
+_sys.modules[__name__] = _pkg
+
+_SUBMODULES = [
+    'abstractions', 'base_client', 'client_manager', 'config', 'context',
+    'decorators', 'immediate_client', 'local', 'log_client_base', 'retry_queue',
+    'trackers', 'upload', 'utils'
+]
+for _m in _SUBMODULES:
+    _sys.modules[f'{__name__}.{_m}'] = _importlib.import_module(f'synth_ai.v0.tracing.{_m}')
+
+_events_pkg = _importlib.import_module('synth_ai.v0.tracing.events')
+_sys.modules[f'{__name__}.events'] = _events_pkg
+for _m in ['manage', 'scope', 'store']:
+    _sys.modules[f'{__name__}.events.{_m}'] = _importlib.import_module(f'synth_ai.v0.tracing.events.{_m}')

synth_ai/tracing_v1/__init__.py

@@ -1,16 +1,31 @@
-import warnings
+import sys as _sys
+import importlib as _importlib
 
-# Issue deprecation warning when this module is imported
-warnings.warn(
-    "synth_ai.tracing (now tracing_v1) is deprecated. "
-    "Please use synth_ai.tracing_v2 instead. "
-    "Backend upload functionality is no longer supported in v1.",
-    DeprecationWarning,
-    stacklevel=2,
-)
+# Forward top-level package
+_pkg = _importlib.import_module('synth_ai.v0.tracing_v1')
+_sys.modules[__name__] = _pkg
 
-# Re-export the main components with deprecation warnings
-from .config import *
-from .decorators import *
-from .trackers import *
-from .abstractions import *
+# Explicitly forward submodules so `synth_ai.tracing_v1.X` works
+_SUBMODULES = [
+    'abstractions',
+    'base_client',
+    'client_manager',
+    'config',
+    'context',
+    'decorators',
+    'immediate_client',
+    'local',
+    'log_client_base',
+    'retry_queue',
+    'trackers',
+    'upload',
+    'utils',
+]
+for _m in _SUBMODULES:
+    _sys.modules[f'{__name__}.{_m}'] = _importlib.import_module(f'synth_ai.v0.tracing_v1.{_m}')
+
+# Forward events package and its submodules
+_events_pkg = _importlib.import_module('synth_ai.v0.tracing_v1.events')
+_sys.modules[f'{__name__}.events'] = _events_pkg
+for _m in ['manage', 'scope', 'store']:
+    _sys.modules[f'{__name__}.events.{_m}'] = _importlib.import_module(f'synth_ai.v0.tracing_v1.events.{_m}')

synth_ai/tracing_v3/config.py

@@ -9,15 +9,21 @@ class TursoConfig:
     """Configuration for Turso/sqld connection."""
 
     # Default values matching serve.sh
-    DEFAULT_DB_FILE = "synth_ai.db"
+    DEFAULT_DB_FILE = "traces/v3/synth_ai.db"
     DEFAULT_HTTP_PORT = 8080
 
     # Local embedded database for async SQLAlchemy
-    # Use the centralized configuration for the database URL
-    db_url: str = os.getenv(
-        "TURSO_LOCAL_DB_URL",
-        f"sqlite+aiosqlite:///{os.path.abspath(os.getenv('SQLD_DB_PATH', 'synth_ai.db'))}",
-    )
+    # Resolve to the actual SQLite file used by sqld if the base path is a directory
+    def _resolve_sqlite_db_url() -> str:  # type: ignore[no-redef]
+        base_path = os.path.abspath(os.getenv("SQLD_DB_PATH", "traces/v3/synth_ai.db"))
+        # If sqld is managing this DB, the real SQLite file lives under dbs/default/data
+        candidate = os.path.join(base_path, "dbs", "default", "data")
+        if os.path.isdir(base_path) and os.path.exists(candidate):
+            return f"sqlite+aiosqlite:///{candidate}"
+        return f"sqlite+aiosqlite:///{base_path}"
+
+    # Use env override if provided; otherwise resolve based on SQLD layout
+    db_url: str = os.getenv("TURSO_LOCAL_DB_URL", _resolve_sqlite_db_url())
 
     # Remote database sync configuration
     sync_url: str = os.getenv("TURSO_DATABASE_URL", "")
@@ -40,7 +46,7 @@ class TursoConfig:
 
     # Daemon settings (for local sqld) - match serve.sh defaults
     sqld_binary: str = os.getenv("SQLD_BINARY", "sqld")
-    sqld_db_path: str = os.getenv("SQLD_DB_PATH", "synth_ai.db")
+    sqld_db_path: str = os.getenv("SQLD_DB_PATH", "traces/v3/synth_ai.db")
     sqld_http_port: int = int(os.getenv("SQLD_HTTP_PORT", "8080"))
     sqld_idle_shutdown: int = int(os.getenv("SQLD_IDLE_SHUTDOWN", "0"))  # 0 = no idle shutdown