π OpenHands: AI-Driven Development
Nested Conversation Support (#8588)
tofarra3d1a923536d
diff --git a/frontend/src/components/features/conversation-panel/conversation-state-indicator.tsx b/frontend/src/components/features/conversation-panel/conversation-state-indicator.tsxindex c0132c2496..46191b0654 100644--- a/frontend/src/components/features/conversation-panel/conversation-state-indicator.tsx+++ b/frontend/src/components/features/conversation-panel/conversation-state-indicator.tsx@@ -2,11 +2,12 @@ import ColdIcon from "./state-indicators/cold.svg?react";import RunningIcon from "./state-indicators/running.svg?react";type SVGIcon = React.FunctionComponent<React.SVGProps<SVGSVGElement>>;-export type ProjectStatus = "RUNNING" | "STOPPED";+export type ProjectStatus = "RUNNING" | "STOPPED" | "STARTING";const INDICATORS: Record<ProjectStatus, SVGIcon> = {STOPPED: ColdIcon,RUNNING: RunningIcon,+ STARTING: ColdIcon,};interface ConversationStateIndicatorProps {diff --git a/frontend/src/context/ws-client-provider.tsx b/frontend/src/context/ws-client-provider.tsxindex 1ba87763d3..4fedab7ee3 100644--- a/frontend/src/context/ws-client-provider.tsx+++ b/frontend/src/context/ws-client-provider.tsx@@ -269,7 +269,7 @@ export function WsClientProvider({if (!conversationId) {throw new Error("No conversation ID provided");}- if (!conversation) {+ if (!conversation || conversation.status === "STARTING") {return () => undefined; // conversation not yet loaded}@@ -309,7 +309,7 @@ export function WsClientProvider({sio.off("connect_failed", handleError);sio.off("disconnect", handleDisconnect);};- }, [conversationId, conversation?.url]);+ }, [conversationId, conversation?.url, conversation?.status]);React.useEffect(() => () => {diff --git a/frontend/src/hooks/query/use-user-conversation.ts b/frontend/src/hooks/query/use-user-conversation.tsindex 5cd141dd99..82653f4a25 100644--- a/frontend/src/hooks/query/use-user-conversation.ts+++ b/frontend/src/hooks/query/use-user-conversation.ts@@ -1,6 +1,9 @@import { useQuery } from "@tanstack/react-query";import OpenHands from "#/api/open-hands";+const FIVE_MINUTES = 1000 * 60 * 5;+const FIFTEEN_MINUTES = 1000 * 60 * 15;+export const useUserConversation = (cid: string | null) =>useQuery({queryKey: ["user", "conversation", cid],@@ -11,6 +14,12 @@ export const useUserConversation = (cid: string | null) =>},enabled: !!cid,retry: false,- staleTime: 1000 * 60 * 5, // 5 minutes- gcTime: 1000 * 60 * 15, // 15 minutes+ refetchInterval: (query) => {+ if (query.state.data?.status === "STARTING") {+ return 2000; // 2 seconds+ }+ return FIVE_MINUTES;+ },+ staleTime: FIVE_MINUTES,+ gcTime: FIFTEEN_MINUTES,});diff --git a/openhands/events/nested_event_store.py b/openhands/events/nested_event_store.pynew file mode 100644index 0000000000..81ee382462--- /dev/null+++ b/openhands/events/nested_event_store.py@@ -0,0 +1,73 @@+from dataclasses import dataclass+from typing import Iterable+from urllib.parse import urlencode++import httpx # type: ignore++from openhands.events.event import Event+from openhands.events.event_filter import EventFilter+from openhands.events.event_store_abc import EventStoreABC+from openhands.events.serialization.event import event_from_dict+++@dataclass+class NestedEventStore(EventStoreABC):+ """+ A stored list of events backing a conversation+ """++ base_url: str+ sid: str+ user_id: str | None++ def search_events(+ self,+ start_id: int = 0,+ end_id: int | None = None,+ reverse: bool = False,+ filter: EventFilter | None = None,+ limit: int | None = None,+ ) -> Iterable[Event]:+ while True:+ search_params = {+ 'start_id': start_id,+ 'reverse': reverse,+ }+ if limit is not None:+ search_params['limit'] = min(100, limit)+ search_str = urlencode(search_params)+ url = f'{self.base_url}/events{search_str}'+ response = httpx.get(url)+ result_set = response.json()+ for result in result_set['results']:+ event = event_from_dict(result)+ start_id = event.id+ if end_id == event.id:+ if not filter or filter.include(event):+ yield event+ return+ if filter and filter.exclude(event):+ continue+ yield event+ if limit is not None:+ limit -= 1+ if limit <= 0:+ return+ if not result_set['has_more']:+ return++ def get_event(self, id: int) -> Event:+ events = list(self.search_events(start_id=id, limit=1))+ if not events:+ raise FileNotFoundError('no_event')+ return events[0]++ def get_latest_event(self) -> Event:+ events = list(self.search_events(reverse=True, limit=1))+ if not events:+ raise FileNotFoundError('no_event')+ return events[0]++ def get_latest_event_id(self) -> int:+ event = self.get_latest_event()+ return event.iddiff --git a/openhands/runtime/base.py b/openhands/runtime/base.pyindex b494e380e3..c1f349c35f 100644--- a/openhands/runtime/base.py+++ b/openhands/runtime/base.py@@ -118,9 +118,10 @@ class Runtime(FileEditRuntimeMixin):)self.sid = sidself.event_stream = event_stream- self.event_stream.subscribe(- EventStreamSubscriber.RUNTIME, self.on_event, self.sid- )+ if event_stream:+ event_stream.subscribe(+ EventStreamSubscriber.RUNTIME, self.on_event, self.sid+ )self.plugins = (copy.deepcopy(plugins) if plugins is not None and len(plugins) > 0 else [])@@ -267,9 +268,10 @@ class Runtime(FileEditRuntimeMixin):returntry:- await self.provider_handler.set_event_stream_secrets(- self.event_stream, env_vars=env_vars- )+ if self.event_stream:+ await self.provider_handler.set_event_stream_secrets(+ self.event_stream, env_vars=env_vars+ )self.add_env_vars(self.provider_handler.expose_env_vars(env_vars))except Exception as e:logger.warning(diff --git a/openhands/runtime/impl/docker/docker_runtime.py b/openhands/runtime/impl/docker/docker_runtime.pyindex 883877cafe..cbde7410d8 100644--- a/openhands/runtime/impl/docker/docker_runtime.py+++ b/openhands/runtime/impl/docker/docker_runtime.py@@ -23,7 +23,7 @@ from openhands.runtime.impl.action_execution.action_execution_client import (from openhands.runtime.impl.docker.containers import stop_all_containersfrom openhands.runtime.plugins import PluginRequirementfrom openhands.runtime.utils import find_available_tcp_port-from openhands.runtime.utils.command import get_action_execution_server_startup_command+from openhands.runtime.utils.command import DEFAULT_MAIN_MODULE, get_action_execution_server_startup_commandfrom openhands.runtime.utils.log_streamer import LogStreamerfrom openhands.runtime.utils.runtime_build import build_runtime_imagefrom openhands.utils.async_utils import call_sync_from_async@@ -38,10 +38,10 @@ APP_PORT_RANGE_1 = (50000, 54999)APP_PORT_RANGE_2 = (55000, 59999)-def _is_retryable_wait_until_alive_error(exception):+def _is_retryablewait_until_alive_error(exception):if isinstance(exception, tenacity.RetryError):cause = exception.last_attempt.exception()- return _is_retryable_wait_until_alive_error(cause)+ return _is_retryablewait_until_alive_error(cause)return isinstance(exception,@@ -51,6 +51,7 @@ def _is_retryable_wait_until_alive_error(exception):httpx.NetworkError,httpx.RemoteProtocolError,httpx.HTTPStatusError,+ httpx.ReadTimeout,),)@@ -80,6 +81,7 @@ class DockerRuntime(ActionExecutionClient):status_callback: Callable | None = None,attach_to_existing: bool = False,headless_mode: bool = True,+ main_module: str = DEFAULT_MAIN_MODULE,):if not DockerRuntime._shutdown_listener_id:DockerRuntime._shutdown_listener_id = add_shutdown_listener(@@ -109,6 +111,7 @@ class DockerRuntime(ActionExecutionClient):self.runtime_container_image = self.config.sandbox.runtime_container_imageself.container_name = CONTAINER_NAME_PREFIX + sidself.container: Container | None = None+ self.main_module = main_moduleself.runtime_builder = DockerRuntimeBuilder(self.docker_client)@@ -148,25 +151,11 @@ class DockerRuntime(ActionExecutionClient):f'Container {self.container_name} not found.',)raise AgentRuntimeDisconnectedError from e- if self.runtime_container_image is None:- if self.base_container_image is None:- raise ValueError(- 'Neither runtime container image nor base container image is set'- )- self.send_status_message('STATUS$STARTING_CONTAINER')- self.runtime_container_image = build_runtime_image(- self.base_container_image,- self.runtime_builder,- platform=self.config.sandbox.platform,- extra_deps=self.config.sandbox.runtime_extra_deps,- force_rebuild=self.config.sandbox.force_rebuild_runtime,- extra_build_args=self.config.sandbox.runtime_extra_build_args,- )-+ self.maybe_build_runtime_container_image()self.log('info', f'Starting runtime with image: {self.runtime_container_image}')- await call_sync_from_async(self._init_container)+ await call_sync_from_async(self.init_container)self.log('info',f'Container started: {self.container_name}. VSCode URL: {self.vscode_url}',@@ -181,7 +170,7 @@ class DockerRuntime(ActionExecutionClient):self.log('info', f'Waiting for client to become ready at {self.api_url}...')self.send_status_message('STATUS$WAITING_FOR_CLIENT')- await call_sync_from_async(self._wait_until_alive)+ await call_sync_from_async(self.wait_until_alive)if not self.attach_to_existing:self.log('info', 'Runtime is ready.')@@ -197,6 +186,22 @@ class DockerRuntime(ActionExecutionClient):self.send_status_message(' ')self._runtime_initialized = True+ def maybe_build_runtime_container_image(self):+ if self.runtime_container_image is None:+ if self.base_container_image is None:+ raise ValueError(+ 'Neither runtime container image nor base container image is set'+ )+ self.send_status_message('STATUS$STARTING_CONTAINER')+ self.runtime_container_image = build_runtime_image(+ self.base_container_image,+ self.runtime_builder,+ platform=self.config.sandbox.platform,+ extra_deps=self.config.sandbox.runtime_extra_deps,+ force_rebuild=self.config.sandbox.force_rebuild_runtime,+ extra_build_args=self.config.sandbox.runtime_extra_build_args,+ )+@staticmethod@lru_cache(maxsize=1)def _init_docker_client() -> docker.DockerClient:@@ -256,7 +261,7 @@ class DockerRuntime(ActionExecutionClient):return volumes- def _init_container(self):+ def init_container(self):self.log('debug', 'Preparing to start container...')self.send_status_message('STATUS$PREPARING_CONTAINER')self._host_port = self._find_available_port(EXECUTION_SERVER_PORT_RANGE)@@ -336,11 +341,7 @@ class DockerRuntime(ActionExecutionClient):f'Sandbox workspace: {self.config.workspace_mount_path_in_sandbox}',)- command = get_action_execution_server_startup_command(- server_port=self._container_port,- plugins=self.plugins,- app_config=self.config,- )+ command = self.get_action_execution_server_startup_command()try:self.container = self.docker_client.containers.run(@@ -371,7 +372,7 @@ class DockerRuntime(ActionExecutionClient):f'Container {self.container_name} already exists. Removing...',)stop_all_containers(self.container_name)- return self._init_container()+ return self.init_container()else:self.log(@@ -421,11 +422,11 @@ class DockerRuntime(ActionExecutionClient):@tenacity.retry(stop=tenacity.stop_after_delay(120) | stop_if_should_exit(),- retry=tenacity.retry_if_exception(_is_retryable_wait_until_alive_error),+ retry=tenacity.retry_if_exception(_is_retryablewait_until_alive_error),reraise=True,wait=tenacity.wait_fixed(2),)- def _wait_until_alive(self):+ def wait_until_alive(self):try:container = self.docker_client.containers.get(self.container_name)if container.status == 'exited':@@ -519,7 +520,7 @@ class DockerRuntime(ActionExecutionClient):self.log('debug', f'Container {self.container_name} resumed')# Wait for the container to be ready- self._wait_until_alive()+ self.wait_until_alive()@classmethodasync def delete(cls, conversation_id: str):@@ -534,3 +535,11 @@ class DockerRuntime(ActionExecutionClient):passfinally:docker_client.close()++ def get_action_execution_server_startup_command(self):+ return get_action_execution_server_startup_command(+ server_port=self._container_port,+ plugins=self.plugins,+ app_config=self.config,+ main_module=self.main_module,+ )diff --git a/openhands/runtime/impl/remote/remote_runtime.py b/openhands/runtime/impl/remote/remote_runtime.pyindex 746a53f3ab..bd0d252505 100644--- a/openhands/runtime/impl/remote/remote_runtime.py+++ b/openhands/runtime/impl/remote/remote_runtime.py@@ -24,7 +24,7 @@ from openhands.runtime.impl.action_execution.action_execution_client import (ActionExecutionClient,)from openhands.runtime.plugins import PluginRequirement-from openhands.runtime.utils.command import get_action_execution_server_startup_command+from openhands.runtime.utils.command import DEFAULT_MAIN_MODULE, get_action_execution_server_startup_commandfrom openhands.runtime.utils.request import send_requestfrom openhands.runtime.utils.runtime_build import build_runtime_imagefrom openhands.utils.async_utils import call_sync_from_async@@ -41,6 +41,7 @@ class RemoteRuntime(ActionExecutionClient):runtime_builder: RemoteRuntimeBuildercontainer_image: stravailable_hosts: dict[str, int]+ main_module: strdef __init__(self,@@ -54,6 +55,7 @@ class RemoteRuntime(ActionExecutionClient):headless_mode: bool = True,user_id: str | None = None,git_provider_tokens: PROVIDER_TOKEN_TYPE | None = None,+ main_module: str = DEFAULT_MAIN_MODULE,) -> None:super().__init__(config,@@ -85,6 +87,7 @@ class RemoteRuntime(ActionExecutionClient):)assert self.config.sandbox.remote_runtime_class in (None, 'sysbox', 'gvisor')+ self.main_module = main_moduleself.runtime_builder = RemoteRuntimeBuilder(self.config.sandbox.remote_runtime_api_url,@@ -231,11 +234,7 @@ class RemoteRuntime(ActionExecutionClient):def _start_runtime(self) -> None:# Prepare the request body for the /start endpoint- command = get_action_execution_server_startup_command(- server_port=self.port,- plugins=self.plugins,- app_config=self.config,- )+ command = self.get_action_execution_server_startup_command()environment: dict[str, str] = {}if self.config.debug or os.environ.get('DEBUG', 'false').lower() == 'true':environment['DEBUG'] = 'true'@@ -492,3 +491,11 @@ class RemoteRuntime(ActionExecutionClient):def _stop_if_closed(self, retry_state: RetryCallState) -> bool:return self._runtime_closed++ def get_action_execution_server_startup_command(self):+ return get_action_execution_server_startup_command(+ server_port=self.port,+ plugins=self.plugins,+ app_config=self.config,+ main_module=self.main_module,+ )diff --git a/openhands/runtime/utils/command.py b/openhands/runtime/utils/command.pyindex b2485d09fb..66787b2e28 100644--- a/openhands/runtime/utils/command.py+++ b/openhands/runtime/utils/command.py@@ -9,6 +9,7 @@ DEFAULT_PYTHON_PREFIX = ['poetry','run',]+DEFAULT_MAIN_MODULE = 'openhands.runtime.action_execution_server'def get_action_execution_server_startup_command(@@ -18,6 +19,7 @@ def get_action_execution_server_startup_command(python_prefix: list[str] = DEFAULT_PYTHON_PREFIX,override_user_id: int | None = None,override_username: str | None = None,+ main_module: str = DEFAULT_MAIN_MODULE,) -> list[str]:sandbox_config = app_config.sandbox@@ -45,7 +47,7 @@ def get_action_execution_server_startup_command('python','-u','-m',- 'openhands.runtime.action_execution_server',+ main_module,str(server_port),'--working-dir',app_config.workspace_mount_path_in_sandbox,diff --git a/openhands/server/__main__.py b/openhands/server/__main__.pynew file mode 100644index 0000000000..b2f621014b--- /dev/null+++ b/openhands/server/__main__.py@@ -0,0 +1,16 @@+import os++import uvicorn+++def main():+ uvicorn.run(+ 'openhands.server.listen:app',+ host='0.0.0.0',+ port=int(os.environ.get('port') or '3000'),+ log_level='debug' if os.environ.get('DEBUG') else 'info',+ )+++if __name__ == '__main__':+ main()diff --git a/openhands/server/app.py b/openhands/server/app.pyindex 8869488b0f..82fab085a8 100644--- a/openhands/server/app.py+++ b/openhands/server/app.py@@ -17,6 +17,7 @@ from openhands.server.routes.conversation import app as conversation_api_routerfrom openhands.server.routes.feedback import app as feedback_api_routerfrom openhands.server.routes.files import app as files_api_routerfrom openhands.server.routes.git import app as git_api_router+from openhands.server.routes.health import add_health_endpointsfrom openhands.server.routes.manage_conversations import (app as manage_conversation_api_router,)@@ -44,11 +45,6 @@ app = FastAPI()[email protected]('/health')-async def health() -> str:- return 'OK'--app.include_router(public_api_router)app.include_router(files_api_router)app.include_router(security_api_router)@@ -59,3 +55,4 @@ app.include_router(settings_router)app.include_router(secrets_router)app.include_router(git_api_router)app.include_router(trajectory_router)+add_health_endpoints(app)diff --git a/openhands/server/config/server_config.py b/openhands/server/config/server_config.pyindex 9dbf83c93f..3ae9cf9910 100644--- a/openhands/server/config/server_config.py+++ b/openhands/server/config/server_config.py@@ -21,7 +21,10 @@ class ServerConfig(ServerConfigInterface):conversation_store_class: str = ('openhands.storage.conversation.file_conversation_store.FileConversationStore')- conversation_manager_class: str = 'openhands.server.conversation_manager.standalone_conversation_manager.StandaloneConversationManager'+ conversation_manager_class: str = os.environ.get(+ "CONVERSATION_MANAGER_CLASS",+ 'openhands.server.conversation_manager.standalone_conversation_manager.StandaloneConversationManager',+ )monitoring_listener_class: str = 'openhands.server.monitoring.MonitoringListener'user_auth_class: str = ('openhands.server.user_auth.default_user_auth.DefaultUserAuth'diff --git a/openhands/server/conversation_manager/docker_nested_conversation_manager.py b/openhands/server/conversation_manager/docker_nested_conversation_manager.pynew file mode 100644index 0000000000..f60dc7310a--- /dev/null+++ b/openhands/server/conversation_manager/docker_nested_conversation_manager.py@@ -0,0 +1,464 @@+from __future__ import annotations++import asyncio+import hashlib+import os+from base64 import urlsafe_b64encode+from dataclasses import dataclass, field+from types import MappingProxyType+from typing import Any, cast++import docker+import httpx+import socketio+from docker.models.containers import Container+from fastapi import status++from openhands.controller.agent import Agent+from openhands.core.config import AppConfig+from openhands.core.logger import openhands_logger as logger+from openhands.events.action import MessageAction+from openhands.events.nested_event_store import NestedEventStore+from openhands.events.stream import EventStream+from openhands.integrations.provider import PROVIDER_TOKEN_TYPE, ProviderHandler+from openhands.llm.llm import LLM+from openhands.runtime.impl.docker.containers import stop_all_containers+from openhands.runtime.impl.docker.docker_runtime import DockerRuntime+from openhands.server.config.server_config import ServerConfig+from openhands.server.conversation_manager.conversation_manager import (+ ConversationManager,+)+from openhands.server.data_models.agent_loop_info import AgentLoopInfo+from openhands.server.monitoring import MonitoringListener+from openhands.server.session.conversation import Conversation+from openhands.server.session.conversation_init_data import ConversationInitData+from openhands.server.session.session import ROOM_KEY, Session+from openhands.storage.conversation.conversation_store import ConversationStore+from openhands.storage.data_models.conversation_metadata import ConversationMetadata+from openhands.storage.data_models.conversation_status import ConversationStatus+from openhands.storage.data_models.settings import Settings+from openhands.storage.files import FileStore+from openhands.storage.locations import get_conversation_dir+from openhands.utils.async_utils import call_sync_from_async+from openhands.utils.import_utils import get_impl+++@dataclass+class DockerNestedConversationManager(ConversationManager):+ """Conversation manager where the agent loops exist inside the docker containers."""++ sio: socketio.AsyncServer+ config: AppConfig+ server_config: ServerConfig+ file_store: FileStore+ docker_client: docker.DockerClient = field(default_factory=docker.from_env)+ _conversation_store_class: type[ConversationStore] | None = None+ _starting_conversation_ids: set[str] = field(default_factory=set)++ async def __aenter__(self):+ # No action is required on startup for this implementation+ pass++ async def __aexit__(self, exc_type, exc_value, traceback):+ # No action is required on shutdown for this implementation+ pass++ async def attach_to_conversation(+ self, sid: str, user_id: str | None = None+ ) -> Conversation | None:+ # Not supported - clients should connect directly to the nested server!+ raise ValueError('unsupported_operation')++ async def detach_from_conversation(self, conversation: Conversation):+ # Not supported - clients should connect directly to the nested server!+ raise ValueError('unsupported_operation')++ async def join_conversation(+ self,+ sid: str,+ connection_id: str,+ settings: Settings,+ user_id: str | None,+ ) -> AgentLoopInfo:+ # Not supported - clients should connect directly to the nested server!+ raise ValueError('unsupported_operation')++ async def get_running_agent_loops(+ self, user_id: str | None = None, filter_to_sids: set[str] | None = None+ ) -> set[str]:+ """+ Get the running agent loops directly from docker.+ """+ names = (container.name for container in self.docker_client.containers.list())+ conversation_ids = {+ name[len('openhands-runtime-') :]+ for name in names+ if name.startswith('openhands-runtime-')+ }+ if filter_to_sids is not None:+ conversation_ids = {+ conversation_id+ for conversation_id in conversation_ids+ if conversation_id in filter_to_sids+ }+ return conversation_ids++ async def get_connections(+ self, user_id: str | None = None, filter_to_sids: set[str] | None = None+ ) -> dict[str, str]:+ # We don't monitor connections outside the nested server, though we could introduce an API for this.+ results: dict[str, str] = {}+ return results++ async def maybe_start_agent_loop(+ self,+ sid: str,+ settings: Settings,+ user_id: str | None,+ initial_user_msg: MessageAction | None = None,+ replay_json: str | None = None,+ ) -> AgentLoopInfo:+ if not await self.is_agent_loop_running(sid):+ await self._start_agent_loop(+ sid, settings, user_id, initial_user_msg, replay_json+ )++ nested_url = self._get_nested_url(sid)+ return AgentLoopInfo(+ conversation_id=sid,+ url=nested_url,+ session_api_key=self._get_session_api_key_for_conversation(sid),+ event_store=NestedEventStore(+ base_url=nested_url,+ sid=sid,+ user_id=user_id,+ ),+ status=ConversationStatus.STARTING+ if sid in self._starting_conversation_ids+ else ConversationStatus.RUNNING,+ )++ async def _start_agent_loop(+ self,+ sid: str,+ settings: Settings,+ user_id: str | None,+ initial_user_msg: MessageAction | None,+ replay_json: str | None,+ ):+ logger.info(f'starting_agent_loop:{sid}', extra={'session_id': sid})+ await self.ensure_num_conversations_below_limit(sid, user_id)+ runtime = await self._create_runtime(sid, user_id, settings)+ self._starting_conversation_ids.add(sid)+ try:+ # Build the runtime container image if it is missing+ await call_sync_from_async(runtime.maybe_build_runtime_container_image)++ # initialize the container but dont wait for it to start+ await call_sync_from_async(runtime.init_container)++ # Start the conversation in a background task.+ asyncio.create_task(+ self._start_conversation(+ sid,+ settings,+ runtime,+ initial_user_msg,+ replay_json,+ runtime.api_url,+ )+ )++ except Exception:+ self._starting_conversation_ids.remove(sid)+ raise++ async def _start_conversation(+ self,+ sid: str,+ settings: Settings,+ runtime: DockerRuntime,+ initial_user_msg: MessageAction | None,+ replay_json: str | None,+ api_url: str,+ ):+ try:+ await call_sync_from_async(runtime.wait_until_alive)+ await call_sync_from_async(runtime.setup_initial_env)+ async with httpx.AsyncClient(+ headers={+ 'X-Session-API-Key': self._get_session_api_key_for_conversation(sid)+ }+ ) as client:+ # setup the settings...+ settings_json = settings.model_dump(context={'expose_secrets': True})+ settings_json.pop('custom_secrets', None)+ settings_json.pop('git_provider_tokens', None)+ secrets_store = settings_json.pop('secrets_store', None) or {}+ response = await client.post(+ f'{api_url}/api/settings', json=settings_json+ )+ assert response.status_code == status.HTTP_200_OK++ # Setup provider tokens+ provider_handler = self._get_provider_handler(settings)+ provider_tokens = provider_handler.provider_tokens+ if provider_tokens:+ provider_tokens_json = {+ k.value: {+ 'token': v.token.get_secret_value(),+ 'user_id': v.user_id,+ 'host': v.host,+ }+ for k, v in provider_tokens.items()+ if v.token+ }+ response = await client.post(+ f'{api_url}/api/add-git-providers',+ json={+ 'provider_tokens': provider_tokens_json,+ },+ )+ assert response.status_code == status.HTTP_200_OK++ # Setup custom secrets+ custom_secrets = secrets_store.get('custom_secrets') or {}+ if custom_secrets:+ for key, value in custom_secrets.items():+ response = await client.post(+ f'{api_url}/api/secrets',+ json={+ 'name': key,+ 'description': value.description,+ 'value': value.value,+ },+ )+ assert response.status_code == status.HTTP_200_OK++ init_conversation: dict[str, Any] = {+ 'initial_user_msg': initial_user_msg,+ 'image_urls': [],+ 'replay_json': replay_json,+ 'conversation_id': sid,+ }++ if isinstance(settings, ConversationInitData):+ init_conversation['repository'] = settings.selected_repository+ init_conversation['selected_branch'] = settings.selected_branch+ init_conversation['git_provider'] = (+ settings.git_provider.value if settings.git_provider else None+ )++ # Create conversation+ response = await client.post(+ f'{api_url}/api/conversations', json=init_conversation+ )+ logger.info(+ f'_start_agent_loop:{response.status_code}:{response.json()}'+ )+ assert response.status_code == status.HTTP_200_OK+ finally:+ self._starting_conversation_ids.remove(sid)++ async def send_to_event_stream(self, connection_id: str, data: dict):+ # Not supported - clients should connect directly to the nested server!+ raise ValueError('unsupported_operation')++ async def disconnect_from_session(self, connection_id: str):+ # Not supported - clients should connect directly to the nested server!+ raise ValueError('unsupported_operation')++ async def close_session(self, sid: str):+ stop_all_containers(f'openhands-runtime-{sid}')++ async def get_agent_loop_info(self, user_id=None, filter_to_sids=None):+ results = []+ containers = self.docker_client.containers.list()+ for container in containers:+ if not container.name.startswith('openhands-runtime-'):+ continue+ conversation_id = container.name[len('openhands-runtime-') :]+ if filter_to_sids is not None and conversation_id not in filter_to_sids:+ continue+ nested_url = self.get_nested_url_for_container(container)+ if os.getenv('NESTED_RUNTIME_BROWSER_HOST', '') != '':+ # This should be set to http://localhost if you're running OH inside a docker container+ nested_url = nested_url.replace(+ self.config.sandbox.local_runtime_url,+ os.getenv('NESTED_RUNTIME_BROWSER_HOST', ''),+ )+ agent_loop_info = AgentLoopInfo(+ conversation_id=conversation_id,+ url=nested_url,+ session_api_key=self._get_session_api_key_for_conversation(+ conversation_id+ ),+ event_store=NestedEventStore(+ base_url=nested_url,+ sid=conversation_id,+ user_id=user_id,+ ),+ status=ConversationStatus.STARTING+ if conversation_id in self._starting_conversation_ids+ else ConversationStatus.RUNNING,+ )+ results.append(agent_loop_info)+ return results++ @classmethod+ def get_instance(+ cls,+ sio: socketio.AsyncServer,+ config: AppConfig,+ file_store: FileStore,+ server_config: ServerConfig,+ monitoring_listener: MonitoringListener,+ ) -> ConversationManager:+ return DockerNestedConversationManager(+ sio=sio,+ config=config,+ server_config=server_config,+ file_store=file_store,+ )++ async def _get_conversation_store(self, user_id: str | None) -> ConversationStore:+ conversation_store_class = self._conversation_store_class+ if not conversation_store_class:+ self._conversation_store_class = conversation_store_class = get_impl(+ ConversationStore, # type: ignore+ self.server_config.conversation_store_class,+ )+ store = await conversation_store_class.get_instance(self.config, user_id)+ return store++ def _get_nested_url(self, sid: str) -> str:+ container = self.docker_client.containers.get(f'openhands-runtime-{sid}')+ return self.get_nested_url_for_container(container)++ def get_nested_url_for_container(self, container: Container) -> str:+ env = container.attrs['Config']['Env']+ container_port = int(next(e[5:] for e in env if e.startswith('port=')))+ conversation_id = container.name[len('openhands-runtime-') :]+ nested_url = f'{self.config.sandbox.local_runtime_url}:{container_port}/api/conversations/{conversation_id}'+ return nested_url++ def _get_session_api_key_for_conversation(self, conversation_id: str):+ jwt_secret = self.config.jwt_secret.get_secret_value() # type:ignore+ conversation_key = f'{jwt_secret}:{conversation_id}'.encode()+ session_api_key = (+ urlsafe_b64encode(hashlib.sha256(conversation_key).digest())+ .decode()+ .replace('=', '')+ )+ return session_api_key++ async def ensure_num_conversations_below_limit(self, sid: str, user_id: str | None):+ response_ids = await self.get_running_agent_loops(user_id)+ if len(response_ids) >= self.config.max_concurrent_conversations:+ logger.info(+ f'too_many_sessions_for:{user_id or ""}',+ extra={'session_id': sid, 'user_id': user_id},+ )+ # Get the conversations sorted (oldest first)+ conversation_store = await self._get_conversation_store(user_id)+ conversations = await conversation_store.get_all_metadata(response_ids)+ conversations.sort(key=_last_updated_at_key, reverse=True)++ while len(conversations) >= self.config.max_concurrent_conversations:+ oldest_conversation_id = conversations.pop().conversation_id+ logger.debug(+ f'closing_from_too_many_sessions:{user_id or ""}:{oldest_conversation_id}',+ extra={'session_id': oldest_conversation_id, 'user_id': user_id},+ )+ # Send status message to client and close session.+ status_update_dict = {+ 'status_update': True,+ 'type': 'error',+ 'id': 'AGENT_ERROR$TOO_MANY_CONVERSATIONS',+ 'message': 'Too many conversations at once. If you are still using this one, try reactivating it by prompting the agent to continue',+ }+ await self.sio.emit(+ 'oh_event',+ status_update_dict,+ to=ROOM_KEY.format(sid=oldest_conversation_id),+ )+ await self.close_session(oldest_conversation_id)++ def _get_provider_handler(self, settings: Settings):+ provider_tokens = None+ if isinstance(settings, ConversationInitData):+ provider_tokens = settings.git_provider_tokens+ provider_handler = ProviderHandler(+ provider_tokens=provider_tokens+ or cast(PROVIDER_TOKEN_TYPE, MappingProxyType({}))+ )+ return provider_handler++ async def _create_runtime(self, sid: str, user_id: str | None, settings: Settings):+ # This session is created here only because it is the easiest way to get a runtime, which+ # is the easiest way to create the needed docker container+ session = Session(+ sid=sid,+ file_store=self.file_store,+ config=self.config,+ sio=self.sio,+ user_id=user_id,+ )+ agent_cls = settings.agent or self.config.default_agent+ agent_name = agent_cls if agent_cls is not None else 'agent'+ llm = LLM(+ config=self.config.get_llm_config_from_agent(agent_name),+ retry_listener=session._notify_on_llm_retry,+ )+ llm = session._create_llm(agent_cls)+ agent_config = self.config.get_agent_config(agent_cls)+ agent = Agent.get_cls(agent_cls)(llm, agent_config)++ config = self.config.model_copy(deep=True)+ env_vars = config.sandbox.runtime_startup_env_vars+ env_vars['CONVERSATION_MANAGER_CLASS'] = (+ 'openhands.server.conversation_manager.standalone_conversation_manager.StandaloneConversationManager'+ )+ env_vars['SERVE_FRONTEND'] = '0'+ env_vars['RUNTIME'] = 'local'+ env_vars['USER'] = 'CURRENT_USER'+ env_vars['SESSION_API_KEY'] = self._get_session_api_key_for_conversation(sid)++ # Set up mounted volume for conversation directory within workspace+ # TODO: Check if we are using the standard event store and file store+ volumes = config.sandbox.volumes+ if not config.sandbox.volumes:+ volumes = []+ else:+ volumes = [v.strip() for v in config.sandbox.volumes.split(',')]+ conversation_dir = get_conversation_dir(sid, user_id)+ volumes.append(+ f'{config.file_store_path}/{conversation_dir}:{AppConfig.model_fields["file_store_path"].default}/{conversation_dir}:rw'+ )+ config.sandbox.volumes = ','.join(volumes)++ # Currently this eventstream is never used and only exists because one is required in order to create a docker runtime+ event_stream = EventStream(sid, self.file_store, user_id)++ runtime = DockerRuntime(+ config=config,+ event_stream=event_stream,+ sid=sid,+ plugins=agent.sandbox_plugins,+ headless_mode=False,+ attach_to_existing=False,+ env_vars=env_vars,+ main_module='openhands.server',+ )++ # Hack - disable setting initial env.+ runtime.setup_initial_env = lambda: None # type:ignore++ return runtime+++def _last_updated_at_key(conversation: ConversationMetadata) -> float:+ last_updated_at = conversation.last_updated_at+ if last_updated_at is None:+ return 0.0+ return last_updated_at.timestamp()diff --git a/openhands/server/data_models/agent_loop_info.py b/openhands/server/data_models/agent_loop_info.pyindex 34eedfa1e0..894afe3693 100644--- a/openhands/server/data_models/agent_loop_info.py+++ b/openhands/server/data_models/agent_loop_info.py@@ -1,6 +1,7 @@-from dataclasses import dataclass+from dataclasses import dataclass, fieldfrom openhands.events.event_store_abc import EventStoreABC+from openhands.storage.data_models.conversation_status import ConversationStatus@dataclass@@ -11,4 +12,5 @@ class AgentLoopInfo:conversation_id: strurl: str | Nonesession_api_key: str | None- event_store: EventStoreABC+ event_store: EventStoreABC | None+ status: ConversationStatus = field(default=ConversationStatus.RUNNING)diff --git a/openhands/server/middleware.py b/openhands/server/middleware.pyindex 1e5d391751..32994fc0ec 100644--- a/openhands/server/middleware.py+++ b/openhands/server/middleware.py@@ -204,11 +204,7 @@ class SessionApiKeyMiddleware:async def __call__(self, request: Request, call_next: RequestResponseEndpoint) -> Response:- if (- request.method != 'OPTIONS'- and request.url.path != '/alive'- and request.url.path != '/server_info'- ):+ if request.method != 'OPTIONS' and request.url.path.startswith('/api'):if self.session_api_key != request.headers.get('X-Session-API-Key'):return JSONResponse({'code': 'invalid_session_api_key'},diff --git a/openhands/server/routes/health.py b/openhands/server/routes/health.pynew file mode 100644index 0000000000..7027115251--- /dev/null+++ b/openhands/server/routes/health.py@@ -0,0 +1,39 @@+import time+from fastapi import FastAPI, Request++from openhands.runtime.utils.system_stats import get_system_stats++start_time = time.time()+last_execution_time = start_time++def add_health_endpoints(app: FastAPI):+ @app.get('/alive')+ async def alive():+ return {'status': 'ok'}+++ @app.get('/health')+ async def health() -> str:+ return 'OK'+++ @app.get('/server_info')+ async def get_server_info():+ current_time = time.time()+ uptime = current_time - start_time+ idle_time = current_time - last_execution_time++ response = {+ 'uptime': uptime,+ 'idle_time': idle_time,+ 'resources': get_system_stats(),+ }+ return response+++ @app.middleware("http")+ async def update_last_execution_time(request: Request, call_next):+ global last_execution_time+ response = await call_next(request)+ last_execution_time = time.time()+ return responsediff --git a/openhands/server/routes/manage_conversations.py b/openhands/server/routes/manage_conversations.pyindex 6a088b141c..c26ad6dcf7 100644--- a/openhands/server/routes/manage_conversations.py+++ b/openhands/server/routes/manage_conversations.py@@ -1,15 +1,13 @@+import asyncioimport uuidfrom datetime import datetime, timezone-from typing import Anyfrom fastapi import APIRouter, Depends, statusfrom fastapi.responses import JSONResponse-from pydantic import BaseModel+from pydantic import BaseModel, Fieldfrom openhands.core.logger import openhands_logger as logger-from openhands.events.action.message import MessageActionfrom openhands.integrations.provider import (- CUSTOM_SECRETS_TYPE_WITH_JSON_SCHEMA,PROVIDER_TOKEN_TYPE,ProviderHandler,)@@ -24,10 +22,9 @@ from openhands.server.data_models.conversation_info import ConversationInfofrom openhands.server.data_models.conversation_info_result_set import (ConversationInfoResultSet,)-from openhands.server.session.conversation_init_data import ConversationInitData+from openhands.server.services.conversation import create_new_conversationfrom openhands.server.shared import (ConversationStoreImpl,- SettingsStoreImpl,config,conversation_manager,)@@ -62,6 +59,7 @@ class InitSessionRequest(BaseModel):replay_json: str | None = Nonesuggested_task: SuggestedTask | None = Noneconversation_instructions: str | None = None+ conversation_id: str = Field(default_factory=lambda: uuid.uuid4().hex)model_config = {'extra': 'forbid'}@@ -69,112 +67,11 @@ class InitSessionRequest(BaseModel):class InitSessionResponse(BaseModel):status: strconversation_id: str- conversation_url: str- session_api_key: str | Nonemessage: str | None = None-async def _create_new_conversation(- user_id: str | None,- git_provider_tokens: PROVIDER_TOKEN_TYPE | None,- custom_secrets: CUSTOM_SECRETS_TYPE_WITH_JSON_SCHEMA | None,- selected_repository: str | None,- selected_branch: str | None,- initial_user_msg: str | None,- image_urls: list[str] | None,- replay_json: str | None,- conversation_instructions: str | None = None,- conversation_trigger: ConversationTrigger = ConversationTrigger.GUI,- attach_convo_id: bool = False,-) -> AgentLoopInfo:- logger.info(- 'Creating conversation',- extra={- 'signal': 'create_conversation',- 'user_id': user_id,- 'trigger': conversation_trigger.value,- },- )- logger.info('Loading settings')- settings_store = await SettingsStoreImpl.get_instance(config, user_id)- settings = await settings_store.load()- logger.info('Settings loaded')-- session_init_args: dict[str, Any] = {}- if settings:- session_init_args = {**settings.__dict__, **session_init_args}- # We could use litellm.check_valid_key for a more accurate check,- # but that would run a tiny inference.- if (- not settings.llm_api_key- or settings.llm_api_key.get_secret_value().isspace()- ):- logger.warning(f'Missing api key for model {settings.llm_model}')- raise LLMAuthenticationError(- 'Error authenticating with the LLM provider. Please check your API key'- )-- else:- logger.warning('Settings not present, not starting conversation')- raise MissingSettingsError('Settings not found')-- session_init_args['git_provider_tokens'] = git_provider_tokens- session_init_args['selected_repository'] = selected_repository- session_init_args['custom_secrets'] = custom_secrets- session_init_args['selected_branch'] = selected_branch- session_init_args['conversation_instructions'] = conversation_instructions- conversation_init_data = ConversationInitData(**session_init_args)- logger.info('Loading conversation store')- conversation_store = await ConversationStoreImpl.get_instance(config, user_id)- logger.info('Conversation store loaded')-- conversation_id = uuid.uuid4().hex- while await conversation_store.exists(conversation_id):- logger.warning(f'Collision on conversation ID: {conversation_id}. Retrying...')- conversation_id = uuid.uuid4().hex- logger.info(- f'New conversation ID: {conversation_id}',- extra={'user_id': user_id, 'session_id': conversation_id},- )-- conversation_title = get_default_conversation_title(conversation_id)-- logger.info(f'Saving metadata for conversation {conversation_id}')- await conversation_store.save_metadata(- ConversationMetadata(- trigger=conversation_trigger,- conversation_id=conversation_id,- title=conversation_title,- user_id=user_id,- selected_repository=selected_repository,- selected_branch=selected_branch,- )- )-- logger.info(- f'Starting agent loop for conversation {conversation_id}',- extra={'user_id': user_id, 'session_id': conversation_id},- )- initial_message_action = None- if initial_user_msg or image_urls:- user_msg = (- initial_user_msg.format(conversation_id)- if attach_convo_id and initial_user_msg- else initial_user_msg- )- initial_message_action = MessageAction(- content=user_msg or '',- image_urls=image_urls or [],- )- agent_loop_info = await conversation_manager.maybe_start_agent_loop(- conversation_id,- conversation_init_data,- user_id,- initial_user_msg=initial_message_action,- replay_json=replay_json,- )- logger.info(f'Finished initializing conversation {agent_loop_info.conversation_id}')- return agent_loop_info+# Temporary alias since the private variable was referenced publicly - delete once deploy project is updated.+_create_new_conversation = create_new_conversation@app.post('/conversations')@@ -190,7 +87,7 @@ async def new_conversation(After successful initialization, the client should connect to the WebSocketusing the returned conversation ID."""- logger.info('Initializing new conversation')+ logger.info(f'initializing_new_conversation:{data}')repository = data.repositoryselected_branch = data.selected_branchinitial_user_msg = data.initial_user_msg@@ -215,8 +112,8 @@ async def new_conversation(# Check against git_provider, otherwise check all provider apisawait provider_handler.verify_repo_provider(repository, git_provider)- # Create conversation with initial message- agent_loop_info = await _create_new_conversation(+ conversation_id = data.conversation_id+ await create_new_conversation(user_id=user_id,git_provider_tokens=provider_tokens,custom_secrets=user_secrets.custom_secrets if user_secrets else None,@@ -226,14 +123,14 @@ async def new_conversation(image_urls=image_urls,replay_json=replay_json,conversation_trigger=conversation_trigger,- conversation_instructions=conversation_instructions+ conversation_instructions=conversation_instructions,+ git_provider=git_provider,+ conversation_id=conversation_id,)return InitSessionResponse(status='ok',- conversation_id=agent_loop_info.conversation_id,- conversation_url=agent_loop_info.url,- session_api_key=agent_loop_info.session_api_key,+ conversation_id=conversation_id,)except MissingSettingsError as e:return JSONResponse(@@ -270,7 +167,6 @@ async def new_conversation(async def search_conversations(page_id: str | None = None,limit: int = 20,- user_id: str | None = Depends(get_user_id),conversation_store: ConversationStore = Depends(get_conversation_store),) -> ConversationInfoResultSet:conversation_metadata_result_set = await conversation_store.search(page_id, limit)@@ -289,9 +185,6 @@ async def search_conversations(conversation_ids = set(conversation.conversation_id for conversation in filtered_results)- running_conversations = await conversation_manager.get_running_agent_loops(- user_id, conversation_ids- )connection_ids_to_conversation_ids = await conversation_manager.get_connections(filter_to_sids=conversation_ids)agent_loop_info = await conversation_manager.get_agent_loop_info(filter_to_sids=conversation_ids)agent_loop_info_by_conversation_id = {info.conversation_id: info for info in agent_loop_info}@@ -299,7 +192,6 @@ async def search_conversations(results=await wait_all(_get_conversation_info(conversation=conversation,- is_running=conversation.conversation_id in running_conversations,num_connections=sum(1 for conversation_id in connection_ids_to_conversation_ids.values()if conversation_id == conversation.conversation_id@@ -321,11 +213,10 @@ async def get_conversation() -> ConversationInfo | None:try:metadata = await conversation_store.get_metadata(conversation_id)- is_running = await conversation_manager.is_agent_loop_running(conversation_id)num_connections = len(await conversation_manager.get_connections(filter_to_sids={conversation_id}))agent_loop_infos = await conversation_manager.get_agent_loop_info(filter_to_sids={conversation_id})agent_loop_info = agent_loop_infos[0] if agent_loop_infos else None- conversation_info = await _get_conversation_info(metadata, is_running, num_connections, agent_loop_info)+ conversation_info = await _get_conversation_info(metadata, num_connections, agent_loop_info)return conversation_infoexcept FileNotFoundError:return None@@ -352,7 +243,6 @@ async def delete_conversation(async def _get_conversation_info(conversation: ConversationMetadata,- is_running: bool,num_connections: int,agent_loop_info: AgentLoopInfo | None,) -> ConversationInfo | None:@@ -368,7 +258,7 @@ async def _get_conversation_info(created_at=conversation.created_at,selected_repository=conversation.selected_repository,status=(- ConversationStatus.RUNNING if is_running else ConversationStatus.STOPPED+ agent_loop_info.status if agent_loop_info else ConversationStatus.STOPPED),num_connections=num_connections,url=agent_loop_info.url if agent_loop_info else None,diff --git a/openhands/server/services/conversation.py b/openhands/server/services/conversation.pynew file mode 100644index 0000000000..79692aa619--- /dev/null+++ b/openhands/server/services/conversation.py@@ -0,0 +1,122 @@+++from typing import Any+import uuid+from openhands.core.logger import openhands_logger as logger+from openhands.events.action.message import MessageAction+from openhands.integrations.provider import CUSTOM_SECRETS_TYPE_WITH_JSON_SCHEMA, PROVIDER_TOKEN_TYPE+from openhands.integrations.service_types import ProviderType+from openhands.server.data_models.agent_loop_info import AgentLoopInfo+from openhands.server.session.conversation_init_data import ConversationInitData+from openhands.server.shared import ConversationStoreImpl, SettingsStoreImpl, config, conversation_manager+from openhands.server.types import LLMAuthenticationError, MissingSettingsError+from openhands.storage.data_models.conversation_metadata import ConversationMetadata, ConversationTrigger+from openhands.utils.conversation_summary import get_default_conversation_title+++async def create_new_conversation(+ user_id: str | None,+ git_provider_tokens: PROVIDER_TOKEN_TYPE | None,+ custom_secrets: CUSTOM_SECRETS_TYPE_WITH_JSON_SCHEMA | None,+ selected_repository: str | None,+ selected_branch: str | None,+ initial_user_msg: str | None,+ image_urls: list[str] | None,+ replay_json: str | None,+ conversation_instructions: str | None = None,+ conversation_trigger: ConversationTrigger = ConversationTrigger.GUI,+ attach_convo_id: bool = False,+ git_provider: ProviderType | None = None,+ conversation_id: str | None = None,+) -> AgentLoopInfo:+ logger.info(+ 'Creating conversation',+ extra={+ 'signal': 'create_conversation',+ 'user_id': user_id,+ 'trigger': conversation_trigger.value,+ },+ )+ logger.info('Loading settings')+ settings_store = await SettingsStoreImpl.get_instance(config, user_id)+ settings = await settings_store.load()+ logger.info('Settings loaded')++ session_init_args: dict[str, Any] = {}+ if settings:+ session_init_args = {**settings.__dict__, **session_init_args}+ # We could use litellm.check_valid_key for a more accurate check,+ # but that would run a tiny inference.+ if (+ not settings.llm_api_key+ or settings.llm_api_key.get_secret_value().isspace()+ ):+ logger.warning(f'Missing api key for model {settings.llm_model}')+ raise LLMAuthenticationError(+ 'Error authenticating with the LLM provider. Please check your API key'+ )++ else:+ logger.warning('Settings not present, not starting conversation')+ raise MissingSettingsError('Settings not found')++ session_init_args['git_provider_tokens'] = git_provider_tokens+ session_init_args['selected_repository'] = selected_repository+ session_init_args['custom_secrets'] = custom_secrets+ session_init_args['selected_branch'] = selected_branch+ session_init_args['git_provider'] = git_provider+ session_init_args['conversation_instructions'] = conversation_instructions+ conversation_init_data = ConversationInitData(**session_init_args)+ logger.info('Loading conversation store')+ conversation_store = await ConversationStoreImpl.get_instance(config, user_id)+ logger.info('Conversation store loaded')++ # For nested runtimes, we allow a single conversation id, passed in on container creation+ if conversation_id is None:+ conversation_id = uuid.uuid4().hex+ while await conversation_store.exists(conversation_id):+ logger.warning(f'Collision on conversation ID: {conversation_id}. Retrying...')+ conversation_id = uuid.uuid4().hex+ logger.info(+ f'New conversation ID: {conversation_id}',+ extra={'user_id': user_id, 'session_id': conversation_id},+ )++ conversation_title = get_default_conversation_title(conversation_id)++ logger.info(f'Saving metadata for conversation {conversation_id}')+ await conversation_store.save_metadata(+ ConversationMetadata(+ trigger=conversation_trigger,+ conversation_id=conversation_id,+ title=conversation_title,+ user_id=user_id,+ selected_repository=selected_repository,+ selected_branch=selected_branch,+ )+ )++ logger.info(+ f'Starting agent loop for conversation {conversation_id}',+ extra={'user_id': user_id, 'session_id': conversation_id},+ )+ initial_message_action = None+ if initial_user_msg or image_urls:+ user_msg = (+ initial_user_msg.format(conversation_id)+ if attach_convo_id and initial_user_msg+ else initial_user_msg+ )+ initial_message_action = MessageAction(+ content=user_msg or '',+ image_urls=image_urls or [],+ )+ agent_loop_info = await conversation_manager.maybe_start_agent_loop(+ conversation_id,+ conversation_init_data,+ user_id,+ initial_user_msg=initial_message_action,+ replay_json=replay_json,+ )+ logger.info(f'Finished initializing conversation {agent_loop_info.conversation_id}')+ return agent_loop_infodiff --git a/openhands/server/session/conversation_init_data.py b/openhands/server/session/conversation_init_data.pyindex 18acbb3806..ea3f1f4d6b 100644--- a/openhands/server/session/conversation_init_data.py+++ b/openhands/server/session/conversation_init_data.py@@ -1,6 +1,7 @@from pydantic import Fieldfrom openhands.integrations.provider import CUSTOM_SECRETS_TYPE, PROVIDER_TOKEN_TYPE+from openhands.integrations.service_types import ProviderTypefrom openhands.storage.data_models.settings import Settings@@ -15,6 +16,7 @@ class ConversationInitData(Settings):replay_json: str | None = Field(default=None)selected_branch: str | None = Field(default=None)conversation_instructions: str | None = Field(default=None)+ git_provider: ProviderType | None = Field(default=None)model_config = {'arbitrary_types_allowed': True,diff --git a/openhands/storage/data_models/conversation_status.py b/openhands/storage/data_models/conversation_status.pyindex 8d476fa4e3..fdbdab5575 100644--- a/openhands/storage/data_models/conversation_status.py+++ b/openhands/storage/data_models/conversation_status.py@@ -2,5 +2,6 @@ from enum import Enumclass ConversationStatus(Enum):+ STARTING = 'STARTING'RUNNING = 'RUNNING'STOPPED = 'STOPPED'diff --git a/tests/unit/test_conversation.py b/tests/unit/test_conversation.pyindex f79f0008aa..4aca4b9dad 100644--- a/tests/unit/test_conversation.py+++ b/tests/unit/test_conversation.py@@ -157,7 +157,6 @@ async def test_search_conversations():result_set = await search_conversations(page_id=None,limit=20,- user_id='12345',conversation_store=mock_store,)@@ -242,9 +241,9 @@ async def test_get_missing_conversation():async def test_new_conversation_success(provider_handler_mock):"""Test successful creation of a new conversation."""with _patch_store():- # Mock the _create_new_conversation function directly+ # Mock the create_new_conversation function directlywith patch(- 'openhands.server.routes.manage_conversations._create_new_conversation'+ 'openhands.server.routes.manage_conversations.create_new_conversation') as mock_create_conversation:# Set up the mock to return a conversation IDmock_create_conversation.return_value = MagicMock(@@ -258,6 +257,7 @@ async def test_new_conversation_success(provider_handler_mock):selected_branch='main',initial_user_msg='Hello, agent!',image_urls=['https://example.com/image.jpg'],+ conversation_id='test_conversation_id',)# Call new_conversation@@ -267,9 +267,8 @@ async def test_new_conversation_success(provider_handler_mock):assert isinstance(response, InitSessionResponse)assert response.status == 'ok'assert response.conversation_id == 'test_conversation_id'- assert response.conversation_url == 'https://my-conversation.com'- # Verify that _create_new_conversation was called with the correct arguments+ # Verify that create_new_conversation was called with the correct argumentsmock_create_conversation.assert_called_once()call_args = mock_create_conversation.call_args[1]assert call_args['user_id'] == 'test_user'@@ -284,9 +283,9 @@ async def test_new_conversation_success(provider_handler_mock):async def test_new_conversation_with_suggested_task(provider_handler_mock):"""Test creating a new conversation with a suggested task."""with _patch_store():- # Mock the _create_new_conversation function directly+ # Mock the create_new_conversation function directlywith patch(- 'openhands.server.routes.manage_conversations._create_new_conversation'+ 'openhands.server.routes.manage_conversations.create_new_conversation') as mock_create_conversation:# Set up the mock to return a conversation IDmock_create_conversation.return_value = MagicMock(@@ -315,6 +314,7 @@ async def test_new_conversation_with_suggested_task(provider_handler_mock):repository='test/repo',selected_branch='main',suggested_task=test_task,+ conversation_id='test_conversation_id',)# Call new_conversation@@ -324,9 +324,8 @@ async def test_new_conversation_with_suggested_task(provider_handler_mock):assert isinstance(response, InitSessionResponse)assert response.status == 'ok'assert response.conversation_id == 'test_conversation_id'- assert response.conversation_url == 'https://my-conversation.com'- # Verify that _create_new_conversation was called with the correct arguments+ # Verify that create_new_conversation was called with the correct argumentsmock_create_conversation.assert_called_once()call_args = mock_create_conversation.call_args[1]assert call_args['user_id'] == 'test_user'@@ -349,9 +348,9 @@ async def test_new_conversation_with_suggested_task(provider_handler_mock):async def test_new_conversation_missing_settings(provider_handler_mock):"""Test creating a new conversation when settings are missing."""with _patch_store():- # Mock the _create_new_conversation function to raise MissingSettingsError+ # Mock the create_new_conversation function to raise MissingSettingsErrorwith patch(- 'openhands.server.routes.manage_conversations._create_new_conversation'+ 'openhands.server.routes.manage_conversations.create_new_conversation') as mock_create_conversation:# Set up the mock to raise MissingSettingsErrormock_create_conversation.side_effect = MissingSettingsError(@@ -378,9 +377,9 @@ async def test_new_conversation_missing_settings(provider_handler_mock):async def test_new_conversation_invalid_session_api_key(provider_handler_mock):"""Test creating a new conversation with an invalid API key."""with _patch_store():- # Mock the _create_new_conversation function to raise LLMAuthenticationError+ # Mock the create_new_conversation function to raise LLMAuthenticationErrorwith patch(- 'openhands.server.routes.manage_conversations._create_new_conversation'+ 'openhands.server.routes.manage_conversations.create_new_conversation') as mock_create_conversation:# Set up the mock to raise LLMAuthenticationErrormock_create_conversation.side_effect = LLMAuthenticationError(@@ -469,9 +468,9 @@ async def test_delete_conversation():async def test_new_conversation_with_bearer_auth(provider_handler_mock):"""Test creating a new conversation with bearer authentication."""with _patch_store():- # Mock the _create_new_conversation function+ # Mock the create_new_conversation functionwith patch(- 'openhands.server.routes.manage_conversations._create_new_conversation'+ 'openhands.server.routes.manage_conversations.create_new_conversation') as mock_create_conversation:# Set up the mock to return a conversation IDmock_create_conversation.return_value = MagicMock(@@ -494,7 +493,7 @@ async def test_new_conversation_with_bearer_auth(provider_handler_mock):assert isinstance(response, InitSessionResponse)assert response.status == 'ok'- # Verify that _create_new_conversation was called with REMOTE_API_KEY trigger+ # Verify that create_new_conversation was called with REMOTE_API_KEY triggermock_create_conversation.assert_called_once()call_args = mock_create_conversation.call_args[1]assert (@@ -506,9 +505,9 @@ async def test_new_conversation_with_bearer_auth(provider_handler_mock):async def test_new_conversation_with_null_repository():"""Test creating a new conversation with null repository."""with _patch_store():- # Mock the _create_new_conversation function+ # Mock the create_new_conversation functionwith patch(- 'openhands.server.routes.manage_conversations._create_new_conversation'+ 'openhands.server.routes.manage_conversations.create_new_conversation') as mock_create_conversation:# Set up the mock to return a conversation IDmock_create_conversation.return_value = MagicMock(@@ -531,7 +530,7 @@ async def test_new_conversation_with_null_repository():assert isinstance(response, InitSessionResponse)assert response.status == 'ok'- # Verify that _create_new_conversation was called with None repository+ # Verify that create_new_conversation was called with None repositorymock_create_conversation.assert_called_once()call_args = mock_create_conversation.call_args[1]assert call_args['selected_repository'] is None@@ -547,9 +546,9 @@ async def test_new_conversation_with_provider_authentication_error("""Test creating a new conversation when provider authentication fails."""with _patch_store():- # Mock the _create_new_conversation function+ # Mock the create_new_conversation functionwith patch(- 'openhands.server.routes.manage_conversations._create_new_conversation'+ 'openhands.server.routes.manage_conversations.create_new_conversation') as mock_create_conversation:# Set up the mock to return a conversation IDmock_create_conversation.return_value = 'test_conversation_id'@@ -578,7 +577,7 @@ async def test_new_conversation_with_provider_authentication_error('test/repo', None)- # Verify that _create_new_conversation was not called+ # Verify that create_new_conversation was not calledmock_create_conversation.assert_not_called()