dtSpark 1.1.0a2__py3-none-any.whl → 1.1.0a6__py3-none-any.whl

dtSpark/web/endpoints/conversations.py

@@ -10,9 +10,11 @@ Provides REST API for conversation operations:
 
 """
 
+import asyncio
 import logging
 import tempfile
 import os
+from pathlib import Path
 from typing import Optional, List
 from datetime import datetime
 
@@ -37,7 +39,7 @@ def parse_datetime(dt_value):
         # SQLite returns timestamps as strings
         try:
             return datetime.fromisoformat(dt_value.replace('Z', '+00:00'))
-        except:
+        except (ValueError, TypeError):
             return datetime.strptime(dt_value, '%Y-%m-%d %H:%M:%S.%f')
     return None
 
@@ -179,6 +181,14 @@ async def create_conversation(
         database = app_instance.database
         conversation_manager = app_instance.conversation_manager
 
+        # Enforce mandatory model if configured
+        mandatory_model = getattr(app_instance, 'configured_model_id', None)
+        mandatory_provider = getattr(app_instance, 'configured_provider', None)
+        if mandatory_model:
+            model_id = mandatory_model
+            logger.info(f"Mandatory model enforced: {model_id}"
+                        f"{f' via {mandatory_provider}' if mandatory_provider else ''}")
+
         # Create conversation in database
         conversation_id = database.create_conversation(
             name=name,
@@ -190,7 +200,7 @@ async def create_conversation(
         conversation_manager.load_conversation(conversation_id)
 
         # Set the model from the conversation and update service references
-        app_instance.llm_manager.set_model(model_id)
+        app_instance.llm_manager.set_model(model_id, mandatory_provider)
         app_instance.bedrock_service = app_instance.llm_manager.get_active_service()
         conversation_manager.update_service(app_instance.bedrock_service)
 
@@ -212,7 +222,7 @@ async def create_conversation(
                     suffix = os.path.splitext(upload_file.filename)[1]
                     if not suffix:
                         upload_errors.append(f"File '{upload_file.filename}' has no file extension")
-                        logger.warning(f"File '{upload_file.filename}' uploaded without extension")
+                        logger.warning("File uploaded without extension")
                         continue
 
                     # Check if extension is supported (using FileManager's validation)
@@ -222,19 +232,19 @@ async def create_conversation(
                                              FileManager.SUPPORTED_DOCUMENT_FILES |
                                              FileManager.SUPPORTED_IMAGE_FILES):
                         upload_errors.append(f"File type '{suffix}' is not supported for '{upload_file.filename}'")
-                        logger.warning(f"Unsupported file type '{suffix}' for file '{upload_file.filename}'")
+                        logger.warning("Unsupported file type uploaded")
                         continue
 
                     # Create temporary file with proper extension
                     temp_fd, temp_path = tempfile.mkstemp(suffix=suffix)
+                    os.close(temp_fd)
 
-                    # Write uploaded content to temp file
-                    with os.fdopen(temp_fd, 'wb') as f:
-                        content = await upload_file.read()
-                        f.write(content)
+                    # Write uploaded content to temp file asynchronously
+                    content = await upload_file.read()
+                    await asyncio.to_thread(Path(temp_path).write_bytes, content)
 
                     temp_files.append(temp_path)
-                    logger.info(f"Saved uploaded file {upload_file.filename} to {temp_path}")
+                    logger.info("Saved uploaded file to %s", temp_path)
 
                 # Attach files using conversation manager
                 if temp_files:
@@ -257,7 +267,7 @@ async def create_conversation(
                     try:
                         if os.path.exists(temp_path):
                             os.unlink(temp_path)
-                    except:
+                    except OSError:
                         pass
 
         # Get the created conversation details
@@ -325,29 +335,59 @@ async def delete_conversation(
 async def list_models(
     request: Request,
     session_id: str = Depends(get_current_session),
-) -> List[dict]:
+) -> dict:
     """
-    Get available models.
+    Get available models and mandatory model configuration.
 
     Returns:
