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.
gpt-pilot/core/ui/api_server.py

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)