You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
510 lines
20 KiB
Python
510 lines
20 KiB
Python
import asyncio
|
|
import uuid
|
|
from typing import Awaitable, Callable, Dict, Optional
|
|
|
|
from pydantic import ValidationError
|
|
from sqlalchemy import select
|
|
|
|
from core.agents.base import BaseAgent
|
|
from core.agents.convo import AgentConvo
|
|
from core.db.models.chat_convo import ChatConvo
|
|
from core.db.models.chat_message import ChatMessage
|
|
from core.llm.convo import Convo
|
|
from core.log import get_logger
|
|
from core.state.state_manager import StateManager
|
|
from core.ui.ipc_client import MESSAGE_SIZE_LIMIT, Message, MessageType
|
|
from core.ui.virtual import VirtualUI
|
|
|
|
log = get_logger(__name__)
|
|
|
|
|
|
async def send_stream_chunk(writer: asyncio.StreamWriter, message_type, content_chunk, request_id):
|
|
if not content_chunk:
|
|
content_chunk = ""
|
|
stream_message = Message(type=message_type, content={"chunk": content_chunk}, request_id=request_id)
|
|
data = stream_message.to_bytes()
|
|
writer.write(len(data).to_bytes(4))
|
|
writer.write(data)
|
|
await writer.drain()
|
|
|
|
|
|
class IPCServer:
|
|
"""
|
|
IPC server for handling requests from external clients.
|
|
"""
|
|
|
|
def __init__(self, host: str, port: int, state_manager: StateManager):
|
|
"""
|
|
Initialize the IPC server.
|
|
|
|
:param host: Host to bind to.
|
|
:param port: Port to listen on.
|
|
:param state_manager: State manager instance.
|
|
"""
|
|
self.host = host
|
|
self.port = port
|
|
self.state_manager = state_manager
|
|
self.server = None
|
|
self.handlers: Dict[MessageType, Callable[[Message, asyncio.StreamWriter], Awaitable[None]]] = {}
|
|
self._setup_handlers()
|
|
self.convo_id = None
|
|
|
|
def _setup_handlers(self):
|
|
"""Set up message handlers."""
|
|
self.handlers[MessageType.EPICS_AND_TASKS] = self._handle_epics_and_tasks
|
|
self.handlers[MessageType.CHAT_MESSAGE] = self._handle_chat_message
|
|
self.handlers[MessageType.START_CHAT] = self._handle_start_chat
|
|
self.handlers[MessageType.GET_CHAT_HISTORY] = self._handle_get_chat_history
|
|
self.handlers[MessageType.PROJECT_INFO] = self._handle_project_info
|
|
self.handlers[MessageType.KNOWLEDGE_BASE] = self._handle_knowledge_base
|
|
self.handlers[MessageType.PROJECT_SPECS] = self._handle_project_specs
|
|
|
|
async def start(self) -> bool:
|
|
"""
|
|
Start the IPC server.
|
|
|
|
:return: True if server started successfully, False otherwise.
|
|
"""
|
|
try:
|
|
self.server = await asyncio.start_server(
|
|
self._handle_client,
|
|
self.host,
|
|
self.port,
|
|
limit=MESSAGE_SIZE_LIMIT,
|
|
)
|
|
log.info(f"IPC server started on {self.host}:{self.port}")
|
|
return True
|
|
except (OSError, ConnectionError) as err:
|
|
log.error(f"Failed to start IPC server: {err}")
|
|
return False
|
|
|
|
async def stop(self):
|
|
"""Stop the IPC server."""
|
|
if self.server:
|
|
self.server.close()
|
|
await self.server.wait_closed()
|
|
log.info(f"IPC server on {self.host}:{self.port} stopped")
|
|
self.server = None
|
|
|
|
async def _handle_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
|
|
"""
|
|
Handle client connection.
|
|
|
|
:param reader: Stream reader.
|
|
:param writer: Stream writer.
|
|
"""
|
|
addr = writer.get_extra_info("peername")
|
|
log.debug(f"New connection from {addr}")
|
|
|
|
try:
|
|
while True:
|
|
# Read message length (4 bytes)
|
|
length_bytes = await reader.readexactly(4)
|
|
if not length_bytes:
|
|
break
|
|
|
|
# Parse message length
|
|
message_length = int.from_bytes(length_bytes)
|
|
|
|
# Read message data
|
|
data = await reader.readexactly(message_length)
|
|
if not data:
|
|
break
|
|
|
|
# Parse message
|
|
try:
|
|
message = Message.from_bytes(data)
|
|
await self._process_message(message, writer)
|
|
except ValidationError as err:
|
|
log.error(f"Invalid message format: {err}")
|
|
await self._send_error(writer, "Invalid message format")
|
|
except ValueError as err:
|
|
log.error(f"Error decoding message: {err}")
|
|
await self._send_error(writer, "Error decoding message")
|
|
|
|
except asyncio.IncompleteReadError:
|
|
log.debug(f"Client {addr} disconnected")
|
|
except (ConnectionResetError, BrokenPipeError) as err:
|
|
log.debug(f"Connection to {addr} lost: {err}")
|
|
finally:
|
|
writer.close()
|
|
await writer.wait_closed()
|
|
log.debug(f"Connection to {addr} closed")
|
|
|
|
async def _process_message(self, message: Message, writer: asyncio.StreamWriter):
|
|
"""
|
|
Process incoming message.
|
|
|
|
:param message: Incoming message.
|
|
:param writer: Stream writer to send response.
|
|
"""
|
|
log.debug(f"Received message of type {message.type} with request ID {message.request_id}")
|
|
|
|
handler = self.handlers.get(message.type)
|
|
if handler:
|
|
await handler(message, writer)
|
|
else:
|
|
log.warning(f"No handler for message type {message.type}")
|
|
request_id = getattr(message, "request_id", None)
|
|
await self._send_error(writer, f"Unsupported message type: {message.type}", request_id)
|
|
|
|
async def _send_response(self, writer: asyncio.StreamWriter, message: Message):
|
|
"""
|
|
Send response to client.
|
|
|
|
:param writer: Stream writer.
|
|
:param message: Message to send.
|
|
"""
|
|
data = message.to_bytes()
|
|
try:
|
|
writer.write(len(data).to_bytes(4, byteorder="big"))
|
|
writer.write(data)
|
|
await writer.drain()
|
|
except (ConnectionResetError, BrokenPipeError) as err:
|
|
log.error(f"Failed to send response: {err}")
|
|
|
|
async def _add_to_chat_history(
|
|
self, project_state_id: uuid.UUID, conversation: Convo, message: Message, assistant_message: str
|
|
):
|
|
"""
|
|
Add new messages to chat history.
|
|
|
|
:param project_state_id: Project state ID.
|
|
:param user_message: User message.
|
|
:param assistant_message: Assistant message.
|
|
"""
|
|
user_message = message.content.get("message", "")
|
|
|
|
try:
|
|
session = self.state_manager.current_session
|
|
if not session:
|
|
log.error("No database session available")
|
|
return
|
|
|
|
# Check if convo exists for this convo id
|
|
query = select(ChatConvo).where(ChatConvo.convo_id == self.convo_id)
|
|
result = await session.execute(query)
|
|
chat_convo = result.scalar_one_or_none()
|
|
|
|
# Create new convo if needed
|
|
if not chat_convo:
|
|
chat_convo = ChatConvo(convo_id=self.convo_id, project_state_id=project_state_id)
|
|
session.add(chat_convo)
|
|
await session.flush()
|
|
|
|
# Check if any ChatMessages exists with the convo id
|
|
query = select(ChatMessage).where(ChatMessage.convo_id == chat_convo.convo_id)
|
|
result = await session.execute(query)
|
|
results = result.scalars().all()
|
|
prev_message_id = None
|
|
|
|
if results:
|
|
prev_message_id = results[-1].id
|
|
|
|
# Create new messages
|
|
message_user = ChatMessage(
|
|
convo_id=chat_convo.convo_id,
|
|
message_type="user",
|
|
message=conversation.messages[1]["content"] if prev_message_id is None else user_message,
|
|
prev_message_id=prev_message_id,
|
|
)
|
|
session.add(message_user)
|
|
await session.flush()
|
|
|
|
message_assistant = ChatMessage(
|
|
convo_id=chat_convo.convo_id,
|
|
message_type="assistant",
|
|
message=assistant_message,
|
|
prev_message_id=message_user.id,
|
|
)
|
|
session.add(message_assistant)
|
|
await session.flush()
|
|
|
|
log.debug(f"Added chat message to database for project state {project_state_id}")
|
|
|
|
except Exception as e:
|
|
log.error(f"Error saving chat history: {e}")
|
|
|
|
async def _send_streaming_response(self, writer: asyncio.StreamWriter, message: Message):
|
|
"""
|
|
Send a streaming response to client.
|
|
|
|
:param writer: Stream writer.
|
|
:param message: Message with request id, content and message type.
|
|
"""
|
|
request_id = message.request_id
|
|
message_type = MessageType.CHAT_MESSAGE_RESPONSE
|
|
|
|
project_state_id = self.state_manager.current_state.id
|
|
|
|
class ChatAgent(BaseAgent):
|
|
agent_type = "chat-agent"
|
|
display_name = "Chat Agent"
|
|
|
|
async def stream_handler(self, content_chunk: str):
|
|
await send_stream_chunk(writer, message_type, content_chunk, request_id)
|
|
|
|
async def generate_prompt(self, convo_id: uuid.UUID, user_msg: str) -> Convo:
|
|
bug_hunt_cycle_user_feedback = None
|
|
command_run = None
|
|
testing_instructions = None
|
|
human_intervention = None
|
|
task_description = None
|
|
initial_description = None
|
|
|
|
# get the ChatConvo for the convo_id, then use its project state id to get the wanted project state
|
|
state = await self.state_manager.get_project_state_for_convo_id(convo_id)
|
|
|
|
if state and self.current_state.id != state.id:
|
|
log.debug(f"State {state.id} does not match current state")
|
|
else:
|
|
state = self.current_state
|
|
|
|
if state.epics and state.epics[0].get("description", None) is not None:
|
|
initial_description = state.epics[0]["description"]
|
|
|
|
if state.current_task and state.current_task.get("description", None) is not None:
|
|
task_description = state.current_task["description"]
|
|
|
|
if state.iterations:
|
|
bug_hunt_cycle_user_feedback = state.iterations[-1].get("user_feedback", None)
|
|
|
|
if state.current_task and state.current_task.get("test_instructions", None):
|
|
testing_instructions = state.current_task.get("test_instructions")
|
|
|
|
if (
|
|
state.steps
|
|
and state.steps[-1].get("command", {}) != {}
|
|
and state.steps[-1].get("completed", False) is False
|
|
):
|
|
command_run = state.steps[-1].get("command", {}).get("command", "")
|
|
|
|
if (
|
|
state.steps
|
|
and state.steps[-1].get("human_intervention_description", None) is not None
|
|
and state.steps[-1].get("completed", False) is False
|
|
):
|
|
human_intervention = state.steps[-1].get("human_intervention_description", None)
|
|
|
|
return AgentConvo(self).template(
|
|
"chat",
|
|
initial_description=initial_description,
|
|
task_description=task_description,
|
|
bug_hunt_cycle_user_feedback=bug_hunt_cycle_user_feedback,
|
|
testing_instructions=testing_instructions,
|
|
command_run=command_run,
|
|
human_intervention=human_intervention,
|
|
user_input=user_msg,
|
|
)
|
|
|
|
async def generate_convo(self, convo_id: uuid.UUID, chat_history: list) -> Convo:
|
|
# chat_history = await self.state_manager.get_chat_history(convo_id)
|
|
conversation = await self.generate_prompt(
|
|
convo_id=convo_id, user_msg=message.content.get("message", "")
|
|
)
|
|
|
|
for chat_msg in chat_history:
|
|
if chat_msg.get("role", "") == "user":
|
|
conversation = conversation.user(chat_msg.get("content", ""))
|
|
if chat_msg.get("role", "") == "assistant":
|
|
conversation = conversation.assistant(chat_msg.get("content", ""))
|
|
|
|
if len(conversation.messages) > 6:
|
|
conversation.slice(2, 4)
|
|
|
|
return conversation
|
|
|
|
async def run(self):
|
|
log.debug("Chat agent started.")
|
|
llm = self.get_llm(stream_output=True)
|
|
|
|
convo_id = uuid.UUID(message.content.get("convoId", ""))
|
|
chat_history = message.content.get("chatHistory", [])
|
|
conversation = await self.generate_convo(convo_id, chat_history)
|
|
return conversation, await llm(conversation)
|
|
|
|
try:
|
|
convo, response = await ChatAgent(state_manager=self.state_manager, ui=VirtualUI(inputs=[])).run()
|
|
await self._add_to_chat_history(project_state_id, convo, message, str(response))
|
|
|
|
# Send final message
|
|
# await send_stream_chunk(writer, message_type, None, request_id)
|
|
|
|
except (ConnectionResetError, BrokenPipeError) as err:
|
|
log.error(f"Failed to send streaming response: {err}", exc_info=True)
|
|
except Exception as err:
|
|
log.error(f"Error during streaming response: {err}", exc_info=True)
|
|
|
|
async def _send_error(self, writer: asyncio.StreamWriter, error_message: str, request_id: Optional[str] = None):
|
|
"""
|
|
Send error response to client.
|
|
|
|
:param writer: Stream writer.
|
|
:param error_message: Error message.
|
|
:param request_id: Optional request ID to include in the response.
|
|
"""
|
|
message = Message(type=MessageType.RESPONSE, content={"error": error_message}, request_id=request_id)
|
|
await self._send_response(writer, message)
|
|
|
|
async def _handle_start_chat(self, message: Message, writer: asyncio.StreamWriter):
|
|
"""
|
|
Handle request for starting chat.
|
|
|
|
:param message: Request message.
|
|
:param writer: Stream writer to send response.
|
|
"""
|
|
log.debug("start chat")
|
|
self.convo_id = uuid.uuid4()
|
|
response = Message(
|
|
type=MessageType.START_CHAT,
|
|
content={"convoId": self.convo_id},
|
|
request_id=message.request_id,
|
|
)
|
|
await self._send_response(writer, response)
|
|
|
|
async def _handle_get_chat_history(self, message: Message, writer: asyncio.StreamWriter):
|
|
log.debug("get chat history")
|
|
|
|
convo_id = uuid.UUID(message.content.get("convoId", ""))
|
|
if not convo_id:
|
|
await self._send_error(writer, "convoId is required", message.request_id)
|
|
return
|
|
|
|
# Get chat history for the given convo_id
|
|
db_chat_history = await self.state_manager.get_chat_history(convo_id)
|
|
chat_history = []
|
|
|
|
for chat_msg in db_chat_history:
|
|
chat_history.append(
|
|
{
|
|
"role": chat_msg.message_type,
|
|
"content": chat_msg.message,
|
|
"id": chat_msg.id,
|
|
}
|
|
)
|
|
response = Message(
|
|
type=MessageType.GET_CHAT_HISTORY,
|
|
content={"chatHistory": chat_history},
|
|
request_id=message.request_id,
|
|
)
|
|
await self._send_response(writer, response)
|
|
|
|
async def _handle_epics_and_tasks(self, message: Message, writer: asyncio.StreamWriter):
|
|
"""
|
|
Handle request for epics and tasks.
|
|
|
|
:param message: Request message.
|
|
:param writer: Stream writer to send response.
|
|
"""
|
|
try:
|
|
# Get current state
|
|
epics_and_tasks = await self.state_manager.get_all_epics_and_tasks(self.state_manager.branch.id)
|
|
|
|
# Send response with the same request_id from the incoming message
|
|
response = Message(
|
|
type=MessageType.EPICS_AND_TASKS,
|
|
content={"epicsAndTasks": epics_and_tasks},
|
|
request_id=message.request_id, # Include the request_id from the incoming message
|
|
)
|
|
log.debug(f"Sending epics and tasks response with request_id: {message.request_id}")
|
|
await self._send_response(writer, response)
|
|
|
|
except Exception as err:
|
|
log.error(f"Error handling epics and tasks request: {err}", exc_info=True)
|
|
await self._send_error(writer, f"Internal server error: {str(err)}", message.request_id)
|
|
|
|
async def _handle_project_info(self, message: Message, writer: asyncio.StreamWriter):
|
|
try:
|
|
project_details = self.state_manager.get_project_info()
|
|
response = Message(
|
|
type=MessageType.PROJECT_INFO,
|
|
content=project_details,
|
|
request_id=message.request_id,
|
|
)
|
|
log.debug(f"Sending project info with request_id: {message.request_id}")
|
|
await self._send_response(writer, response)
|
|
|
|
except Exception as err:
|
|
log.error(f"Error handling project info request: {err}", exc_info=True)
|
|
await self._send_error(writer, f"Internal server error: {str(err)}", message.request_id)
|
|
|
|
async def _handle_knowledge_base(self, message: Message, writer: asyncio.StreamWriter):
|
|
try:
|
|
state = self.state_manager.current_state
|
|
if message.content and message.content.get("projectStateId", None) is not None:
|
|
state = await self.state_manager.get_project_state_by_id(
|
|
uuid.UUID(message.content.get("projectStateId", ""))
|
|
)
|
|
|
|
if not state:
|
|
await self._send_error(writer, "Project state not found", message.request_id)
|
|
return
|
|
|
|
# Convert KnowledgeBase object to dictionary for JSON serialization
|
|
knowledge_base_dict = {
|
|
"pages": state.knowledge_base.pages,
|
|
"apis": state.knowledge_base.apis,
|
|
"user_options": state.knowledge_base.user_options,
|
|
"utility_functions": state.knowledge_base.utility_functions,
|
|
}
|
|
|
|
response = Message(
|
|
type=MessageType.KNOWLEDGE_BASE,
|
|
content={
|
|
"projectStateId": state.id,
|
|
"knowledgeBase": knowledge_base_dict,
|
|
},
|
|
request_id=message.request_id,
|
|
)
|
|
log.debug(f"Sending knowledge base with request_id: {message.request_id}")
|
|
await self._send_response(writer, response)
|
|
|
|
except Exception as err:
|
|
log.error(f"Error handling knowledge base request: {err}", exc_info=True)
|
|
await self._send_error(writer, f"Internal server error: {str(err)}", message.request_id)
|
|
|
|
async def _handle_project_specs(self, message: Message, writer: asyncio.StreamWriter):
|
|
try:
|
|
state = self.state_manager.current_state
|
|
|
|
if not state:
|
|
await self._send_error(writer, "Project state not found", message.request_id)
|
|
return
|
|
|
|
response = Message(
|
|
type=MessageType.PROJECT_SPECS,
|
|
content={
|
|
"projectStateId": state.id,
|
|
"projectSpecification": state.specification.description,
|
|
},
|
|
request_id=message.request_id,
|
|
)
|
|
log.debug(f"Sending knowledge base with request_id: {message.request_id}")
|
|
await self._send_response(writer, response)
|
|
|
|
except Exception as err:
|
|
log.error(f"Error handling knowledge base request: {err}", exc_info=True)
|
|
await self._send_error(writer, f"Internal server error: {str(err)}", message.request_id)
|
|
|
|
async def _handle_chat_message(self, message: Message, writer: asyncio.StreamWriter):
|
|
"""
|
|
Handle chat message with streaming response.
|
|
|
|
:param message: Request message.
|
|
:param writer: Stream writer to send response.
|
|
"""
|
|
try:
|
|
chat_message = message.content.get("message", "")
|
|
if not chat_message:
|
|
raise ValueError("Chat message is empty")
|
|
|
|
# Stream the response
|
|
await self._send_streaming_response(
|
|
writer,
|
|
message,
|
|
)
|
|
|
|
except Exception as err:
|
|
log.error(f"Error handling chat message request: {err}", exc_info=True)
|
|
await self._send_error(writer, f"Internal server error: {str(err)}", message.request_id)
|