π OpenHands: AI-Driven Development
Remove ConversationCallback class (replaced by V1 EventCallback) (#14159)
Tim O'Farrell273c38f0b610
diff --git a/enterprise/storage/__init__.py b/enterprise/storage/__init__.pyindex 8f2e987fd7..6b1f0e9764 100644--- a/enterprise/storage/__init__.py+++ b/enterprise/storage/__init__.py@@ -2,7 +2,6 @@ from storage.api_key import ApiKeyfrom storage.auth_tokens import AuthTokensfrom storage.billing_session import BillingSessionfrom storage.billing_session_type import BillingSessionType-from storage.conversation_callback import CallbackStatus, ConversationCallbackfrom storage.conversation_work import ConversationWorkfrom storage.feedback import ConversationFeedback, Feedbackfrom storage.github_app_installation import GithubAppInstallation@@ -45,8 +44,6 @@ __all__ = ['AuthTokens','BillingSession','BillingSessionType',- 'CallbackStatus',- 'ConversationCallback','ConversationFeedback','StoredConversationMetadataSaas','ConversationWork',diff --git a/enterprise/storage/base.py b/enterprise/storage/base.pyindex 306cb94a93..3faccf1fe7 100644--- a/enterprise/storage/base.py+++ b/enterprise/storage/base.py@@ -3,7 +3,7 @@ Unified SQLAlchemy declarative base for all models.Re-exports the core Base to ensure enterprise and core models share the samemetadata registry. This allows foreign key relationships between enterprise-models (e.g., ConversationCallback) and core models (e.g., StoredConversationMetadata).+models and core models (e.g., StoredConversationMetadata).The core Base now uses SQLAlchemy 2.0 DeclarativeBase for proper type inferencewith Mapped types, while remaining backward compatible with existing Column()diff --git a/enterprise/storage/conversation_callback.py b/enterprise/storage/conversation_callback.pydeleted file mode 100644index 7d3ec50f63..0000000000--- a/enterprise/storage/conversation_callback.py+++ /dev/null@@ -1,115 +0,0 @@-from __future__ import annotations--from typing import TYPE_CHECKING--if TYPE_CHECKING:- from openhands.events.observation.agent import AgentStateChangedObservation--from abc import ABC, abstractmethod-from datetime import datetime-from enum import Enum--from pydantic import BaseModel, ConfigDict-from sqlalchemy import DateTime, ForeignKey, String, Text, text-from sqlalchemy import Enum as SQLEnum-from sqlalchemy.orm import Mapped, mapped_column-from storage.base import Base--from openhands.utils.import_utils import get_impl---class ConversationCallbackProcessor(BaseModel, ABC):- """- Abstract base class for conversation callback processors.-- Conversation processors are invoked when events occur in a conversation- to perform additional processing, notifications, or integrations.- """-- model_config = ConfigDict(- # Allow extra fields for flexibility- extra='allow',- # Allow arbitrary types- arbitrary_types_allowed=True,- )-- @abstractmethod- async def __call__(- self,- callback: ConversationCallback,- observation: 'AgentStateChangedObservation',- ) -> None:- """- Process a conversation event.-- Args:- conversation_id: The ID of the conversation to process- observation: The AgentStateChangedObservation that triggered the callback- callback: The conversation callback- """---class CallbackStatus(Enum):- """Status of a conversation callback."""-- ACTIVE = 'ACTIVE'- COMPLETED = 'COMPLETED'- ERROR = 'ERROR'---class ConversationCallback(Base):- """- Model for storing conversation callbacks that process conversation events.- """-- __tablename__ = 'conversation_callbacks'-- id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)- conversation_id: Mapped[str] = mapped_column(- String,- ForeignKey('conversation_metadata.conversation_id'),- nullable=False,- index=True,- )- status: Mapped[CallbackStatus] = mapped_column(- SQLEnum(CallbackStatus), nullable=False, default=CallbackStatus.ACTIVE- )- processor_type: Mapped[str] = mapped_column(String, nullable=False)- processor_json: Mapped[str] = mapped_column(Text, nullable=False)- created_at: Mapped[datetime] = mapped_column(- DateTime,- server_default=text('CURRENT_TIMESTAMP'),- nullable=False,- )- updated_at: Mapped[datetime] = mapped_column(- DateTime,- server_default=text('CURRENT_TIMESTAMP'),- onupdate=datetime.now,- nullable=False,- )-- def get_processor(self) -> ConversationCallbackProcessor:- """- Get the processor instance from the stored processor type and JSON data.-- Returns:- ConversationCallbackProcessor: The processor instance- """- # Import the processor class dynamically- processor_class: type[ConversationCallbackProcessor] = get_impl(- ConversationCallbackProcessor, self.processor_type- )- processor = processor_class.model_validate_json(self.processor_json)- return processor-- def set_processor(self, processor: ConversationCallbackProcessor) -> None:- """- Set the processor instance, storing its type and JSON representation.-- Args:- processor: The ConversationCallbackProcessor instance to store- """- self.processor_type = (- f'{processor.__class__.__module__}.{processor.__class__.__name__}'- )- self.processor_json = processor.model_dump_json()diff --git a/enterprise/tests/unit/test_conversation_callback_processor.py b/enterprise/tests/unit/test_conversation_callback_processor.pydeleted file mode 100644index 6892eba251..0000000000--- a/enterprise/tests/unit/test_conversation_callback_processor.py+++ /dev/null@@ -1,195 +0,0 @@-"""-Tests for ConversationCallbackProcessor and ConversationCallback models.-"""--import json-from uuid import UUID--import pytest-from storage.conversation_callback import (- CallbackStatus,- ConversationCallback,- ConversationCallbackProcessor,-)-from storage.stored_conversation_metadata import StoredConversationMetadata-from storage.stored_conversation_metadata_saas import (- StoredConversationMetadataSaas,-)--from openhands.events.observation.agent import AgentStateChangedObservation---class MockConversationCallbackProcessor(ConversationCallbackProcessor):- """Mock implementation of ConversationCallbackProcessor for testing."""-- name: str = 'test'- config: dict = {}-- def __init__(self, name: str = 'test', config: dict | None = None, **kwargs):- super().__init__(name=name, config=config or {}, **kwargs)- self.call_count = 0- self.last_conversation_id: str | None = None-- def __call__(- self, callback: ConversationCallback, observation: AgentStateChangedObservation- ) -> None:- """Mock implementation that tracks calls."""- self.call_count += 1- self.last_conversation_id = callback.conversation_id---class TestConversationCallbackProcessor:- """Test the ConversationCallbackProcessor abstract base class."""-- def test_mock_processor_creation(self):- """Test that we can create a mock processor."""- processor = MockConversationCallbackProcessor(- name='test_processor', config={'key': 'value'}- )- assert processor.name == 'test_processor'- assert processor.config == {'key': 'value'}- assert processor.call_count == 0- assert processor.last_conversation_id is None-- def test_mock_processor_call(self):- """Test that the mock processor can be called."""- callback = ConversationCallback(conversation_id='test_conversation_id')- processor = MockConversationCallbackProcessor()- processor(- callback,- AgentStateChangedObservation('foobar', 'awaiting_user_input'),- )-- assert processor.call_count == 1- assert processor.last_conversation_id == 'test_conversation_id'-- def test_processor_serialization(self):- """Test that processors can be serialized to JSON."""- processor = MockConversationCallbackProcessor(- name='test', config={'setting': 'value'}- )- json_data = processor.model_dump_json()-- # Should be able to parse the JSON- data = json.loads(json_data)- assert data['name'] == 'test'- assert data['config'] == {'setting': 'value'}---class TestConversationCallback:- """Test the ConversationCallback SQLAlchemy model."""-- @pytest.fixture- def conversation_metadata(self, session_maker):- """Create a test conversation metadata record."""- with session_maker() as session:- metadata = StoredConversationMetadata(- conversation_id='test_conversation_123'- )- metadata_saas = StoredConversationMetadataSaas(- conversation_id='test_conversation_123',- user_id=UUID('5594c7b6-f959-4b81-92e9-b09c206f5081'),- org_id=UUID('5594c7b6-f959-4b81-92e9-b09c206f5081'),- )- session.add(metadata)- session.add(metadata_saas)- session.commit()- session.refresh(metadata)- yield metadata-- # Cleanup- session.delete(metadata)- session.delete(metadata_saas)- session.commit()-- def test_callback_creation(self, conversation_metadata, session_maker):- """Test creating a conversation callback."""- processor = MockConversationCallbackProcessor(name='test_processor')-- with session_maker() as session:- callback = ConversationCallback(- conversation_id=conversation_metadata.conversation_id,- status=CallbackStatus.ACTIVE,- processor_type='tests.unit.test_conversation_processor.MockConversationCallbackProcessor',- processor_json=processor.model_dump_json(),- )- session.add(callback)- session.commit()- session.refresh(callback)-- assert callback.id is not None- assert callback.conversation_id == conversation_metadata.conversation_id- assert callback.status == CallbackStatus.ACTIVE- assert callback.created_at is not None- assert callback.updated_at is not None-- # Cleanup- session.delete(callback)- session.commit()-- def test_set_processor(self, conversation_metadata, session_maker):- """Test setting a processor on a callback."""- processor = MockConversationCallbackProcessor(- name='test_processor', config={'key': 'value'}- )-- callback = ConversationCallback(- conversation_id=conversation_metadata.conversation_id- )- callback.set_processor(processor)-- assert (- callback.processor_type- == 'enterprise.tests.unit.test_conversation_callback_processor.MockConversationCallbackProcessor'- )-- # Verify the JSON contains the processor data- processor_data = json.loads(callback.processor_json)- assert processor_data['name'] == 'test_processor'- assert processor_data['config'] == {'key': 'value'}-- def test_get_processor(self, conversation_metadata, session_maker):- """Test getting a processor from a callback."""- processor = MockConversationCallbackProcessor(- name='test_processor', config={'key': 'value'}- )-- callback = ConversationCallback(- conversation_id=conversation_metadata.conversation_id- )- callback.set_processor(processor)-- # Get the processor back- retrieved_processor = callback.get_processor()-- assert isinstance(retrieved_processor, MockConversationCallbackProcessor)- assert retrieved_processor.name == 'test_processor'- assert retrieved_processor.config == {'key': 'value'}-- def test_callback_status_enum(self):- """Test the CallbackStatus enum."""- assert CallbackStatus.ACTIVE.value == 'ACTIVE'- assert CallbackStatus.COMPLETED.value == 'COMPLETED'- assert CallbackStatus.ERROR.value == 'ERROR'-- def test_callback_foreign_key_constraint(- self, conversation_metadata, session_maker- ):- """Test that the foreign key constraint works."""- with session_maker() as session:- # This should work with valid conversation_id- callback = ConversationCallback(- conversation_id=conversation_metadata.conversation_id,- processor_type='test.Processor',- processor_json='{}',- )- session.add(callback)- session.commit()-- # Cleanup- session.delete(callback)- session.commit()-- # Note: SQLite doesn't enforce foreign key constraints by default in tests- # In a real PostgreSQL database, this would raise an integrity error- # For now, we just test that the callback can be created with valid data