321 lines
15 KiB
Python
321 lines
15 KiB
Python
# Copyright (c) 2025 Patrick Motsch
|
|
# All rights reserved.
|
|
"""
|
|
Main workflow service - handles workflow execution, scheduling, and chat playground operations.
|
|
|
|
Combines functionality from:
|
|
- mainAutomation.py: Automation workflow execution and scheduling
|
|
- mainChatPlayground.py: Chat playground workflow start/stop operations
|
|
"""
|
|
|
|
import logging
|
|
import json
|
|
from typing import Dict, Any, Optional
|
|
|
|
from modules.datamodels.datamodelChat import ChatWorkflow, UserInputRequest, WorkflowModeEnum
|
|
from modules.features.automation.datamodelFeatureAutomation import AutomationDefinition
|
|
from modules.datamodels.datamodelUam import User
|
|
from modules.shared.timeUtils import getUtcTimestamp
|
|
from modules.shared.eventManagement import eventManager
|
|
from modules.features.automation.mainAutomation import getAutomationServices
|
|
from modules.workflows.workflowManager import WorkflowManager
|
|
from .subAutomationUtils import parseScheduleToCron, planToPrompt, replacePlaceholders
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
async def chatStart(currentUser: User, userInput: UserInputRequest, workflowMode: WorkflowModeEnum, workflowId: Optional[str] = None, mandateId: Optional[str] = None, featureInstanceId: Optional[str] = None, featureCode: Optional[str] = None) -> ChatWorkflow:
|
|
"""
|
|
Starts a new chat or continues an existing one, then launches processing asynchronously.
|
|
|
|
Args:
|
|
currentUser: Current user
|
|
userInput: User input request
|
|
workflowId: Optional workflow ID to continue existing workflow
|
|
workflowMode: Workflow mode (Dynamic, Automation, etc.)
|
|
mandateId: Mandate ID (required for billing)
|
|
featureInstanceId: Feature instance ID (required for billing)
|
|
featureCode: Feature code (e.g., 'chatplayground', 'automation')
|
|
"""
|
|
try:
|
|
services = getAutomationServices(currentUser, mandateId=mandateId, featureInstanceId=featureInstanceId)
|
|
|
|
# Store allowedProviders in services context for model selection
|
|
if hasattr(userInput, 'allowedProviders') and userInput.allowedProviders:
|
|
services.allowedProviders = userInput.allowedProviders
|
|
logger.info(f"AI provider filter active: {userInput.allowedProviders}")
|
|
|
|
# Store feature code in services (for billing)
|
|
if featureCode:
|
|
services.featureCode = featureCode
|
|
|
|
workflowManager = WorkflowManager(services)
|
|
workflow = await workflowManager.workflowStart(userInput, workflowMode, workflowId)
|
|
return workflow
|
|
except Exception as e:
|
|
logger.error(f"Error starting chat: {str(e)}")
|
|
raise
|
|
|
|
async def chatStop(currentUser: User, workflowId: str, mandateId: Optional[str] = None, featureInstanceId: Optional[str] = None, featureCode: Optional[str] = None) -> ChatWorkflow:
|
|
"""Stops a running chat."""
|
|
try:
|
|
services = getAutomationServices(currentUser, mandateId=mandateId, featureInstanceId=featureInstanceId)
|
|
if featureCode:
|
|
services.featureCode = featureCode
|
|
workflowManager = WorkflowManager(services)
|
|
return await workflowManager.workflowStop(workflowId)
|
|
except Exception as e:
|
|
logger.error(f"Error stopping chat: {str(e)}")
|
|
raise
|
|
|
|
|
|
async def executeAutomation(automationId: str, automation, creatorUser: User, services) -> ChatWorkflow:
|
|
"""Execute automation workflow with the creator user's context.
|
|
|
|
The automation object and creatorUser are resolved by the caller (handler)
|
|
using the SysAdmin eventUser. This function does NOT re-load them.
|
|
|
|
Args:
|
|
automationId: ID of automation to execute
|
|
automation: Pre-loaded automation object (with system fields like _createdBy)
|
|
creatorUser: The user who created the automation (workflow runs in this context)
|
|
services: Services instance (used for interfaceDbApp etc.)
|
|
|
|
Returns:
|
|
ChatWorkflow instance created by automation execution
|
|
"""
|
|
executionStartTime = getUtcTimestamp()
|
|
executionLog = {
|
|
"timestamp": executionStartTime,
|
|
"workflowId": None,
|
|
"status": "running",
|
|
"messages": []
|
|
}
|
|
|
|
try:
|
|
executionLog["messages"].append(f"Started execution at {executionStartTime}")
|
|
|
|
# Store allowed providers from automation in services context
|
|
if hasattr(automation, 'allowedProviders') and automation.allowedProviders:
|
|
services.allowedProviders = automation.allowedProviders
|
|
logger.debug(f"Automation {automationId} restricted to providers: {automation.allowedProviders}")
|
|
|
|
# Context comes EXCLUSIVELY from the automation definition
|
|
automationMandateId = str(automation.mandateId) if automation.mandateId is not None else None
|
|
automationFeatureInstanceId = str(automation.featureInstanceId) if automation.featureInstanceId is not None else None
|
|
|
|
if not automationMandateId or not automationFeatureInstanceId:
|
|
raise ValueError(f"Automation {automationId} missing mandateId or featureInstanceId")
|
|
|
|
logger.info(f"Executing automation {automationId} as user {creatorUser.id} with mandateId={automationMandateId}, featureInstanceId={automationFeatureInstanceId}")
|
|
|
|
# 1. Replace placeholders in template to generate plan
|
|
template = automation.template or ""
|
|
placeholders = automation.placeholders or {}
|
|
planJson = replacePlaceholders(template, placeholders)
|
|
try:
|
|
plan = json.loads(planJson)
|
|
except json.JSONDecodeError as e:
|
|
logger.error(f"Failed to parse plan JSON after placeholder replacement: {str(e)}")
|
|
logger.error(f"Template: {template[:500]}...")
|
|
logger.error(f"Placeholders: {placeholders}")
|
|
logger.error(f"Generated planJson (first 1000 chars): {planJson[:1000]}")
|
|
logger.error(f"Error position: line {e.lineno}, column {e.colno}, char {e.pos}")
|
|
if e.pos is not None:
|
|
start = max(0, e.pos - 100)
|
|
end = min(len(planJson), e.pos + 100)
|
|
logger.error(f"Context around error: ...{planJson[start:end]}...")
|
|
raise ValueError(f"Invalid JSON after placeholder replacement: {str(e)}")
|
|
executionLog["messages"].append("Template placeholders replaced successfully")
|
|
executionLog["messages"].append(f"Using creator user: {creatorUser.id}")
|
|
|
|
# 2. Create UserInputRequest from plan
|
|
# Embed plan JSON in prompt for TemplateMode to extract
|
|
promptText = planToPrompt(plan)
|
|
planJsonStr = json.dumps(plan)
|
|
# Embed plan as JSON comment so TemplateMode can extract it
|
|
promptWithPlan = f"{promptText}\n\n<!--TEMPLATE_PLAN_START-->\n{planJsonStr}\n<!--TEMPLATE_PLAN_END-->"
|
|
|
|
userInput = UserInputRequest(
|
|
prompt=promptWithPlan,
|
|
listFileId=[],
|
|
userLanguage=creatorUser.language or "en"
|
|
)
|
|
|
|
executionLog["messages"].append("Starting workflow execution")
|
|
|
|
# 3. Start workflow using chatStart with creator's context
|
|
# mandateId and featureInstanceId come from the automation definition
|
|
workflow = await chatStart(
|
|
currentUser=creatorUser,
|
|
userInput=userInput,
|
|
workflowMode=WorkflowModeEnum.WORKFLOW_AUTOMATION,
|
|
workflowId=None,
|
|
mandateId=automationMandateId,
|
|
featureInstanceId=automationFeatureInstanceId,
|
|
featureCode='automation'
|
|
)
|
|
|
|
executionLog["workflowId"] = workflow.id
|
|
executionLog["status"] = "completed"
|
|
executionLog["messages"].append(f"Workflow {workflow.id} started successfully")
|
|
logger.info(f"Started workflow {workflow.id} with plan containing {len(plan.get('tasks', []))} tasks (plan embedded in userInput)")
|
|
|
|
# Set workflow name with "automated" prefix — use creatorUser's Services
|
|
# (services parameter is eventServices with eventUser context, must use creatorUser context)
|
|
creatorServices = getAutomationServices(creatorUser, mandateId=automationMandateId, featureInstanceId=automationFeatureInstanceId)
|
|
automationLabel = automation.label or "Unknown Automation"
|
|
workflowName = f"automated: {automationLabel}"
|
|
creatorServices.interfaceDbChat.updateWorkflow(workflow.id, {"name": workflowName})
|
|
logger.info(f"Set workflow {workflow.id} name to: {workflowName}")
|
|
|
|
# Save execution log (bypasses RBAC — system operation, not a user edit)
|
|
executionLogs = list(automation.executionLogs or [])
|
|
executionLogs.append(executionLog)
|
|
# Keep only last 50 executions
|
|
if len(executionLogs) > 50:
|
|
executionLogs = executionLogs[-50:]
|
|
|
|
services.interfaceDbAutomation._saveExecutionLog(automationId, executionLogs)
|
|
|
|
return workflow
|
|
except Exception as e:
|
|
# Log error to execution log
|
|
executionLog["status"] = "error"
|
|
executionLog["messages"].append(f"Error: {str(e)}")
|
|
|
|
# Save execution log even on error (bypasses RBAC — system operation)
|
|
# Use the automation object already passed in (no re-load needed)
|
|
try:
|
|
executionLogs = list(getattr(automation, 'executionLogs', None) or [])
|
|
executionLogs.append(executionLog)
|
|
if len(executionLogs) > 50:
|
|
executionLogs = executionLogs[-50:]
|
|
services.interfaceDbAutomation._saveExecutionLog(automationId, executionLogs)
|
|
except Exception as logError:
|
|
logger.error(f"Error saving execution log: {str(logError)}")
|
|
|
|
raise
|
|
|
|
|
|
def syncAutomationEvents(services, eventUser) -> Dict[str, Any]:
|
|
"""Sync scheduler with all active automations.
|
|
All operations (DB reads, scheduler registration) are synchronous.
|
|
|
|
Args:
|
|
services: Services instance for data access
|
|
eventUser: System-level event user for accessing automations
|
|
|
|
Returns:
|
|
Dictionary with sync results (synced count and event IDs)
|
|
"""
|
|
# Get all automation definitions filtered by RBAC (for current mandate)
|
|
filtered = services.interfaceDbAutomation.getAllAutomationDefinitionsWithRBAC(eventUser)
|
|
|
|
registeredEvents = {}
|
|
|
|
for automation in filtered:
|
|
# Handle both dict and object access patterns
|
|
if isinstance(automation, dict):
|
|
automationId = automation.get('id')
|
|
isActive = automation.get('active', False)
|
|
currentEventId = automation.get('eventId')
|
|
schedule = automation.get('schedule')
|
|
else:
|
|
automationId = automation.id
|
|
isActive = automation.active if hasattr(automation, 'active') else False
|
|
currentEventId = automation.eventId if hasattr(automation, 'eventId') else None
|
|
schedule = automation.schedule if hasattr(automation, 'schedule') else None
|
|
|
|
if not schedule:
|
|
logger.warning(f"Automation {automationId} has no schedule, skipping")
|
|
continue
|
|
|
|
try:
|
|
# Parse schedule to cron kwargs
|
|
cronKwargs = parseScheduleToCron(schedule)
|
|
|
|
if isActive:
|
|
newEventId = f"automation.{automationId}"
|
|
handler = createAutomationEventHandler(automationId, eventUser)
|
|
|
|
# Register with replaceExisting=True (atomically replaces old event)
|
|
eventManager.registerCron(
|
|
jobId=newEventId,
|
|
func=handler,
|
|
cronKwargs=cronKwargs,
|
|
replaceExisting=True
|
|
)
|
|
|
|
# Update automation with new eventId
|
|
if currentEventId != newEventId:
|
|
services.interfaceDbAutomation.updateAutomationDefinition(
|
|
automationId,
|
|
{"eventId": newEventId}
|
|
)
|
|
|
|
registeredEvents[automationId] = newEventId
|
|
else:
|
|
# Remove event if exists
|
|
if currentEventId:
|
|
try:
|
|
eventManager.remove(currentEventId)
|
|
services.interfaceDbAutomation.updateAutomationDefinition(
|
|
automationId,
|
|
{"eventId": None}
|
|
)
|
|
except Exception as e:
|
|
logger.warning(f"Error removing event {currentEventId}: {str(e)}")
|
|
except Exception as e:
|
|
logger.error(f"Error syncing automation {automationId}: {str(e)}")
|
|
|
|
return {
|
|
"synced": len(registeredEvents),
|
|
"events": registeredEvents
|
|
}
|
|
|
|
|
|
def createAutomationEventHandler(automationId: str, eventUser):
|
|
"""Create event handler function for a specific automation.
|
|
|
|
Args:
|
|
automationId: ID of automation to create handler for
|
|
eventUser: System-level event user for accessing automations (captured in closure)
|
|
|
|
Returns:
|
|
Async handler function for scheduled automation execution
|
|
"""
|
|
async def handler():
|
|
try:
|
|
if not eventUser:
|
|
logger.error("Event user not available for automation execution")
|
|
return
|
|
|
|
# Load automation using SysAdmin eventUser (has unrestricted access)
|
|
eventServices = getAutomationServices(eventUser, mandateId=None, featureInstanceId=None)
|
|
automation = eventServices.interfaceDbAutomation.getAutomationDefinition(automationId, includeSystemFields=True)
|
|
if not automation or not getattr(automation, "active", False):
|
|
logger.warning(f"Automation {automationId} not found or not active, skipping execution")
|
|
return
|
|
|
|
# Get creator user ID from automation's _createdBy system field
|
|
creatorUserId = getattr(automation, "_createdBy", None)
|
|
if not creatorUserId:
|
|
logger.error(f"Automation {automationId} has no creator user (_createdBy missing)")
|
|
return
|
|
|
|
# Get creator user from database (using SysAdmin access)
|
|
creatorUser = eventServices.interfaceDbApp.getUser(creatorUserId)
|
|
if not creatorUser:
|
|
logger.error(f"Creator user {creatorUserId} not found for automation {automationId}")
|
|
return
|
|
|
|
# Execute automation — pass automation object and creatorUser directly
|
|
# No re-load needed in executeAutomation
|
|
await executeAutomation(automationId, automation, creatorUser, eventServices)
|
|
logger.info(f"Successfully executed automation {automationId} as user {creatorUserId}")
|
|
except Exception as e:
|
|
logger.error(f"Error executing automation {automationId}: {str(e)}")
|
|
|
|
return handler
|
|
|