Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

feat(chat): improve agent generator error propagation (#11884)

Zamil Majdyb2eb4831bd3d
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/__init__.py b/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/__init__.py
index 392f642c41..499025b7dc 100644
--- a/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/__init__.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/__init__.py
@@ -9,6 +9,7 @@ from .core import (
json_to_graph,
save_agent_to_library,
)
+from .errors import get_user_message_for_error
from .service import health_check as check_external_service_health
from .service import is_external_service_configured
@@ -25,4 +26,6 @@ __all__ = [
# Service
"is_external_service_configured",
"check_external_service_health",
+ # Error handling
+ "get_user_message_for_error",
]
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/core.py b/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/core.py
index fc15587110..d56e33cbb0 100644
--- a/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/core.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/core.py
@@ -64,7 +64,7 @@ async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
instructions: Structured instructions from decompose_goal
Returns:
- Agent JSON dict or None on error
+ Agent JSON dict, error dict {"type": "error", ...}, or None on error
Raises:
AgentGeneratorNotConfiguredError: If the external service is not configured.
@@ -73,7 +73,10 @@ async def generate_agent(instructions: dict[str, Any]) -> dict[str, Any] | None:
logger.info("Calling external Agent Generator service for generate_agent")
result = await generate_agent_external(instructions)
if result:
- # Ensure required fields
+ # Check if it's an error response - pass through as-is
+ if isinstance(result, dict) and result.get("type") == "error":
+ return result
+ # Ensure required fields for successful agent generation
if "id" not in result:
result["id"] = str(uuid.uuid4())
if "version" not in result:
@@ -267,7 +270,8 @@ async def generate_agent_patch(
current_agent: Current agent JSON
Returns:
- Updated agent JSON, clarifying questions dict, or None on error
+ Updated agent JSON, clarifying questions dict {"type": "clarifying_questions", ...},
+ error dict {"type": "error", ...}, or None on unexpected error
Raises:
AgentGeneratorNotConfiguredError: If the external service is not configured.
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/errors.py b/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/errors.py
new file mode 100644
index 0000000000..bf71a95df9
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/errors.py
@@ -0,0 +1,43 @@
+"""Error handling utilities for agent generator."""
+
+
+def get_user_message_for_error(
+ error_type: str,
+ operation: str = "process the request",
+ llm_parse_message: str | None = None,
+ validation_message: str | None = None,
+) -> str:
+ """Get a user-friendly error message based on error type.
+
+ This function maps internal error types to user-friendly messages,
+ providing a consistent experience across different agent operations.
+
+ Args:
+ error_type: The error type from the external service
+ (e.g., "llm_parse_error", "timeout", "rate_limit")
+ operation: Description of what operation failed, used in the default
+ message (e.g., "analyze the goal", "generate the agent")
+ llm_parse_message: Custom message for llm_parse_error type
+ validation_message: Custom message for validation_error type
+
+ Returns:
+ User-friendly error message suitable for display to the user
+ """
+ if error_type == "llm_parse_error":
+ return (
+ llm_parse_message
+ or "The AI had trouble processing this request. Please try again."
+ )
+ elif error_type == "validation_error":
+ return (
+ validation_message
+ or "The request failed validation. Please try rephrasing."
+ )
+ elif error_type == "patch_error":
+ return "Failed to apply the changes. Please try a different approach."
+ elif error_type in ("timeout", "llm_timeout"):
+ return "The request took too long. Please try again."
+ elif error_type in ("rate_limit", "llm_rate_limit"):
+ return "The service is currently busy. Please try again in a moment."
+ else:
+ return f"Failed to {operation}. Please try again."
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/service.py b/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/service.py
index a4d2f1af15..1df1faaaef 100644
--- a/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/service.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/agent_generator/service.py
@@ -14,6 +14,70 @@ from backend.util.settings import Settings
logger = logging.getLogger(__name__)
+
+def _create_error_response(
+ error_message: str,
+ error_type: str = "unknown",
+ details: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+ """Create a standardized error response dict.
+
+ Args:
+ error_message: Human-readable error message
+ error_type: Machine-readable error type
+ details: Optional additional error details
+
+ Returns:
+ Error dict with type="error" and error details
+ """
+ response: dict[str, Any] = {
+ "type": "error",
+ "error": error_message,
+ "error_type": error_type,
+ }
+ if details:
+ response["details"] = details
+ return response
+
+
+def _classify_http_error(e: httpx.HTTPStatusError) -> tuple[str, str]:
+ """Classify an HTTP error into error_type and message.
+
+ Args:
+ e: The HTTP status error
+
+ Returns:
+ Tuple of (error_type, error_message)
+ """
+ status = e.response.status_code
+ if status == 429:
+ return "rate_limit", f"Agent Generator rate limited: {e}"
+ elif status == 503:
+ return "service_unavailable", f"Agent Generator unavailable: {e}"
+ elif status == 504 or status == 408:
+ return "timeout", f"Agent Generator timed out: {e}"
+ else:
+ return "http_error", f"HTTP error calling Agent Generator: {e}"
+
+
+def _classify_request_error(e: httpx.RequestError) -> tuple[str, str]:
+ """Classify a request error into error_type and message.
+
+ Args:
+ e: The request error
+
+ Returns:
+ Tuple of (error_type, error_message)
+ """
+ error_str = str(e).lower()
+ if "timeout" in error_str or "timed out" in error_str:
+ return "timeout", f"Agent Generator request timed out: {e}"
+ elif "connect" in error_str:
+ return "connection_error", f"Could not connect to Agent Generator: {e}"
+ else:
+ return "request_error", f"Request error calling Agent Generator: {e}"
+
+
_client: httpx.AsyncClient | None = None
_settings: Settings | None = None
@@ -67,7 +131,8 @@ async def decompose_goal_external(
- {"type": "instructions", "steps": [...]}
- {"type": "unachievable_goal", ...}
- {"type": "vague_goal", ...}
- Or None on error
+ - {"type": "error", "error": "...", "error_type": "..."} on error
+ Or None on unexpected error
"""
client = _get_client()
@@ -83,8 +148,13 @@ async def decompose_goal_external(
data = response.json()
if not data.get("success"):
- logger.error(f"External service returned error: {data.get('error')}")
- return None
+ error_msg = data.get("error", "Unknown error from Agent Generator")
+ error_type = data.get("error_type", "unknown")
+ logger.error(
+ f"Agent Generator decomposition failed: {error_msg} "
+ f"(type: {error_type})"
+ )
+ return _create_error_response(error_msg, error_type)
# Map the response to the expected format
response_type = data.get("type")
@@ -106,25 +176,37 @@ async def decompose_goal_external(
"type": "vague_goal",
"suggested_goal": data.get("suggested_goal"),
}
+ elif response_type == "error":
+ # Pass through error from the service
+ return _create_error_response(
+ data.get("error", "Unknown error"),
+ data.get("error_type", "unknown"),
+ )
else:
logger.error(
f"Unknown response type from external service: {response_type}"
)
- return None
+ return _create_error_response(
+ f"Unknown response type from Agent Generator: {response_type}",
+ "invalid_response",
+ )
except httpx.HTTPStatusError as e:
- logger.error(f"HTTP error calling external agent generator: {e}")
- return None
+ error_type, error_msg = _classify_http_error(e)
+ logger.error(error_msg)
+ return _create_error_response(error_msg, error_type)
except httpx.RequestError as e:
- logger.error(f"Request error calling external agent generator: {e}")
- return None
+ error_type, error_msg = _classify_request_error(e)
+ logger.error(error_msg)
+ return _create_error_response(error_msg, error_type)
except Exception as e:
- logger.error(f"Unexpected error calling external agent generator: {e}")
- return None
+ error_msg = f"Unexpected error calling Agent Generator: {e}"
+ logger.error(error_msg)
+ return _create_error_response(error_msg, "unexpected_error")
async def generate_agent_external(
- instructions: dict[str, Any]
+ instructions: dict[str, Any],
) -> dict[str, Any] | None:
"""Call the external service to generate an agent from instructions.
@@ -132,7 +214,7 @@ async def generate_agent_external(
instructions: Structured instructions from decompose_goal
Returns:
- Agent JSON dict or None on error
+ Agent JSON dict on success, or error dict {"type": "error", ...} on error
"""
client = _get_client()
@@ -144,20 +226,28 @@ async def generate_agent_external(
data = response.json()
if not data.get("success"):
- logger.error(f"External service returned error: {data.get('error')}")
- return None
+ error_msg = data.get("error", "Unknown error from Agent Generator")
+ error_type = data.get("error_type", "unknown")
+ logger.error(
+ f"Agent Generator generation failed: {error_msg} "
+ f"(type: {error_type})"
+ )
+ return _create_error_response(error_msg, error_type)
return data.get("agent_json")
except httpx.HTTPStatusError as e:
- logger.error(f"HTTP error calling external agent generator: {e}")
- return None
+ error_type, error_msg = _classify_http_error(e)
+ logger.error(error_msg)
+ return _create_error_response(error_msg, error_type)
except httpx.RequestError as e:
- logger.error(f"Request error calling external agent generator: {e}")
- return None
+ error_type, error_msg = _classify_request_error(e)
+ logger.error(error_msg)
+ return _create_error_response(error_msg, error_type)
except Exception as e:
- logger.error(f"Unexpected error calling external agent generator: {e}")
- return None
+ error_msg = f"Unexpected error calling Agent Generator: {e}"
+ logger.error(error_msg)
+ return _create_error_response(error_msg, "unexpected_error")
async def generate_agent_patch_external(
@@ -170,7 +260,7 @@ async def generate_agent_patch_external(
current_agent: Current agent JSON
Returns:
- Updated agent JSON, clarifying questions dict, or None on error
+ Updated agent JSON, clarifying questions dict, or error dict on error
"""
client = _get_client()
@@ -186,8 +276,13 @@ async def generate_agent_patch_external(
data = response.json()
if not data.get("success"):
- logger.error(f"External service returned error: {data.get('error')}")
- return None
+ error_msg = data.get("error", "Unknown error from Agent Generator")
+ error_type = data.get("error_type", "unknown")
+ logger.error(
+ f"Agent Generator patch generation failed: {error_msg} "
+ f"(type: {error_type})"
+ )
+ return _create_error_response(error_msg, error_type)
# Check if it's clarifying questions
if data.get("type") == "clarifying_questions":
@@ -196,18 +291,28 @@ async def generate_agent_patch_external(
"questions": data.get("questions", []),
}
+ # Check if it's an error passed through
+ if data.get("type") == "error":
+ return _create_error_response(
+ data.get("error", "Unknown error"),
+ data.get("error_type", "unknown"),
+ )
+
# Otherwise return the updated agent JSON
return data.get("agent_json")
except httpx.HTTPStatusError as e:
- logger.error(f"HTTP error calling external agent generator: {e}")
- return None
+ error_type, error_msg = _classify_http_error(e)
+ logger.error(error_msg)
+ return _create_error_response(error_msg, error_type)
except httpx.RequestError as e:
- logger.error(f"Request error calling external agent generator: {e}")
- return None
+ error_type, error_msg = _classify_request_error(e)
+ logger.error(error_msg)
+ return _create_error_response(error_msg, error_type)
except Exception as e:
- logger.error(f"Unexpected error calling external agent generator: {e}")
- return None
+ error_msg = f"Unexpected error calling Agent Generator: {e}"
+ logger.error(error_msg)
+ return _create_error_response(error_msg, "unexpected_error")
async def get_blocks_external() -> list[dict[str, Any]] | None:
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/create_agent.py b/autogpt_platform/backend/backend/api/features/chat/tools/create_agent.py
index 6b3784e323..74011c7e95 100644
--- a/autogpt_platform/backend/backend/api/features/chat/tools/create_agent.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/create_agent.py
@@ -9,6 +9,7 @@ from .agent_generator import (
AgentGeneratorNotConfiguredError,
decompose_goal,
generate_agent,
+ get_user_message_for_error,
save_agent_to_library,
)
from .base import BaseTool
@@ -117,11 +118,29 @@ class CreateAgentTool(BaseTool):
if decomposition_result is None:
return ErrorResponse(
- message="Failed to analyze the goal. The agent generation service may be unavailable or timed out. Please try again.",
+ message="Failed to analyze the goal. The agent generation service may be unavailable. Please try again.",
error="decomposition_failed",
+ details={"description": description[:100]},
+ session_id=session_id,
+ )
+
+ # Check if the result is an error from the external service
+ if decomposition_result.get("type") == "error":
+ error_msg = decomposition_result.get("error", "Unknown error")
+ error_type = decomposition_result.get("error_type", "unknown")
+ user_message = get_user_message_for_error(
+ error_type,
+ operation="analyze the goal",
+ llm_parse_message="The AI had trouble understanding this request. Please try rephrasing your goal.",
+ )
+ return ErrorResponse(
+ message=user_message,
+ error=f"decomposition_failed:{error_type}",
details={
- "description": description[:100]
- }, # Include context for debugging
+ "description": description[:100],
+ "service_error": error_msg,
+ "error_type": error_type,
+ },
session_id=session_id,
)
@@ -186,11 +205,30 @@ class CreateAgentTool(BaseTool):
if agent_json is None:
return ErrorResponse(
- message="Failed to generate the agent. The agent generation service may be unavailable or timed out. Please try again.",
+ message="Failed to generate the agent. The agent generation service may be unavailable. Please try again.",
error="generation_failed",
+ details={"description": description[:100]},
+ session_id=session_id,
+ )
+
+ # Check if the result is an error from the external service
+ if isinstance(agent_json, dict) and agent_json.get("type") == "error":
+ error_msg = agent_json.get("error", "Unknown error")
+ error_type = agent_json.get("error_type", "unknown")
+ user_message = get_user_message_for_error(
+ error_type,
+ operation="generate the agent",
+ llm_parse_message="The AI had trouble generating the agent. Please try again or simplify your goal.",
+ validation_message="The generated agent failed validation. Please try rephrasing your goal.",
+ )
+ return ErrorResponse(
+ message=user_message,
+ error=f"generation_failed:{error_type}",
details={
- "description": description[:100]
- }, # Include context for debugging
+ "description": description[:100],
+ "service_error": error_msg,
+ "error_type": error_type,
+ },
session_id=session_id,
)
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/edit_agent.py b/autogpt_platform/backend/backend/api/features/chat/tools/edit_agent.py
index 7c4da8ad43..ee8eee53ce 100644
--- a/autogpt_platform/backend/backend/api/features/chat/tools/edit_agent.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/edit_agent.py
@@ -9,6 +9,7 @@ from .agent_generator import (
AgentGeneratorNotConfiguredError,
generate_agent_patch,
get_agent_as_json,
+ get_user_message_for_error,
save_agent_to_library,
)
from .base import BaseTool
@@ -152,6 +153,28 @@ class EditAgentTool(BaseTool):
session_id=session_id,
)
+ # Check if the result is an error from the external service
+ if isinstance(result, dict) and result.get("type") == "error":
+ error_msg = result.get("error", "Unknown error")
+ error_type = result.get("error_type", "unknown")
+ user_message = get_user_message_for_error(
+ error_type,
+ operation="generate the changes",
+ llm_parse_message="The AI had trouble generating the changes. Please try again or simplify your request.",
+ validation_message="The generated changes failed validation. Please try rephrasing your request.",
+ )
+ return ErrorResponse(
+ message=user_message,
+ error=f"update_generation_failed:{error_type}",
+ details={
+ "agent_id": agent_id,
+ "changes": changes[:100],
+ "service_error": error_msg,
+ "error_type": error_type,
+ },
+ session_id=session_id,
+ )
+
# Check if LLM returned clarifying questions
if result.get("type") == "clarifying_questions":
questions = result.get("questions", [])
diff --git a/autogpt_platform/backend/test/agent_generator/test_service.py b/autogpt_platform/backend/test/agent_generator/test_service.py
index 81ff794532..fe7a1a7fdd 100644
--- a/autogpt_platform/backend/test/agent_generator/test_service.py
+++ b/autogpt_platform/backend/test/agent_generator/test_service.py
@@ -151,15 +151,20 @@ class TestDecomposeGoalExternal:
@pytest.mark.asyncio
async def test_decompose_goal_handles_http_error(self):
"""Test decomposition handles HTTP errors gracefully."""
+ mock_response = MagicMock()
+ mock_response.status_code = 500
mock_client = AsyncMock()
mock_client.post.side_effect = httpx.HTTPStatusError(
- "Server error", request=MagicMock(), response=MagicMock()
+ "Server error", request=MagicMock(), response=mock_response
)
with patch.object(service, "_get_client", return_value=mock_client):
result = await service.decompose_goal_external("Build a chatbot")
- assert result is None
+ assert result is not None
+ assert result.get("type") == "error"
+ assert result.get("error_type") == "http_error"
+ assert "Server error" in result.get("error", "")
@pytest.mark.asyncio
async def test_decompose_goal_handles_request_error(self):
@@ -170,7 +175,10 @@ class TestDecomposeGoalExternal:
with patch.object(service, "_get_client", return_value=mock_client):
result = await service.decompose_goal_external("Build a chatbot")
- assert result is None
+ assert result is not None
+ assert result.get("type") == "error"
+ assert result.get("error_type") == "connection_error"
+ assert "Connection failed" in result.get("error", "")
@pytest.mark.asyncio
async def test_decompose_goal_handles_service_error(self):
@@ -179,6 +187,7 @@ class TestDecomposeGoalExternal:
mock_response.json.return_value = {
"success": False,
"error": "Internal error",
+ "error_type": "internal_error",
}
mock_response.raise_for_status = MagicMock()
@@ -188,7 +197,10 @@ class TestDecomposeGoalExternal:
with patch.object(service, "_get_client", return_value=mock_client):
result = await service.decompose_goal_external("Build a chatbot")
- assert result is None
+ assert result is not None
+ assert result.get("type") == "error"
+ assert result.get("error") == "Internal error"
+ assert result.get("error_type") == "internal_error"
class TestGenerateAgentExternal:
@@ -236,7 +248,10 @@ class TestGenerateAgentExternal:
with patch.object(service, "_get_client", return_value=mock_client):
result = await service.generate_agent_external({"steps": []})
- assert result is None
+ assert result is not None
+ assert result.get("type") == "error"
+ assert result.get("error_type") == "connection_error"
+ assert "Connection failed" in result.get("error", "")
class TestGenerateAgentPatchExternal: