Skip to content

πŸ™Œ 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__.py
index 8f2e987fd7..6b1f0e9764 100644
--- a/enterprise/storage/__init__.py
+++ b/enterprise/storage/__init__.py
@@ -2,7 +2,6 @@ from storage.api_key import ApiKey
from storage.auth_tokens import AuthTokens
from storage.billing_session import BillingSession
from storage.billing_session_type import BillingSessionType
-from storage.conversation_callback import CallbackStatus, ConversationCallback
from storage.conversation_work import ConversationWork
from storage.feedback import ConversationFeedback, Feedback
from 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.py
index 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 same
metadata 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 inference
with Mapped types, while remaining backward compatible with existing Column()
diff --git a/enterprise/storage/conversation_callback.py b/enterprise/storage/conversation_callback.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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