-        List of available models with their IDs and names
+        Dictionary with models list and mandatory model info
     """
     try:
         app_instance = request.app.state.app_instance
 
+        mandatory_model = getattr(app_instance, 'configured_model_id', None)
+        mandatory_provider = getattr(app_instance, 'configured_provider', None)
+
         # Get available models from LLM manager
-        models = app_instance.llm_manager.list_all_models()
+        all_models = app_instance.llm_manager.list_all_models()
 
-        return [
+        models = [
             {
                 "id": model.get('id', model.get('name', 'unknown')),
                 "name": model.get('name', 'Unknown'),
                 "provider": model.get('provider', 'Unknown'),
-                "model_maker": model.get('model_maker'),  # Optional: model creator (for Bedrock models)
+                "model_maker": model.get('model_maker'),
             }
-            for model in models
+            for model in all_models
         ]
 
+        # If mandatory model is set, filter to matching models only
+        if mandatory_model:
+            filtered = [
+                m for m in models
+                if m['id'] == mandatory_model
+                or m['name'] == mandatory_model
+            ]
+
+            # Further filter by provider if mandatory_provider is set
+            if mandatory_provider and filtered:
+                provider_filtered = [
+                    m for m in filtered
+                    if m['provider'] == mandatory_provider
+                ]
+                if provider_filtered:
+                    filtered = provider_filtered
+
+            if filtered:
+                models = filtered
+
+        return {
+            "models": models,
+            "mandatory_model": mandatory_model,
+            "mandatory_provider": mandatory_provider,
+            "model_locked": mandatory_model is not None,
+        }
+
     except Exception as e:
         logger.error(f"Error listing models: {e}")
         raise HTTPException(status_code=500, detail=str(e))

dtSpark/web/endpoints/main_menu.py

@@ -80,50 +80,17 @@ async def get_account_info(
     """
     try:
         app_instance = request.app.state.app_instance
-
-        # Get LLM manager to determine active provider
         llm_manager = getattr(app_instance, 'llm_manager', None)
         user_guid = getattr(app_instance, 'user_guid', 'unknown')
 
         if llm_manager and llm_manager.active_provider:
-            active_provider = llm_manager.active_provider.lower()
-
-            # AWS Bedrock
-            if 'bedrock' in active_provider or 'aws' in active_provider:
-                auth = getattr(app_instance, 'authenticator', None)
-                if auth:
-                    account_info = auth.get_account_info()
-                    if account_info:
-                        return AccountInfo(
-                            provider='aws',
-                            user_arn=account_info.get('user_arn'),
-                            account_id=account_info.get('account_id'),
-                            region=account_info.get('region'),
-                            user_guid=user_guid,
-                            auth_method=account_info.get('auth_method'),
-                        )
-
-            # Anthropic
-            elif 'anthropic' in active_provider:
-                return AccountInfo(
-                    provider='anthropic',
-                    user_guid=user_guid,
-                    auth_method='api_key',
-                )
-
-            # Ollama
-            elif 'ollama' in active_provider:
-                return AccountInfo(
-                    provider='ollama',
-                    user_guid=user_guid,
-                    auth_method='local',
-                )
+            result = _build_account_info_for_provider(
+                app_instance, llm_manager.active_provider.lower(), user_guid
+            )
+            if result:
+                return result
 
-        # No provider configured - return basic info
-        return AccountInfo(
-            provider='none',
-            user_guid=user_guid,
-        )
+        return AccountInfo(provider='none', user_guid=user_guid)
 
     except HTTPException:
         raise
