447 lines
19 KiB
Python
447 lines
19 KiB
Python
import logging
|
|
import importlib
|
|
import pkgutil
|
|
import inspect
|
|
from typing import Dict, Any, List, Optional
|
|
from modules.interfaces.interfaceAppModel import User, UserConnection
|
|
from modules.interfaces.interfaceChatModel import (
|
|
TaskStatus, ChatDocument, TaskItem, TaskAction, TaskResult,
|
|
ChatStat, ChatLog, ChatMessage, ChatWorkflow
|
|
)
|
|
from modules.interfaces.interfaceAiCalls import interfaceAiCalls
|
|
from modules.interfaces.interfaceChatObjects import getInterface as getChatObjects
|
|
from modules.interfaces.interfaceComponentObjects import getInterface as getComponentObjects
|
|
from modules.workflow.managerDocument import DocumentManager
|
|
from modules.methods.methodBase import MethodBase
|
|
import uuid
|
|
import base64
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class ServiceContainer:
|
|
"""Service container that provides access to all services and their functions"""
|
|
|
|
def __init__(self, currentUser: User, workflow: ChatWorkflow):
|
|
# Core services
|
|
self.user = currentUser
|
|
self.workflow = workflow
|
|
self.tasks = workflow.tasks
|
|
self.statusEnums = TaskStatus
|
|
self.currentTask = None # Initialize current task as None
|
|
|
|
# Initialize managers
|
|
self.interfaceChat = getChatObjects(currentUser)
|
|
self.interfaceComponent = getComponentObjects(currentUser)
|
|
self.interfaceAiCalls = interfaceAiCalls()
|
|
self.documentManager = DocumentManager(self)
|
|
|
|
# Initialize methods catalog
|
|
self.methods = {}
|
|
# Discover additional methods
|
|
self._discoverMethods()
|
|
|
|
def _discoverMethods(self):
|
|
"""Dynamically discover all method classes and their actions in modules.methods package"""
|
|
try:
|
|
# Import the methods package
|
|
methodsPackage = importlib.import_module('modules.methods')
|
|
|
|
# Discover all modules in the package
|
|
for _, name, isPkg in pkgutil.iter_modules(methodsPackage.__path__):
|
|
if not isPkg and name.startswith('method'):
|
|
try:
|
|
# Import the module
|
|
module = importlib.import_module(f'modules.methods.{name}')
|
|
|
|
# Find all classes in the module that inherit from MethodBase
|
|
for itemName, item in inspect.getmembers(module):
|
|
if (inspect.isclass(item) and
|
|
issubclass(item, MethodBase) and
|
|
item != MethodBase):
|
|
# Instantiate the method
|
|
methodInstance = item(self)
|
|
|
|
# Discover actions from public methods
|
|
actions = {}
|
|
for methodName, method in inspect.getmembers(methodInstance, predicate=inspect.isfunction):
|
|
# Skip private methods and inherited methods
|
|
if not methodName.startswith('_') and methodName not in ['execute', 'actions', 'validateParameters']:
|
|
# Get method signature
|
|
sig = inspect.signature(method)
|
|
params = {}
|
|
|
|
# Convert parameters to action definition
|
|
for paramName, param in sig.parameters.items():
|
|
if paramName not in ['self', 'authData']:
|
|
params[paramName] = {
|
|
'type': param.annotation if param.annotation != param.empty else Any,
|
|
'required': param.default == param.empty,
|
|
'description': param.default.__doc__ if hasattr(param.default, '__doc__') else None
|
|
}
|
|
|
|
# Add action definition
|
|
actions[methodName] = {
|
|
'description': method.__doc__ or '',
|
|
'parameters': params,
|
|
'method': method
|
|
}
|
|
|
|
# Add method instance with discovered actions
|
|
self.methods[methodInstance.name] = {
|
|
'instance': methodInstance,
|
|
'description': methodInstance.description,
|
|
'actions': actions
|
|
}
|
|
logger.info(f"Discovered method: {methodInstance.name} with {len(actions)} actions")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error loading method module {name}: {str(e)}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error discovering methods: {str(e)}")
|
|
|
|
# ===== Functions =====
|
|
|
|
def extractContent(self, prompt: str, document: ChatDocument) -> str:
|
|
"""Extract content from document using prompt"""
|
|
return self.documentManager.extractContent(prompt, document)
|
|
|
|
def getMethodsCatalog(self) -> Dict[str, Any]:
|
|
"""Get catalog of available methods and their actions"""
|
|
catalog = {}
|
|
for methodName, method in self.methods.items():
|
|
catalog[methodName] = {
|
|
'description': method['description'],
|
|
'actions': {
|
|
actionName: {
|
|
'description': action['description'],
|
|
'parameters': action['parameters']
|
|
}
|
|
for actionName, action in method['actions'].items()
|
|
}
|
|
}
|
|
return catalog
|
|
|
|
def getMethodsList(self) -> List[str]:
|
|
"""Get list of available methods with their signatures"""
|
|
methodList = []
|
|
for methodName, method in self.methods.items():
|
|
for actionName, action in method['actions'].items():
|
|
# Get parameter types from action signature
|
|
paramTypes = []
|
|
for paramName, param in action['parameters'].items():
|
|
paramTypes.append(f"{paramName}:{param['type']}")
|
|
|
|
# Format: method.action([param1:type, param2:type]) # description
|
|
signature = f"{methodName}.{actionName}([{', '.join(paramTypes)}])"
|
|
if action['description']:
|
|
signature += f" # {action['description']}"
|
|
methodList.append(signature)
|
|
return methodList
|
|
|
|
def getDocumentReferenceList(self) -> Dict[str, List[Dict[str, str]]]:
|
|
"""Get list of document references sorted by datetime, categorized by chat round"""
|
|
chat_refs = []
|
|
history_refs = []
|
|
|
|
# Process messages in reverse order to find current chat round
|
|
for message in reversed(self.workflow.messages):
|
|
# Get document references from message
|
|
if message.documents:
|
|
# For messages with action context, use documentList reference
|
|
if message.actionId and message.documentsLabel:
|
|
doc_ref = self.getDocumentReferenceFromMessage(message)
|
|
doc_info = {
|
|
"documentReference": doc_ref,
|
|
"datetime": message.publishedAt
|
|
}
|
|
|
|
# Add to appropriate list based on message status
|
|
if message.status == "first":
|
|
chat_refs.append(doc_info)
|
|
break # Stop after finding first message
|
|
elif message.status == "step":
|
|
chat_refs.append(doc_info)
|
|
else:
|
|
history_refs.append(doc_info)
|
|
# For regular messages, use individual document references
|
|
else:
|
|
for doc in message.documents:
|
|
doc_ref = self.getDocumentReferenceFromChatDocument(doc)
|
|
doc_info = {
|
|
"documentReference": doc_ref,
|
|
"datetime": message.publishedAt
|
|
}
|
|
|
|
# Add to appropriate list based on message status
|
|
if message.status == "first":
|
|
chat_refs.append(doc_info)
|
|
break # Stop after finding first message
|
|
elif message.status == "step":
|
|
chat_refs.append(doc_info)
|
|
else:
|
|
history_refs.append(doc_info)
|
|
|
|
# Stop processing if we hit a first message
|
|
if message.status == "first":
|
|
break
|
|
|
|
# Sort both lists by datetime in descending order
|
|
chat_refs.sort(key=lambda x: x["datetime"], reverse=True)
|
|
history_refs.sort(key=lambda x: x["datetime"], reverse=True)
|
|
|
|
return {
|
|
"chat": chat_refs,
|
|
"history": history_refs
|
|
}
|
|
|
|
def getDocumentReferenceFromChatDocument(self, document: ChatDocument) -> str:
|
|
"""Get document reference from ChatDocument"""
|
|
return f"document_{document.id}_{document.filename}"
|
|
|
|
def getDocumentReferenceFromMessage(self, message: ChatMessage) -> str:
|
|
"""Get document reference from ChatMessage with action context"""
|
|
if not message.actionId or not message.documentsLabel:
|
|
return None
|
|
|
|
# If documentsLabel already contains the full reference format, return it
|
|
if message.documentsLabel.startswith("documentList_"):
|
|
return message.documentsLabel
|
|
|
|
# Otherwise construct the reference
|
|
return f"documentList_{message.actionId}_{message.documentsLabel}"
|
|
|
|
def getChatDocumentsFromDocumentReference(self, documentReference: str) -> List[ChatDocument]:
|
|
"""Get ChatDocuments from document reference"""
|
|
try:
|
|
# Parse reference format
|
|
parts = documentReference.split('_', 2) # Split into max 3 parts
|
|
if len(parts) < 3:
|
|
return []
|
|
|
|
ref_type = parts[0]
|
|
ref_id = parts[1]
|
|
ref_label = parts[2] # Keep the full label
|
|
|
|
if ref_type == "document":
|
|
# Handle ChatDocument reference: document_<id>_<filename>
|
|
# Find document in workflow messages
|
|
for message in self.workflow.messages:
|
|
if message.documents:
|
|
for doc in message.documents:
|
|
if doc.id == ref_id:
|
|
return [doc]
|
|
|
|
elif ref_type == "documentList":
|
|
# Handle document list reference: documentList_<action.id>_<label>
|
|
# Find message with matching action ID and documents label
|
|
for message in self.workflow.messages:
|
|
if (message.actionId == ref_id and
|
|
message.documentsLabel == documentReference and # Compare full reference
|
|
message.documents):
|
|
return message.documents
|
|
|
|
return []
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting documents from reference {documentReference}: {str(e)}")
|
|
return []
|
|
|
|
def getConnectionReferenceList(self) -> List[Dict[str, str]]:
|
|
"""Get list of all UserConnection objects as references"""
|
|
connections = []
|
|
for conn in self.user.connections:
|
|
connections.append({
|
|
"connectionReference": f"connection_{conn.id}_{conn.authority}",
|
|
"authority": conn.authority
|
|
})
|
|
# Sort by authority
|
|
return sorted(connections, key=lambda x: x["authority"])
|
|
|
|
def getConnectionReferenceFromUserConnection(self, connection: UserConnection) -> str:
|
|
"""Get connection reference from UserConnection"""
|
|
return f"connection_{connection.id}_{connection.authority}"
|
|
|
|
def getUserConnectionFromConnectionReference(self, connectionReference: str) -> Optional[UserConnection]:
|
|
"""Get UserConnection from reference string"""
|
|
try:
|
|
# Parse reference format: connection_{id}_{authority}
|
|
parts = connectionReference.split('_')
|
|
if len(parts) != 3 or parts[0] != "connection":
|
|
return None
|
|
|
|
conn_id = parts[1]
|
|
authority = parts[2]
|
|
|
|
# Find matching connection
|
|
for conn in self.user.connections:
|
|
if str(conn.id) == conn_id and conn.authority == authority:
|
|
return conn
|
|
return None
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error parsing connection reference: {str(e)}")
|
|
return None
|
|
|
|
async def summarizeChat(self, messages: List[ChatMessage]) -> str:
|
|
"""
|
|
Summarize chat messages from last to first message with status="first"
|
|
|
|
Args:
|
|
messages: List of chat messages to summarize
|
|
|
|
Returns:
|
|
str: Summary of the chat in user's language
|
|
"""
|
|
try:
|
|
# Get messages from last to first, stopping at first message with status="first"
|
|
relevantMessages = []
|
|
for msg in reversed(messages):
|
|
relevantMessages.append(msg)
|
|
if msg.status == "first":
|
|
break
|
|
|
|
# Create prompt for AI
|
|
prompt = f"""You are an AI assistant providing a summary of a chat conversation.
|
|
Please respond in '{self.user.language}' language.
|
|
|
|
Chat History:
|
|
{chr(10).join(f"- {msg.message}" for msg in reversed(relevantMessages))}
|
|
|
|
Instructions:
|
|
1. Summarize the conversation's key points and outcomes
|
|
2. Be concise but informative
|
|
3. Use a professional but friendly tone
|
|
4. Focus on important decisions and next steps if any
|
|
|
|
Please provide a comprehensive summary of this conversation."""
|
|
|
|
# Get summary using AI
|
|
return await self.interfaceAiCalls.callAiTextBasic(prompt)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error summarizing chat: {str(e)}")
|
|
return f"Error summarizing chat: {str(e)}"
|
|
|
|
async def summarizeMessage(self, message: ChatMessage) -> str:
|
|
"""
|
|
Summarize a single chat message
|
|
|
|
Args:
|
|
message: Chat message to summarize
|
|
|
|
Returns:
|
|
str: Summary of the message in user's language
|
|
"""
|
|
try:
|
|
# Create prompt for AI
|
|
prompt = f"""You are an AI assistant providing a summary of a chat message.
|
|
Please respond in '{self.user.language}' language.
|
|
|
|
Message:
|
|
{message.message}
|
|
|
|
Instructions:
|
|
1. Summarize the key points of this message
|
|
2. Be concise but informative
|
|
3. Use a professional but friendly tone
|
|
4. Focus on important information and any actions needed
|
|
|
|
Please provide a clear summary of this message."""
|
|
|
|
# Get summary using AI
|
|
return await self.interfaceAiCalls.callAiTextBasic(prompt)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error summarizing message: {str(e)}")
|
|
return f"Error summarizing message: {str(e)}"
|
|
|
|
def callAiTextBasic(self, prompt: str, context: str = None) -> str:
|
|
"""Basic text processing using OpenAI"""
|
|
return self.interfaceAiCalls.callAiTextBasic(prompt, context)
|
|
|
|
def callAiTextAdvanced(self, prompt: str, context: str = None) -> str:
|
|
"""Advanced text processing using Anthropic"""
|
|
return self.interfaceAiCalls.callAiTextAdvanced(prompt, context)
|
|
|
|
def callAiImageBasic(self, prompt: str, imageData: bytes, mimeType: str) -> str:
|
|
"""Basic image processing using OpenAI"""
|
|
return self.interfaceAiCalls.callAiImageBasic(prompt, imageData, mimeType)
|
|
|
|
def callAiImageAdvanced(self, prompt: str, imageData: bytes, mimeType: str) -> str:
|
|
"""Advanced image processing using Anthropic"""
|
|
return self.interfaceAiCalls.callAiImageAdvanced(prompt, imageData, mimeType)
|
|
|
|
def getFileInfo(self, fileId: str) -> Dict[str, Any]:
|
|
"""Get file information"""
|
|
return self.interfaceComponent.getFileInfo(fileId)
|
|
|
|
def getFileData(self, fileId: str) -> bytes:
|
|
"""Get file data by ID"""
|
|
return self.interfaceComponent.getFileData(fileId)
|
|
|
|
def createFile(self, fileName: str, mimeType: str, content: str, base64encoded: bool = False) -> str:
|
|
"""Create new file and return its ID"""
|
|
# Convert content to bytes based on base64 flag
|
|
if base64encoded:
|
|
content_bytes = base64.b64decode(content)
|
|
else:
|
|
content_bytes = content.encode('utf-8')
|
|
|
|
# First create the file metadata
|
|
file_item = self.interfaceComponent.createFile(
|
|
name=fileName,
|
|
mimeType=mimeType,
|
|
size=len(content_bytes)
|
|
)
|
|
|
|
# Then store the file data
|
|
self.interfaceComponent.createFileData(file_item.id, content_bytes)
|
|
|
|
return file_item.id
|
|
|
|
def createDocument(self, fileName: str, mimeType: str, content: str, base64encoded: bool = True) -> ChatDocument:
|
|
"""Create document from file data object created by AI call"""
|
|
# First create the file and get its ID
|
|
file_id = self.createFile(fileName, mimeType, content, base64encoded)
|
|
|
|
# Get file info for metadata
|
|
file_info = self.interfaceComponent.getFile(file_id)
|
|
|
|
# Create document with file reference
|
|
return ChatDocument(
|
|
id=str(uuid.uuid4()),
|
|
fileId=file_id,
|
|
filename=fileName,
|
|
fileSize=file_info.fileSize,
|
|
mimeType=mimeType
|
|
)
|
|
|
|
async def executeMethod(self, methodName: str, actionName: str, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
|
|
"""Execute a method action"""
|
|
try:
|
|
if methodName not in self.methods:
|
|
raise ValueError(f"Unknown method: {methodName}")
|
|
|
|
method = self.methods[methodName]
|
|
if actionName not in method['actions']:
|
|
raise ValueError(f"Unknown action: {actionName} for method {methodName}")
|
|
|
|
action = method['actions'][actionName]
|
|
|
|
# Execute the action
|
|
return await action['method'](parameters, authData)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error executing method {methodName}.{actionName}: {str(e)}")
|
|
raise
|
|
|
|
# Create singleton instance
|
|
serviceObject = None
|
|
|
|
def initializeServiceContainer(currentUser: User, workflow: ChatWorkflow) -> ServiceContainer:
|
|
"""Initialize the service container singleton"""
|
|
global serviceObject
|
|
if serviceObject is None:
|
|
serviceObject = ServiceContainer(currentUser, workflow)
|
|
return serviceObject
|