kyrlos adel
cva1
7cfdc4c
Raw History Blame Contribute Delete
11.4 kB
import asyncio
import json
from typing import List, Dict, Any, Optional, Type, Union, AsyncGenerator, Literal, cast, TYPE_CHECKING
if TYPE_CHECKING:
from core.jit.config import JITConfig
from core.agentpress.tool import Tool
from core.agentpress.tool_registry import ToolRegistry
from core.agentpress.processor_config import ProcessorConfig
from core.agentpress.error_processor import ErrorProcessor
from core.services.supabase import DBConnection
from core.utils.logger import logger
from langfuse.client import StatefulGenerationClient, StatefulTraceClient
from core.services.langfuse import langfuse
from core.agentpress.thread_manager.services import (
MessageFetcher,
ThreadState,
AutoContinueManager,
BillingHandler,
ExecutionOrchestrator,
)
ToolChoice = Literal["auto", "required", "none"]
class ThreadManager:
def __init__(self, trace: Optional[StatefulTraceClient] = None, agent_config: Optional[dict] = None,
project_id: Optional[str] = None, thread_id: Optional[str] = None, account_id: Optional[str] = None,
jit_config: Optional['JITConfig'] = None):
self.db = DBConnection()
self.tool_registry = ToolRegistry()
self.project_id = project_id
self.thread_id = thread_id
self.account_id = account_id
self.trace = trace
if not self.trace:
self.trace = langfuse.trace(name="anonymous:thread_manager")
self.agent_config = agent_config
self.jit_config = jit_config
self._memory_context: Optional[Dict[str, Any]] = None
self.message_fetcher = MessageFetcher()
self.execution_orchestrator = ExecutionOrchestrator()
def set_memory_context(self, memory_context: Optional[Dict[str, Any]]):
self._memory_context = memory_context
def add_tool(self, tool_class: Type[Tool], function_names: Optional[List[str]] = None, **kwargs):
self.tool_registry.register_tool(tool_class, function_names, **kwargs)
async def create_thread(
self,
account_id: Optional[str] = None,
project_id: Optional[str] = None,
is_public: bool = False,
metadata: Optional[Dict[str, Any]] = None
) -> str:
from core.threads import repo as threads_repo
try:
thread_id = await threads_repo.insert_thread(
account_id=account_id,
project_id=project_id,
is_public=is_public,
metadata=metadata
)
if thread_id:
logger.info(f"Successfully created thread: {thread_id}")
return thread_id
else:
raise Exception("Failed to create thread: no thread_id returned")
except Exception as e:
logger.error(f"Failed to create thread: {str(e)}", exc_info=True)
raise Exception(f"Thread creation failed: {str(e)}")
async def add_message(
self,
thread_id: str,
type: str,
content: Union[Dict[str, Any], List[Any], str],
is_llm_message: bool = False,
metadata: Optional[Dict[str, Any]] = None,
agent_id: Optional[str] = None,
agent_version_id: Optional[str] = None
):
from core.threads import repo as threads_repo
try:
saved_message = await threads_repo.insert_message(
thread_id=thread_id,
message_type=type,
content=content,
is_llm_message=is_llm_message,
metadata=metadata,
agent_id=agent_id,
agent_version_id=agent_version_id
)
if saved_message and 'message_id' in saved_message:
if is_llm_message:
from core.cache.runtime_cache import invalidate_message_history_cache
await invalidate_message_history_cache(thread_id)
if type == "llm_response_end" and isinstance(content, dict):
await BillingHandler.handle(thread_id, content, saved_message, self.account_id)
return saved_message
else:
logger.error(f"Insert operation failed for thread {thread_id}")
return None
except Exception as e:
logger.error(f"Failed to add message to thread {thread_id}: {e}")
return None
async def get_llm_messages(self, thread_id: str, lightweight: bool = False) -> List[Dict[str, Any]]:
return await self.message_fetcher.get_llm_messages(thread_id, lightweight)
async def thread_has_images(self, thread_id: str) -> bool:
return await ThreadState.check_has_images(thread_id)
async def run_thread(
self,
thread_id: str,
system_prompt: Dict[str, Any],
stream: bool = True,
temporary_message: Optional[Dict[str, Any]] = None,
llm_model: str = "gpt-5",
llm_temperature: float = 0,
llm_max_tokens: Optional[int] = None,
processor_config: Optional[ProcessorConfig] = None,
tool_choice: ToolChoice = "auto",
native_max_auto_continues: int = 25,
generation: Optional[StatefulGenerationClient] = None,
latest_user_message_content: Optional[str] = None,
cancellation_event: Optional[asyncio.Event] = None,
prefetch_messages_task: Optional[asyncio.Task] = None,
prefetch_llm_end_task: Optional[asyncio.Task] = None,
) -> Union[Dict[str, Any], AsyncGenerator]:
logger.debug(f"🚀 Starting thread execution for {thread_id} with model {llm_model}")
if processor_config is None:
config = ProcessorConfig()
elif isinstance(processor_config, ProcessorConfig):
config = processor_config
else:
logger.error(f"Invalid processor_config type: {type(processor_config)}, creating default")
config = ProcessorConfig()
auto_continue_state = {
'count': 0,
'active': True,
'continuous_state': {'accumulated_content': '', 'thread_run_id': None},
'force_tool_fallback': False,
'error_retry_count': 0
}
MAX_ERROR_RETRIES = 3
if native_max_auto_continues == 0:
result = await self._execute_run(
thread_id, system_prompt, llm_model, llm_temperature, llm_max_tokens,
tool_choice, config, stream,
generation, auto_continue_state, temporary_message, latest_user_message_content,
cancellation_event, prefetch_messages_task, prefetch_llm_end_task
)
if isinstance(result, dict) and result.get("status") == "error":
return self._create_single_error_generator(result)
return result
return AutoContinueManager.run_generator(
thread_id, system_prompt, llm_model, llm_temperature, llm_max_tokens,
tool_choice, config, stream,
generation, auto_continue_state, temporary_message,
native_max_auto_continues, latest_user_message_content, cancellation_event,
prefetch_messages_task, prefetch_llm_end_task, MAX_ERROR_RETRIES,
self.account_id, self._execute_run
)
async def _execute_run(
self, thread_id: str, system_prompt: Dict[str, Any], llm_model: str,
llm_temperature: float, llm_max_tokens: Optional[int], tool_choice: ToolChoice,
config: ProcessorConfig, stream: bool, generation: Optional[StatefulGenerationClient],
auto_continue_state: Dict[str, Any], temporary_message: Optional[Dict[str, Any]] = None,
latest_user_message_content: Optional[str] = None, cancellation_event: Optional[asyncio.Event] = None,
prefetch_messages_task: Optional[asyncio.Task] = None, prefetch_llm_end_task: Optional[asyncio.Task] = None
) -> Union[Dict[str, Any], AsyncGenerator]:
if not isinstance(config, ProcessorConfig):
logger.error(f"ERROR: config is {type(config)}, expected ProcessorConfig. Value: {config}")
config = ProcessorConfig()
try:
return await self.execution_orchestrator.execute_pipeline(
thread_id=thread_id,
system_prompt=system_prompt,
llm_model=llm_model,
registry_model_id=llm_model,
llm_temperature=llm_temperature,
llm_max_tokens=llm_max_tokens,
tool_choice=tool_choice,
config=config,
stream=stream,
generation=generation,
auto_continue_state=auto_continue_state,
memory_context=self._memory_context,
latest_user_message_content=latest_user_message_content,
cancellation_event=cancellation_event,
prefetch_messages_task=prefetch_messages_task,
prefetch_llm_end_task=prefetch_llm_end_task,
tool_registry=self.tool_registry,
get_llm_messages_func=self.get_llm_messages,
thread_has_images_func=self.thread_has_images,
response_processor=self.response_processor,
db=self.db
)
except Exception as e:
processed_error = ErrorProcessor.process_system_error(e, context={"thread_id": thread_id})
ErrorProcessor.log_error(processed_error)
return processed_error.to_stream_dict()
async def _create_single_error_generator(self, error_dict: Dict[str, Any]):
yield error_dict
async def cleanup(self):
if hasattr(self, 'response_processor') and self.response_processor:
if hasattr(self.response_processor, 'cleanup'):
try:
await self.response_processor.cleanup()
except Exception as e:
logger.warning(f"[ThreadManager] ResponseProcessor cleanup error: {e}")
self.response_processor = None
if hasattr(self, 'tool_registry') and self.tool_registry:
seen_instances = set()
for tool_info in self.tool_registry.tools.values():
tool_instance = tool_info.get('instance')
if tool_instance and id(tool_instance) not in seen_instances:
seen_instances.add(id(tool_instance))
if hasattr(tool_instance, 'cleanup'):
try:
result = tool_instance.cleanup()
if hasattr(result, '__await__'):
await result
except Exception as e:
logger.debug(f"[ThreadManager] Tool cleanup error (non-fatal): {e}")
self.tool_registry.tools.clear()
self.tool_registry = None
# 3. Clear other references
self.message_fetcher = None
self.execution_orchestrator = None
self._memory_context = None
# 4. Langfuse trace cleanup (doesn't hold connections, just metadata)
# Keep trace for final metrics but don't hold reference
if hasattr(self, 'trace'):
self.trace = None