@@ -132,6 +99,40 @@ async def get_account_info(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+def _build_account_info_for_provider(
+    app_instance, active_provider: str, user_guid: str
+) -> Optional[AccountInfo]:
+    """Build AccountInfo for the given active provider, or return None if unavailable."""
+    if 'bedrock' in active_provider or 'aws' in active_provider:
+        return _build_aws_account_info(app_instance, user_guid)
+
+    if 'anthropic' in active_provider:
+        return AccountInfo(provider='anthropic', user_guid=user_guid, auth_method='api_key')
+
+    if 'ollama' in active_provider:
+        return AccountInfo(provider='ollama', user_guid=user_guid, auth_method='local')
+
+    return None
+
+
+def _build_aws_account_info(app_instance, user_guid: str) -> Optional[AccountInfo]:
+    """Build AccountInfo from the AWS authenticator, or return None."""
+    auth = getattr(app_instance, 'authenticator', None)
+    if not auth:
+        return None
+    account_info = auth.get_account_info()
+    if not account_info:
+        return None
+    return AccountInfo(
+        provider='aws',
+        user_arn=account_info.get('user_arn'),
+        account_id=account_info.get('account_id'),
+        region=account_info.get('region'),
+        user_guid=user_guid,
+        auth_method=account_info.get('auth_method'),
+    )
+
+
 @router.get("/providers")
 async def get_providers(
     request: Request,
@@ -147,71 +148,11 @@ async def get_providers(
         app_instance = request.app.state.app_instance
         providers = []
 
-        # Get LLM manager which has all registered providers
         llm_manager = getattr(app_instance, 'llm_manager', None)
-
         if llm_manager and hasattr(llm_manager, 'providers'):
             for provider_name, service in llm_manager.providers.items():
-                models = []
-                status = 'connected'
-                provider_type = 'unknown'
-                auth_method = None
-                region = None
-                base_url = None
-
-                # Determine provider type
-                provider_name_lower = provider_name.lower()
-                if 'bedrock' in provider_name_lower or 'aws' in provider_name_lower:
-                    provider_type = 'aws'
-                    auth = getattr(app_instance, 'authenticator', None)
-                    if auth:
-                        account_info = auth.get_account_info()
-                        if account_info:
-                            auth_method = account_info.get('auth_method')
-                            region = account_info.get('region')
-                elif 'anthropic' in provider_name_lower:
-                    provider_type = 'anthropic'
-                    auth_method = 'api_key'
-                elif 'ollama' in provider_name_lower:
-                    provider_type = 'ollama'
-                    auth_method = 'local'
-                    base_url = getattr(service, 'base_url', 'http://localhost:11434')
-
-                # Get available models
-                try:
-                    if hasattr(service, 'list_available_models'):
-                        available_models = service.list_available_models()
-                    elif hasattr(service, 'list_models'):
-                        available_models = service.list_models()
-                    else:
-                        available_models = []
-
-                    for model in available_models:
-                        if isinstance(model, dict):
-                            model_id = model.get('id') or model.get('modelId') or model.get('name') or str(model)
-                            display_name = model.get('display_name') or model.get('modelName') or model_id
-                        else:
-                            model_id = str(model)
-                            display_name = model_id
-
-                        models.append(ProviderModelInfo(
-                            model_id=model_id,
-                            display_name=display_name,
-                        ))
-                except Exception as e:
-                    logger.warning(f"Failed to list models from {provider_name}: {e}")
-                    status = 'error'
-
-                providers.append(ProviderInfo(
-                    name=provider_name,
-                    type=provider_type,
-                    enabled=True,
-                    status=status,
-                    models=models,
-                    auth_method=auth_method,
-                    region=region,
-                    base_url=base_url,
-                ))
+                provider_info = _build_provider_info(app_instance, provider_name, service)
+                providers.append(provider_info)
 
         return providers
 
@@ -220,6 +161,88 @@ async def get_providers(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+def _build_provider_info(app_instance, provider_name: str, service) -> ProviderInfo:
+    """Build a ProviderInfo for a single registered provider."""
+    provider_type, auth_method, region, base_url = _detect_provider_type(
+        app_instance, provider_name, service
+    )
+
+    models, status = _list_provider_models(provider_name, service)
+
+    return ProviderInfo(
+        name=provider_name,
+        type=provider_type,
+        enabled=True,
+        status=status,
+        models=models,
+        auth_method=auth_method,
+        region=region,
+        base_url=base_url,
+    )
+
+
+def _detect_provider_type(app_instance, provider_name: str, service) -> tuple:
+    """Detect the provider type, auth method, region, and base URL from the provider name."""
+    provider_name_lower = provider_name.lower()
+    auth_method = None
+    region = None
+    base_url = None
+
+    if 'bedrock' in provider_name_lower or 'aws' in provider_name_lower:
+        provider_type = 'aws'
+        auth = getattr(app_instance, 'authenticator', None)
+        if auth:
+            account_info = auth.get_account_info()
+            if account_info:
+                auth_method = account_info.get('auth_method')
+                region = account_info.get('region')
+    elif 'anthropic' in provider_name_lower:
+        provider_type = 'anthropic'
+        auth_method = 'api_key'
+    elif 'ollama' in provider_name_lower:
+        provider_type = 'ollama'
+        auth_method = 'local'
+        base_url = getattr(service, 'base_url', 'http://localhost:11434')
+    else:
+        provider_type = 'unknown'
+
+    return provider_type, auth_method, region, base_url
+
+
+def _list_provider_models(provider_name: str, service) -> tuple:
+    """List available models from a provider service. Returns (models, status)."""
+    models = []
+    status = 'connected'
+
+    try:
+        if hasattr(service, 'list_available_models'):
+            available_models = service.list_available_models()
+        elif hasattr(service, 'list_models'):
+            available_models = service.list_models()
+        else:
+            available_models = []
+
+        for model in available_models:
+            models.append(_parse_model_info(model))
+    except Exception as e:
+        logger.warning(f"Failed to list models from {provider_name}: {e}")
+        status = 'error'
+
+    return models, status
+
+
+def _parse_model_info(model) -> ProviderModelInfo:
+    """Parse a model entry (dict or string) into a ProviderModelInfo."""
+    if isinstance(model, dict):
+        model_id = model.get('id') or model.get('modelId') or model.get('name') or str(model)
+        display_name = model.get('display_name') or model.get('modelName') or model_id
+    else:
+        model_id = str(model)
+        display_name = model_id
+
+    return ProviderModelInfo(model_id=model_id, display_name=display_name)
+
+
 @router.get("/costs/last-month")
 async def get_last_month_costs(
     request: Request,
@@ -607,14 +630,18 @@ async def get_daemon_status(request: Request):
         except Exception:
             pass
 
+        if not daemon_running and scheduled_count > 0:
+            warning_message = (
+                f"Daemon is not running - {scheduled_count} scheduled action(s) will not execute"
+            )
+        else:
+            warning_message = None
+
         return {
             'daemon_running': daemon_running,
             'daemon_pid': daemon_pid,
             'scheduled_actions_count': scheduled_count,
-            'warning': None if daemon_running else (
-                f"Daemon is not running - {scheduled_count} scheduled action(s) will not execute"
-                if scheduled_count > 0 else None
-            )
+            'warning': warning_message,
         }
 
     except Exception as e:

dtSpark/web/endpoints/streaming.py

@@ -151,7 +151,7 @@ class StreamingManager:
                                         "content": result.get('content', ''),
                                     }),
                                 }
-                        except:
+                        except ValueError:
                             pass
 
                     elif role == 'assistant' and content.strip().startswith('['):
@@ -179,7 +179,7 @@ class StreamingManager:
                                                 "input": block.get('input', {}),
                                             }),
                                         }
