import os import json import asyncio import datetime from typing import Optional, Dict, List, Any, AsyncGenerator from dataclasses import dataclass from agent.tools.message_tool import MessageTool from agent.tools.sb_deploy_tool import SandboxDeployTool from agent.tools.sb_expose_tool import SandboxExposeTool from agent.tools.web_search_tool import SandboxWebSearchTool from dotenv import load_dotenv from utils.config import config from agent.agent_builder_prompt import get_agent_builder_prompt from agentpress.thread_manager import ThreadManager from agentpress.response_processor import ProcessorConfig from agent.tools.sb_shell_tool import SandboxShellTool from agent.tools.sb_files_tool import SandboxFilesTool from agent.tools.data_providers_tool import DataProvidersTool from agent.tools.expand_msg_tool import ExpandMessageTool from agent.prompt import get_system_prompt from utils.logger import logger from utils.auth_utils import get_account_id_from_thread from services.billing import check_billing_status from agent.tools.sb_vision_tool import SandboxVisionTool from agent.tools.sb_image_edit_tool import SandboxImageEditTool from agent.tools.sb_presentation_outline_tool import SandboxPresentationOutlineTool from agent.tools.sb_presentation_tool import SandboxPresentationTool from services.langfuse import langfuse from langfuse.client import StatefulTraceClient from agent.tools.mcp_tool_wrapper import MCPToolWrapper from agent.tools.task_list_tool import TaskListTool from agentpress.tool import SchemaType from agent.tools.sb_sheets_tool import SandboxSheetsTool from agent.tools.sb_web_dev_tool import SandboxWebDevTool from agent.tools.sb_upload_file_tool import SandboxUploadFileTool load_dotenv() @dataclass class AgentConfig: thread_id: str project_id: str stream: bool native_max_auto_continues: int = 25 max_iterations: int = 100 model_name: str = "openai/gpt-5-mini" enable_thinking: Optional[bool] = False reasoning_effort: Optional[str] = 'low' enable_context_manager: bool = True agent_config: Optional[dict] = None trace: Optional[StatefulTraceClient] = None class ToolManager: def __init__(self, thread_manager: ThreadManager, project_id: str, thread_id: str): self.thread_manager = thread_manager self.project_id = project_id self.thread_id = thread_id def register_all_tools(self, agent_id: Optional[str] = None, disabled_tools: Optional[List[str]] = None): """Register all available tools by default, with optional exclusions. Args: agent_id: Optional agent ID for agent builder tools disabled_tools: List of tool names to exclude from registration """ disabled_tools = disabled_tools or [] logger.debug(f"Registering tools with disabled list: {disabled_tools}") # Core tools - always enabled self._register_core_tools() # Sandbox tools self._register_sandbox_tools(disabled_tools) # Data and utility tools self._register_utility_tools(disabled_tools) # Agent builder tools - register if agent_id provided if agent_id: self._register_agent_builder_tools(agent_id, disabled_tools) # Browser tool self._register_browser_tool(disabled_tools) logger.debug(f"Tool registration complete. Registered tools: {list(self.thread_manager.tool_registry.tools.keys())}") def _register_core_tools(self): """Register core tools that are always available.""" self.thread_manager.add_tool(ExpandMessageTool, thread_id=self.thread_id, thread_manager=self.thread_manager) self.thread_manager.add_tool(MessageTool) self.thread_manager.add_tool(TaskListTool, project_id=self.project_id, thread_manager=self.thread_manager, thread_id=self.thread_id) def _register_sandbox_tools(self, disabled_tools: List[str]): """Register sandbox-related tools.""" sandbox_tools = [ ('sb_shell_tool', SandboxShellTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ('sb_files_tool', SandboxFilesTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ('sb_deploy_tool', SandboxDeployTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ('sb_expose_tool', SandboxExposeTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ('web_search_tool', SandboxWebSearchTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ('sb_vision_tool', SandboxVisionTool, {'project_id': self.project_id, 'thread_id': self.thread_id, 'thread_manager': self.thread_manager}), ('sb_image_edit_tool', SandboxImageEditTool, {'project_id': self.project_id, 'thread_id': self.thread_id, 'thread_manager': self.thread_manager}), ('sb_presentation_outline_tool', SandboxPresentationOutlineTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ('sb_presentation_tool', SandboxPresentationTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ('sb_sheets_tool', SandboxSheetsTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ('sb_web_dev_tool', SandboxWebDevTool, {'project_id': self.project_id, 'thread_id': self.thread_id, 'thread_manager': self.thread_manager}), ('sb_upload_file_tool', SandboxUploadFileTool, {'project_id': self.project_id, 'thread_manager': self.thread_manager}), ] for tool_name, tool_class, kwargs in sandbox_tools: if tool_name not in disabled_tools: self.thread_manager.add_tool(tool_class, **kwargs) logger.debug(f"Registered {tool_name}") def _register_utility_tools(self, disabled_tools: List[str]): """Register utility and data provider tools.""" if config.RAPID_API_KEY and 'data_providers_tool' not in disabled_tools: self.thread_manager.add_tool(DataProvidersTool) logger.debug("Registered data_providers_tool") def _register_agent_builder_tools(self, agent_id: str, disabled_tools: List[str]): """Register agent builder tools.""" from agent.tools.agent_builder_tools.agent_config_tool import AgentConfigTool from agent.tools.agent_builder_tools.mcp_search_tool import MCPSearchTool from agent.tools.agent_builder_tools.credential_profile_tool import CredentialProfileTool from agent.tools.agent_builder_tools.workflow_tool import WorkflowTool from agent.tools.agent_builder_tools.trigger_tool import TriggerTool from services.supabase import DBConnection db = DBConnection() agent_builder_tools = [ ('agent_config_tool', AgentConfigTool), ('mcp_search_tool', MCPSearchTool), ('credential_profile_tool', CredentialProfileTool), ('workflow_tool', WorkflowTool), ('trigger_tool', TriggerTool), ] for tool_name, tool_class in agent_builder_tools: if tool_name not in disabled_tools: self.thread_manager.add_tool(tool_class, thread_manager=self.thread_manager, db_connection=db, agent_id=agent_id) logger.debug(f"Registered {tool_name}") def _register_browser_tool(self, disabled_tools: List[str]): """Register browser tool.""" if 'browser_tool' not in disabled_tools: from agent.tools.browser_tool import BrowserTool self.thread_manager.add_tool(BrowserTool, project_id=self.project_id, thread_id=self.thread_id, thread_manager=self.thread_manager) logger.debug("Registered browser_tool") class MCPManager: def __init__(self, thread_manager: ThreadManager, account_id: str): self.thread_manager = thread_manager self.account_id = account_id async def register_mcp_tools(self, agent_config: dict) -> Optional[MCPToolWrapper]: all_mcps = [] if agent_config.get('configured_mcps'): all_mcps.extend(agent_config['configured_mcps']) if agent_config.get('custom_mcps'): for custom_mcp in agent_config['custom_mcps']: custom_type = custom_mcp.get('customType', custom_mcp.get('type', 'sse')) if custom_type == 'pipedream': if 'config' not in custom_mcp: custom_mcp['config'] = {} if not custom_mcp['config'].get('external_user_id'): profile_id = custom_mcp['config'].get('profile_id') if profile_id: try: from pipedream import profile_service from uuid import UUID profile = await profile_service.get_profile(UUID(self.account_id), UUID(profile_id)) if profile: custom_mcp['config']['external_user_id'] = profile.external_user_id except Exception as e: logger.error(f"Error retrieving external_user_id from profile {profile_id}: {e}") if 'headers' in custom_mcp['config'] and 'x-pd-app-slug' in custom_mcp['config']['headers']: custom_mcp['config']['app_slug'] = custom_mcp['config']['headers']['x-pd-app-slug'] elif custom_type == 'composio': qualified_name = custom_mcp.get('qualifiedName') if not qualified_name: qualified_name = f"composio.{custom_mcp['name'].replace(' ', '_').lower()}" mcp_config = { 'name': custom_mcp['name'], 'qualifiedName': qualified_name, 'config': custom_mcp.get('config', {}), 'enabledTools': custom_mcp.get('enabledTools', []), 'instructions': custom_mcp.get('instructions', ''), 'isCustom': True, 'customType': 'composio' } all_mcps.append(mcp_config) continue mcp_config = { 'name': custom_mcp['name'], 'qualifiedName': f"custom_{custom_type}_{custom_mcp['name'].replace(' ', '_').lower()}", 'config': custom_mcp['config'], 'enabledTools': custom_mcp.get('enabledTools', []), 'instructions': custom_mcp.get('instructions', ''), 'isCustom': True, 'customType': custom_type } all_mcps.append(mcp_config) if not all_mcps: return None mcp_wrapper_instance = MCPToolWrapper(mcp_configs=all_mcps) try: await mcp_wrapper_instance.initialize_and_register_tools() updated_schemas = mcp_wrapper_instance.get_schemas() for method_name, schema_list in updated_schemas.items(): for schema in schema_list: self.thread_manager.tool_registry.tools[method_name] = { "instance": mcp_wrapper_instance, "schema": schema } logger.debug(f"⚡ Registered {len(updated_schemas)} MCP tools (Redis cache enabled)") return mcp_wrapper_instance except Exception as e: logger.error(f"Failed to initialize MCP tools: {e}") return None class PromptManager: @staticmethod async def build_system_prompt(model_name: str, agent_config: Optional[dict], thread_id: str, mcp_wrapper_instance: Optional[MCPToolWrapper], client=None) -> dict: default_system_content = get_system_prompt() if "anthropic" not in model_name.lower(): sample_response_path = os.path.join(os.path.dirname(__file__), 'sample_responses/1.txt') with open(sample_response_path, 'r') as file: sample_response = file.read() default_system_content = default_system_content + "\n\n " + sample_response + "" # Start with agent's normal system prompt or default if agent_config and agent_config.get('system_prompt'): system_content = agent_config['system_prompt'].strip() else: system_content = default_system_content # Check if agent has builder tools enabled - append the full builder prompt if agent_config: agentpress_tools = agent_config.get('agentpress_tools', {}) has_builder_tools = any( agentpress_tools.get(tool, False) for tool in ['agent_config_tool', 'mcp_search_tool', 'credential_profile_tool', 'workflow_tool', 'trigger_tool'] ) if has_builder_tools: # Append the full agent builder prompt to the existing system prompt builder_prompt = get_agent_builder_prompt() system_content += f"\n\n{builder_prompt}" # Add agent knowledge base context if available if agent_config and client and 'agent_id' in agent_config: try: logger.debug(f"Retrieving agent knowledge base context for agent {agent_config['agent_id']}") # Use only agent-based knowledge base context kb_result = await client.rpc('get_agent_knowledge_base_context', { 'p_agent_id': agent_config['agent_id'] }).execute() if kb_result.data and kb_result.data.strip(): logger.debug(f"Found agent knowledge base context, adding to system prompt (length: {len(kb_result.data)} chars)") # logger.debug(f"Knowledge base data object: {kb_result.data[:500]}..." if len(kb_result.data) > 500 else f"Knowledge base data object: {kb_result.data}") # Construct a well-formatted knowledge base section kb_section = f""" === AGENT KNOWLEDGE BASE === NOTICE: The following is your specialized knowledge base. This information should be considered authoritative for your responses and should take precedence over general knowledge when relevant. {kb_result.data} === END AGENT KNOWLEDGE BASE === IMPORTANT: Always reference and utilize the knowledge base information above when it's relevant to user queries. This knowledge is specific to your role and capabilities.""" system_content += kb_section else: logger.debug("No knowledge base context found for this agent") except Exception as e: logger.error(f"Error retrieving knowledge base context for agent {agent_config.get('agent_id', 'unknown')}: {e}") # Continue without knowledge base context rather than failing if agent_config and (agent_config.get('configured_mcps') or agent_config.get('custom_mcps')) and mcp_wrapper_instance and mcp_wrapper_instance._initialized: mcp_info = "\n\n--- MCP Tools Available ---\n" mcp_info += "You have access to external MCP (Model Context Protocol) server tools.\n" mcp_info += "MCP tools can be called directly using their native function names in the standard function calling format:\n" mcp_info += '\n' mcp_info += '\n' mcp_info += 'value1\n' mcp_info += 'value2\n' mcp_info += '\n' mcp_info += '\n\n' mcp_info += "Available MCP tools:\n" try: registered_schemas = mcp_wrapper_instance.get_schemas() for method_name, schema_list in registered_schemas.items(): for schema in schema_list: if schema.schema_type == SchemaType.OPENAPI: func_info = schema.schema.get('function', {}) description = func_info.get('description', 'No description available') mcp_info += f"- **{method_name}**: {description}\n" params = func_info.get('parameters', {}) props = params.get('properties', {}) if props: mcp_info += f" Parameters: {', '.join(props.keys())}\n" except Exception as e: logger.error(f"Error listing MCP tools: {e}") mcp_info += "- Error loading MCP tool list\n" mcp_info += "\n🚨 CRITICAL MCP TOOL RESULT INSTRUCTIONS 🚨\n" mcp_info += "When you use ANY MCP (Model Context Protocol) tools:\n" mcp_info += "1. ALWAYS read and use the EXACT results returned by the MCP tool\n" mcp_info += "2. For search tools: ONLY cite URLs, sources, and information from the actual search results\n" mcp_info += "3. For any tool: Base your response entirely on the tool's output - do NOT add external information\n" mcp_info += "4. DO NOT fabricate, invent, hallucinate, or make up any sources, URLs, or data\n" mcp_info += "5. If you need more information, call the MCP tool again with different parameters\n" mcp_info += "6. When writing reports/summaries: Reference ONLY the data from MCP tool results\n" mcp_info += "7. If the MCP tool doesn't return enough information, explicitly state this limitation\n" mcp_info += "8. Always double-check that every fact, URL, and reference comes from the MCP tool output\n" mcp_info += "\nIMPORTANT: MCP tool results are your PRIMARY and ONLY source of truth for external data!\n" mcp_info += "NEVER supplement MCP results with your training data or make assumptions beyond what the tools provide.\n" system_content += mcp_info now = datetime.datetime.now(datetime.timezone.utc) datetime_info = f"\n\n=== CURRENT DATE/TIME INFORMATION ===\n" datetime_info += f"Today's date: {now.strftime('%A, %B %d, %Y')}\n" datetime_info += f"Current UTC time: {now.strftime('%H:%M:%S UTC')}\n" datetime_info += f"Current year: {now.strftime('%Y')}\n" datetime_info += f"Current month: {now.strftime('%B')}\n" datetime_info += f"Current day: {now.strftime('%A')}\n" datetime_info += "Use this information for any time-sensitive tasks, research, or when current date/time context is needed.\n" system_content += datetime_info return {"role": "system", "content": system_content} class MessageManager: def __init__(self, client, thread_id: str, model_name: str, trace: Optional[StatefulTraceClient], agent_config: Optional[dict] = None, enable_context_manager: bool = False): self.client = client self.thread_id = thread_id self.model_name = model_name self.trace = trace self.agent_config = agent_config self.enable_context_manager = enable_context_manager async def build_temporary_message(self) -> Optional[dict]: """Build temporary message based on configuration and context.""" system_message = None # Start with agent's system prompt if available if self.agent_config and 'system_prompt' in self.agent_config: system_prompt = self.agent_config['system_prompt'] if system_prompt: system_message = system_prompt # If agent has builder tools enabled, append builder capabilities if self.agent_config: agentpress_tools = self.agent_config.get('agentpress_tools', {}) has_builder_tools = any( agentpress_tools.get(tool, False) for tool in ['agent_config_tool', 'mcp_search_tool', 'credential_profile_tool', 'workflow_tool', 'trigger_tool'] ) if has_builder_tools: from agent.agent_builder_prompt import AGENT_BUILDER_SYSTEM_PROMPT if system_message: # Append builder capabilities to existing system prompt system_message += f"\n\n{AGENT_BUILDER_SYSTEM_PROMPT}" else: # Use builder prompt if no existing system prompt system_message = AGENT_BUILDER_SYSTEM_PROMPT # Build and return the temporary message if we have content if system_message: return { "temporary": True, "role": "system", "content": system_message } return None class AgentRunner: def __init__(self, config: AgentConfig): self.config = config async def setup(self): if not self.config.trace: self.config.trace = langfuse.trace(name="run_agent", session_id=self.config.thread_id, metadata={"project_id": self.config.project_id}) self.thread_manager = ThreadManager( trace=self.config.trace, agent_config=self.config.agent_config ) self.client = await self.thread_manager.db.client self.account_id = await get_account_id_from_thread(self.client, self.config.thread_id) if not self.account_id: raise ValueError("Could not determine account ID for thread") project = await self.client.table('projects').select('*').eq('project_id', self.config.project_id).execute() if not project.data or len(project.data) == 0: raise ValueError(f"Project {self.config.project_id} not found") project_data = project.data[0] sandbox_info = project_data.get('sandbox', {}) if not sandbox_info.get('id'): # Sandbox is created lazily by tools when required. Do not fail setup # if no sandbox is present — tools will call `_ensure_sandbox()` # which will create and persist the sandbox metadata when needed. logger.debug(f"No sandbox found for project {self.config.project_id}; will create lazily when needed") async def setup_tools(self): tool_manager = ToolManager(self.thread_manager, self.config.project_id, self.config.thread_id) # Use agent ID from agent config if available (for any agent with builder tools enabled) agent_id = None if self.config.agent_config: agent_id = self.config.agent_config.get('agent_id') # Convert agent config to disabled tools list disabled_tools = self._get_disabled_tools_from_config() # Register all tools with exclusions tool_manager.register_all_tools(agent_id=agent_id, disabled_tools=disabled_tools) def _get_disabled_tools_from_config(self) -> List[str]: """Convert agent config to list of disabled tools.""" disabled_tools = [] if not self.config.agent_config or 'agentpress_tools' not in self.config.agent_config: # No tool configuration - enable all tools by default return disabled_tools raw_tools = self.config.agent_config['agentpress_tools'] # Handle different formats of tool configuration if not isinstance(raw_tools, dict): # If not a dict, assume all tools are enabled return disabled_tools # Special case: Suna default agents with empty tool config enable all tools if self.config.agent_config.get('is_suna_default', False) and not raw_tools: return disabled_tools def is_tool_enabled(tool_name: str) -> bool: try: tool_config = raw_tools.get(tool_name, True) # Default to True (enabled) if not specified if isinstance(tool_config, bool): return tool_config elif isinstance(tool_config, dict): return tool_config.get('enabled', True) # Default to True (enabled) if not specified else: return True # Default to enabled except Exception: return True # Default to enabled # List of all available tools all_tools = [ 'sb_shell_tool', 'sb_files_tool', 'sb_deploy_tool', 'sb_expose_tool', 'web_search_tool', 'sb_vision_tool', 'sb_presentation_tool', 'sb_image_edit_tool', 'sb_sheets_tool', 'sb_web_dev_tool', 'data_providers_tool', 'browser_tool', 'agent_config_tool', 'mcp_search_tool', 'credential_profile_tool', 'workflow_tool', 'trigger_tool' ] # Add tools that are explicitly disabled for tool_name in all_tools: if not is_tool_enabled(tool_name): disabled_tools.append(tool_name) # Special handling for presentation tools if 'sb_presentation_tool' in disabled_tools: disabled_tools.extend(['sb_presentation_outline_tool']) logger.debug(f"Disabled tools from config: {disabled_tools}") return disabled_tools async def setup_mcp_tools(self) -> Optional[MCPToolWrapper]: if not self.config.agent_config: return None mcp_manager = MCPManager(self.thread_manager, self.account_id) return await mcp_manager.register_mcp_tools(self.config.agent_config) def get_max_tokens(self) -> Optional[int]: logger.debug(f"get_max_tokens called with: '{self.config.model_name}' (type: {type(self.config.model_name)})") if "sonnet" in self.config.model_name.lower(): return 8192 elif "gpt-4" in self.config.model_name.lower(): return 4096 elif "gemini-2.5-pro" in self.config.model_name.lower(): return 64000 elif "kimi-k2" in self.config.model_name.lower(): return 8192 return None async def run(self) -> AsyncGenerator[Dict[str, Any], None]: await self.setup() await self.setup_tools() mcp_wrapper_instance = await self.setup_mcp_tools() system_message = await PromptManager.build_system_prompt( self.config.model_name, self.config.agent_config, self.config.thread_id, mcp_wrapper_instance, self.client ) logger.debug(f"model_name received: {self.config.model_name}") iteration_count = 0 continue_execution = True latest_user_message = await self.client.table('messages').select('*').eq('thread_id', self.config.thread_id).eq('type', 'user').order('created_at', desc=True).limit(1).execute() if latest_user_message.data and len(latest_user_message.data) > 0: data = latest_user_message.data[0]['content'] if isinstance(data, str): data = json.loads(data) if self.config.trace: self.config.trace.update(input=data['content']) message_manager = MessageManager(self.client, self.config.thread_id, self.config.model_name, self.config.trace, agent_config=self.config.agent_config, enable_context_manager=self.config.enable_context_manager) while continue_execution and iteration_count < self.config.max_iterations: iteration_count += 1 can_run, message, subscription = await check_billing_status(self.client, self.account_id) if not can_run: error_msg = f"Billing limit reached: {message}" yield { "type": "status", "status": "stopped", "message": error_msg } break latest_message = await self.client.table('messages').select('*').eq('thread_id', self.config.thread_id).in_('type', ['assistant', 'tool', 'user']).order('created_at', desc=True).limit(1).execute() if latest_message.data and len(latest_message.data) > 0: message_type = latest_message.data[0].get('type') if message_type == 'assistant': continue_execution = False break temporary_message = await message_manager.build_temporary_message() max_tokens = self.get_max_tokens() logger.debug(f"max_tokens: {max_tokens}") generation = self.config.trace.generation(name="thread_manager.run_thread") if self.config.trace else None try: response = await self.thread_manager.run_thread( thread_id=self.config.thread_id, system_prompt=system_message, stream=self.config.stream, llm_model=self.config.model_name, llm_temperature=0, llm_max_tokens=max_tokens, tool_choice="auto", max_xml_tool_calls=1, temporary_message=temporary_message, processor_config=ProcessorConfig( xml_tool_calling=True, native_tool_calling=False, execute_tools=True, execute_on_stream=True, tool_execution_strategy="parallel", xml_adding_strategy="user_message" ), native_max_auto_continues=self.config.native_max_auto_continues, include_xml_examples=True, enable_thinking=self.config.enable_thinking, reasoning_effort=self.config.reasoning_effort, enable_context_manager=self.config.enable_context_manager, generation=generation ) if isinstance(response, dict) and "status" in response and response["status"] == "error": yield response break last_tool_call = None agent_should_terminate = False error_detected = False full_response = "" try: if hasattr(response, '__aiter__') and not isinstance(response, dict): async for chunk in response: if isinstance(chunk, dict) and chunk.get('type') == 'status' and chunk.get('status') == 'error': error_detected = True yield chunk continue if chunk.get('type') == 'status': try: metadata = chunk.get('metadata', {}) if isinstance(metadata, str): metadata = json.loads(metadata) if metadata.get('agent_should_terminate'): agent_should_terminate = True content = chunk.get('content', {}) if isinstance(content, str): content = json.loads(content) if content.get('function_name'): last_tool_call = content['function_name'] elif content.get('xml_tag_name'): last_tool_call = content['xml_tag_name'] except Exception: pass if chunk.get('type') == 'assistant' and 'content' in chunk: try: content = chunk.get('content', '{}') if isinstance(content, str): assistant_content_json = json.loads(content) else: assistant_content_json = content assistant_text = assistant_content_json.get('content', '') full_response += assistant_text if isinstance(assistant_text, str): if '' in assistant_text or '' in assistant_text or '' in assistant_text: if '' in assistant_text: xml_tool = 'ask' elif '' in assistant_text: xml_tool = 'complete' elif '' in assistant_text: xml_tool = 'web-browser-takeover' last_tool_call = xml_tool except json.JSONDecodeError: pass except Exception: pass yield chunk else: error_detected = True if error_detected: if generation: generation.end(output=full_response, status_message="error_detected", level="ERROR") break if agent_should_terminate or last_tool_call in ['ask', 'complete', 'web-browser-takeover']: if generation: generation.end(output=full_response, status_message="agent_stopped") continue_execution = False except Exception as e: error_msg = f"Error during response streaming: {str(e)}" if generation: generation.end(output=full_response, status_message=error_msg, level="ERROR") yield { "type": "status", "status": "error", "message": error_msg } break except Exception as e: error_msg = f"Error running thread: {str(e)}" yield { "type": "status", "status": "error", "message": error_msg } break if generation: generation.end(output=full_response) asyncio.create_task(asyncio.to_thread(lambda: langfuse.flush())) async def run_agent( thread_id: str, project_id: str, stream: bool, thread_manager: Optional[ThreadManager] = None, native_max_auto_continues: int = 25, max_iterations: int = 100, model_name: str = "openai/gpt-5-mini", enable_thinking: Optional[bool] = False, reasoning_effort: Optional[str] = 'low', enable_context_manager: bool = True, agent_config: Optional[dict] = None, trace: Optional[StatefulTraceClient] = None ): effective_model = model_name is_tier_default = model_name in ["Kimi K2", "Claude Sonnet 4", "openai/gpt-5-mini"] if is_tier_default and agent_config and agent_config.get('model'): effective_model = agent_config['model'] logger.debug(f"Using model from agent config: {effective_model} (tier default was {model_name})") elif not is_tier_default: logger.debug(f"Using user-selected model: {effective_model}") else: logger.debug(f"Using tier default model: {effective_model}") config = AgentConfig( thread_id=thread_id, project_id=project_id, stream=stream, native_max_auto_continues=native_max_auto_continues, max_iterations=max_iterations, model_name=effective_model, enable_thinking=enable_thinking, reasoning_effort=reasoning_effort, enable_context_manager=enable_context_manager, agent_config=agent_config, trace=trace ) runner = AgentRunner(config) async for chunk in runner.run(): yield chunk