-                        except:
+                        except ValueError:
                             pass
 
                 last_message_count = len(current_messages)

dtSpark/web/server.py

@@ -9,6 +9,7 @@ import os
 import sys
 import socket
 import logging
+import time
 import webbrowser
 import signal
 import asyncio
@@ -252,6 +253,48 @@ def create_app(
             loop = asyncio.get_running_loop()
             loop.set_exception_handler(_suppress_connection_reset_errors)
 
+    # Set to hold references to background tasks (prevents garbage collection)
+    _background_tasks = set()
+
+    # Browser heartbeat state
+    app.state.last_heartbeat = 0.0
+
+    @app.post("/api/heartbeat")
+    async def heartbeat():
+        """Receive browser heartbeat ping."""
+        app.state.last_heartbeat = time.time()
+        return JSONResponse({"status": "ok"})
+
+    @app.on_event("startup")
+    async def start_heartbeat_monitor():
+        """Start background task to monitor browser heartbeat."""
+        if not heartbeat_enabled:
+            return
+
+        async def _monitor_heartbeat():
+            # Initial grace period - wait for browser to connect and send first heartbeat
+            grace_period = heartbeat_timeout * 2
+            logger.info(
+                f"Browser heartbeat monitor started (interval={heartbeat_interval}s, "
+                f"timeout={heartbeat_timeout}s, grace={grace_period}s)"
+            )
+            await asyncio.sleep(grace_period)
+
+            while True:
+                await asyncio.sleep(heartbeat_interval)
+                last = app.state.last_heartbeat
+                if last > 0 and (time.time() - last) > heartbeat_timeout:
+                    logger.info(
+                        f"No browser heartbeat for {heartbeat_timeout}s - "
+                        f"shutting down (browser likely closed)"
+                    )
+                    os.kill(os.getpid(), signal.SIGTERM)
+                    return
+
+        task = asyncio.create_task(_monitor_heartbeat())
+        _background_tasks.add(task)
+        task.add_done_callback(_background_tasks.discard)
+
     # Get template and static directories
     web_dir = Path(__file__).parent
     templates_dir = web_dir / "templates"
@@ -260,11 +303,24 @@ def create_app(
     # Setup templates
     templates = Jinja2Templates(directory=str(templates_dir))
 
+    # Determine feature flags from app instance
+    actions_enabled = getattr(app_instance, 'actions_enabled', False)
+
+    # Read heartbeat configuration
+    from dtPyAppFramework.settings import Settings as _Settings
+    _hb_settings = _Settings()
+    heartbeat_enabled = _hb_settings.get('interface.web.browser_heartbeat.enabled', True)
+    heartbeat_interval = _hb_settings.get('interface.web.browser_heartbeat.interval_seconds', 15)
+    heartbeat_timeout = _hb_settings.get('interface.web.browser_heartbeat.timeout_seconds', 60)
+
     # Add global template variables for app name and version
     templates.env.globals['app_name'] = full_name()
     templates.env.globals['app_version'] = version()
     templates.env.globals['app_description'] = description()
     templates.env.globals['agent_name'] = agent_name()
+    templates.env.globals['actions_enabled'] = actions_enabled
+    templates.env.globals['heartbeat_enabled'] = heartbeat_enabled
+    templates.env.globals['heartbeat_interval_ms'] = heartbeat_interval * 1000
 
     # Mount static files
     app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
@@ -428,13 +484,14 @@ def create_app(
         logger.info("Shutdown request received via API")
         # Send shutdown signal to the process
         # Use a background task to allow the response to be sent first
-        import asyncio
         async def shutdown_server():
             await asyncio.sleep(0.5)  # Give time for response to be sent
             logger.info("Shutting down web server...")
             os.kill(os.getpid(), signal.SIGTERM)
 
-        asyncio.create_task(shutdown_server())
+        task = asyncio.create_task(shutdown_server())
+        _background_tasks.add(task)
+        task.add_done_callback(_background_tasks.discard)
         return JSONResponse({"status": "shutdown initiated"})
 
     @app.get("/menu", response_class=HTMLResponse)
@@ -456,13 +513,14 @@ def create_app(
         chat_router,
         streaming_router,
     )
-    from .endpoints.autonomous_actions import router as autonomous_actions_router
-
     app.include_router(main_menu_router, prefix="/api", tags=["Main Menu"])
     app.include_router(conversations_router, prefix="/api", tags=["Conversations"])
     app.include_router(chat_router, prefix="/api", tags=["Chat"])
     app.include_router(streaming_router, prefix="/api", tags=["Streaming"])
-    app.include_router(autonomous_actions_router, prefix="/api", tags=["Autonomous Actions"])
+
+    if actions_enabled:
+        from .endpoints.autonomous_actions import router as autonomous_actions_router
+        app.include_router(autonomous_actions_router, prefix="/api", tags=["Autonomous Actions"])
 
     # Add template routes for conversations and chat
     @app.get("/conversations", response_class=HTMLResponse)
@@ -515,6 +573,8 @@ def create_app(
     @app.get("/actions", response_class=HTMLResponse)
     async def actions_page(request: Request, session_id: str = Depends(get_session)):
         """Display autonomous actions management page."""
+        if not actions_enabled:
+            return RedirectResponse(url="/menu", status_code=303)
         return templates.TemplateResponse(
             "actions.html",
             {

dtSpark/web/ssl_utils.py

@@ -10,7 +10,7 @@ import os.path
 import socket
 import ipaddress
 from pathlib import Path
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Tuple, Optional
 
 from dtPyAppFramework.paths import ApplicationPaths
@@ -72,8 +72,8 @@ def generate_self_signed_certificate(
             .issuer_name(issuer)
             .public_key(private_key.public_key())
             .serial_number(x509.random_serial_number())
-            .not_valid_before(datetime.utcnow())
-            .not_valid_after(datetime.utcnow() + timedelta(days=validity_days))
+            .not_valid_before(datetime.now(timezone.utc))
+            .not_valid_after(datetime.now(timezone.utc) + timedelta(days=validity_days))
             .add_extension(
                 x509.SubjectAlternativeName([
                     x509.DNSName(hostname),

dtSpark/web/static/css/dark-theme.css

@@ -94,7 +94,8 @@ body {
 }
 
 .chat-message .message-content pre {
-    background-color: rgba(0, 0, 0, 0.5);
+    background-color: #0d1117;
+    border: 1px solid #30363d;
     padding: 1rem;
     border-radius: 0.5rem;
     overflow-x: auto;
@@ -195,16 +196,19 @@ body {
 
 /* Code blocks in markdown */
 .markdown-content pre {
-    background-color: rgba(0, 0, 0, 0.5);
+    background-color: #0d1117;
+    border: 1px solid #30363d;
     padding: 1rem;
     border-radius: 0.5rem;
     overflow-x: auto;
+    margin: 1rem 0;
 }
 
 .markdown-content code {
-    background-color: rgba(0, 0, 0, 0.3);
+    background-color: rgba(110, 118, 129, 0.3);
     padding: 0.2rem 0.4rem;
     border-radius: 0.25rem;
+    font-size: 0.875em;
 }
 
 /* Alerts */
@@ -324,7 +328,7 @@ body {
     border: 1px solid #f44336;
     border-radius: 0.5rem;
     padding: 1rem;
-    color: #ff8a80;
+    color: #ffd7d3;
 }
 
 .mermaid-error .text-danger {
@@ -339,14 +343,6 @@ body {
     padding: 0;
 }
 
-.chat-message .message-content pre {
-    background-color: #0d1117;
-    border: 1px solid #30363d;
-    border-radius: 0.5rem;
-    padding: 1rem;
-    overflow-x: auto;
-}
-
 .chat-message .message-content code:not(.hljs) {
     background-color: rgba(110, 118, 129, 0.3);
     padding: 0.2rem 0.4rem;
@@ -354,29 +350,12 @@ body {
     font-size: 0.875em;
 }
 
-/* Markdown content styling */
-.markdown-content pre {
-    background-color: #0d1117;
-    border: 1px solid #30363d;
-    border-radius: 0.5rem;
-    padding: 1rem;
-    overflow-x: auto;
-    margin: 1rem 0;
-}
-
 .markdown-content pre code {
     background-color: transparent;
     padding: 0;
     border-radius: 0;
 }
 
-.markdown-content code {
-    background-color: rgba(110, 118, 129, 0.3);
-    padding: 0.2rem 0.4rem;
-    border-radius: 0.25rem;
-    font-size: 0.875em;
-}
-
 .markdown-content blockquote {
     border-left: 4px solid var(--spark-cyan);
     padding-left: 1rem;