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(platform): add feature request tools for CoPilot chat (#12102)

Swifty5035b69c792b
diff --git a/autogpt_platform/backend/.env.default b/autogpt_platform/backend/.env.default
index fa52ba812a..2711bd2df9 100644
--- a/autogpt_platform/backend/.env.default
+++ b/autogpt_platform/backend/.env.default
@@ -104,6 +104,12 @@ TWITTER_CLIENT_SECRET=
# Make a new workspace for your OAuth APP -- trust me
# https://linear.app/settings/api/applications/new
# Callback URL: http://localhost:3000/auth/integrations/oauth_callback
+LINEAR_API_KEY=
+# Linear project and team IDs for the feature request tracker.
+# Find these in your Linear workspace URL: linear.app/<workspace>/project/<project-id>
+# and in team settings. Used by the chat copilot to file and search feature requests.
+LINEAR_FEATURE_REQUEST_PROJECT_ID=
+LINEAR_FEATURE_REQUEST_TEAM_ID=
LINEAR_CLIENT_ID=
LINEAR_CLIENT_SECRET=
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/__init__.py b/autogpt_platform/backend/backend/api/features/chat/tools/__init__.py
index dcbc35ef37..350776081a 100644
--- a/autogpt_platform/backend/backend/api/features/chat/tools/__init__.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/__init__.py
@@ -12,6 +12,7 @@ from .base import BaseTool
from .create_agent import CreateAgentTool
from .customize_agent import CustomizeAgentTool
from .edit_agent import EditAgentTool
+from .feature_requests import CreateFeatureRequestTool, SearchFeatureRequestsTool
from .find_agent import FindAgentTool
from .find_block import FindBlockTool
from .find_library_agent import FindLibraryAgentTool
@@ -45,6 +46,9 @@ TOOL_REGISTRY: dict[str, BaseTool] = {
"view_agent_output": AgentOutputTool(),
"search_docs": SearchDocsTool(),
"get_doc_page": GetDocPageTool(),
+ # Feature request tools
+ "search_feature_requests": SearchFeatureRequestsTool(),
+ "create_feature_request": CreateFeatureRequestTool(),
# Workspace tools for CoPilot file operations
"list_workspace_files": ListWorkspaceFilesTool(),
"read_workspace_file": ReadWorkspaceFileTool(),
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/feature_requests.py b/autogpt_platform/backend/backend/api/features/chat/tools/feature_requests.py
new file mode 100644
index 0000000000..95f1eb1fbe
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/feature_requests.py
@@ -0,0 +1,448 @@
+"""Feature request tools - search and create feature requests via Linear."""
+
+import logging
+from typing import Any
+
+from pydantic import SecretStr
+
+from backend.api.features.chat.model import ChatSession
+from backend.api.features.chat.tools.base import BaseTool
+from backend.api.features.chat.tools.models import (
+ ErrorResponse,
+ FeatureRequestCreatedResponse,
+ FeatureRequestInfo,
+ FeatureRequestSearchResponse,
+ NoResultsResponse,
+ ToolResponseBase,
+)
+from backend.blocks.linear._api import LinearClient
+from backend.data.model import APIKeyCredentials
+from backend.data.user import get_user_email_by_id
+from backend.util.settings import Settings
+
+logger = logging.getLogger(__name__)
+
+MAX_SEARCH_RESULTS = 10
+
+# GraphQL queries/mutations
+SEARCH_ISSUES_QUERY = """
+query SearchFeatureRequests($term: String!, $filter: IssueFilter, $first: Int) {
+ searchIssues(term: $term, filter: $filter, first: $first) {
+ nodes {
+ id
+ identifier
+ title
+ description
+ }
+ }
+}
+"""
+
+CUSTOMER_UPSERT_MUTATION = """
+mutation CustomerUpsert($input: CustomerUpsertInput!) {
+ customerUpsert(input: $input) {
+ success
+ customer {
+ id
+ name
+ externalIds
+ }
+ }
+}
+"""
+
+ISSUE_CREATE_MUTATION = """
+mutation IssueCreate($input: IssueCreateInput!) {
+ issueCreate(input: $input) {
+ success
+ issue {
+ id
+ identifier
+ title
+ url
+ }
+ }
+}
+"""
+
+CUSTOMER_NEED_CREATE_MUTATION = """
+mutation CustomerNeedCreate($input: CustomerNeedCreateInput!) {
+ customerNeedCreate(input: $input) {
+ success
+ need {
+ id
+ body
+ customer {
+ id
+ name
+ }
+ issue {
+ id
+ identifier
+ title
+ url
+ }
+ }
+ }
+}
+"""
+
+
+_settings: Settings | None = None
+
+
+def _get_settings() -> Settings:
+ global _settings
+ if _settings is None:
+ _settings = Settings()
+ return _settings
+
+
+def _get_linear_config() -> tuple[LinearClient, str, str]:
+ """Return a configured Linear client, project ID, and team ID.
+
+ Raises RuntimeError if any required setting is missing.
+ """
+ secrets = _get_settings().secrets
+ if not secrets.linear_api_key:
+ raise RuntimeError("LINEAR_API_KEY is not configured")
+ if not secrets.linear_feature_request_project_id:
+ raise RuntimeError("LINEAR_FEATURE_REQUEST_PROJECT_ID is not configured")
+ if not secrets.linear_feature_request_team_id:
+ raise RuntimeError("LINEAR_FEATURE_REQUEST_TEAM_ID is not configured")
+
+ credentials = APIKeyCredentials(
+ id="system-linear",
+ provider="linear",
+ api_key=SecretStr(secrets.linear_api_key),
+ title="System Linear API Key",
+ )
+ client = LinearClient(credentials=credentials)
+ return (
+ client,
+ secrets.linear_feature_request_project_id,
+ secrets.linear_feature_request_team_id,
+ )
+
+
+class SearchFeatureRequestsTool(BaseTool):
+ """Tool for searching existing feature requests in Linear."""
+
+ @property
+ def name(self) -> str:
+ return "search_feature_requests"
+
+ @property
+ def description(self) -> str:
+ return (
+ "Search existing feature requests to check if a similar request "
+ "already exists before creating a new one. Returns matching feature "
+ "requests with their ID, title, and description."
+ )
+
+ @property
+ def parameters(self) -> dict[str, Any]:
+ return {
+ "type": "object",
+ "properties": {
+ "query": {
+ "type": "string",
+ "description": "Search term to find matching feature requests.",
+ },
+ },
+ "required": ["query"],
+ }
+
+ @property
+ def requires_auth(self) -> bool:
+ return True
+
+ async def _execute(
+ self,
+ user_id: str | None,
+ session: ChatSession,
+ **kwargs,
+ ) -> ToolResponseBase:
+ query = kwargs.get("query", "").strip()
+ session_id = session.session_id if session else None
+
+ if not query:
+ return ErrorResponse(
+ message="Please provide a search query.",
+ error="Missing query parameter",
+ session_id=session_id,
+ )
+
+ try:
+ client, project_id, _team_id = _get_linear_config()
+ data = await client.query(
+ SEARCH_ISSUES_QUERY,
+ {
+ "term": query,
+ "filter": {
+ "project": {"id": {"eq": project_id}},
+ },
+ "first": MAX_SEARCH_RESULTS,
+ },
+ )
+
+ nodes = data.get("searchIssues", {}).get("nodes", [])
+
+ if not nodes:
+ return NoResultsResponse(
+ message=f"No feature requests found matching '{query}'.",
+ suggestions=[
+ "Try different keywords",
+ "Use broader search terms",
+ "You can create a new feature request if none exists",
+ ],
+ session_id=session_id,
+ )
+
+ results = [
+ FeatureRequestInfo(
+ id=node["id"],
+ identifier=node["identifier"],
+ title=node["title"],
+ description=node.get("description"),
+ )
+ for node in nodes
+ ]
+
+ return FeatureRequestSearchResponse(
+ message=f"Found {len(results)} feature request(s) matching '{query}'.",
+ results=results,
+ count=len(results),
+ query=query,
+ session_id=session_id,
+ )
+ except Exception as e:
+ logger.exception("Failed to search feature requests")
+ return ErrorResponse(
+ message="Failed to search feature requests.",
+ error=str(e),
+ session_id=session_id,
+ )
+
+
+class CreateFeatureRequestTool(BaseTool):
+ """Tool for creating feature requests (or adding needs to existing ones)."""
+
+ @property
+ def name(self) -> str:
+ return "create_feature_request"
+
+ @property
+ def description(self) -> str:
+ return (
+ "Create a new feature request or add a customer need to an existing one. "
+ "Always search first with search_feature_requests to avoid duplicates. "
+ "If a matching request exists, pass its ID as existing_issue_id to add "
+ "the user's need to it instead of creating a duplicate."
+ )
+
+ @property
+ def parameters(self) -> dict[str, Any]:
+ return {
+ "type": "object",
+ "properties": {
+ "title": {
+ "type": "string",
+ "description": "Title for the feature request.",
+ },
+ "description": {
+ "type": "string",
+ "description": "Detailed description of what the user wants and why.",
+ },
+ "existing_issue_id": {
+ "type": "string",
+ "description": (
+ "If adding a need to an existing feature request, "
+ "provide its Linear issue ID (from search results). "
+ "Omit to create a new feature request."
+ ),
+ },
+ },
+ "required": ["title", "description"],
+ }
+
+ @property
+ def requires_auth(self) -> bool:
+ return True
+
+ async def _find_or_create_customer(
+ self, client: LinearClient, user_id: str, name: str
+ ) -> dict:
+ """Find existing customer by user_id or create a new one via upsert.
+
+ Args:
+ client: Linear API client.
+ user_id: Stable external ID used to deduplicate customers.
+ name: Human-readable display name (e.g. the user's email).
+ """
+ data = await client.mutate(
+ CUSTOMER_UPSERT_MUTATION,
+ {
+ "input": {
+ "name": name,
+ "externalId": user_id,
+ },
+ },
+ )
+ result = data.get("customerUpsert", {})
+ if not result.get("success"):
+ raise RuntimeError(f"Failed to upsert customer: {data}")
+ return result["customer"]
+
+ async def _execute(
+ self,
+ user_id: str | None,
+ session: ChatSession,
+ **kwargs,
+ ) -> ToolResponseBase:
+ title = kwargs.get("title", "").strip()
+ description = kwargs.get("description", "").strip()
+ existing_issue_id = kwargs.get("existing_issue_id")
+ session_id = session.session_id if session else None
+
+ if not title or not description:
+ return ErrorResponse(
+ message="Both title and description are required.",
+ error="Missing required parameters",
+ session_id=session_id,
+ )
+
+ if not user_id:
+ return ErrorResponse(
+ message="Authentication required to create feature requests.",
+ error="Missing user_id",
+ session_id=session_id,
+ )
+
+ try:
+ client, project_id, team_id = _get_linear_config()
+ except Exception as e:
+ logger.exception("Failed to initialize Linear client")
+ return ErrorResponse(
+ message="Failed to create feature request.",
+ error=str(e),
+ session_id=session_id,
+ )
+
+ # Resolve a human-readable name (email) for the Linear customer record.
+ # Fall back to user_id if the lookup fails or returns None.
+ try:
+ customer_display_name = await get_user_email_by_id(user_id) or user_id
+ except Exception:
+ customer_display_name = user_id
+
+ # Step 1: Find or create customer for this user
+ try:
+ customer = await self._find_or_create_customer(
+ client, user_id, customer_display_name
+ )
+ customer_id = customer["id"]
+ customer_name = customer["name"]
+ except Exception as e:
+ logger.exception("Failed to upsert customer in Linear")
+ return ErrorResponse(
+ message="Failed to create feature request.",
+ error=str(e),
+ session_id=session_id,
+ )
+
+ # Step 2: Create or reuse issue
+ issue_id: str | None = None
+ issue_identifier: str | None = None
+ if existing_issue_id:
+ # Add need to existing issue - we still need the issue details for response
+ is_new_issue = False
+ issue_id = existing_issue_id
+ else:
+ # Create new issue in the feature requests project
+ try:
+ data = await client.mutate(
+ ISSUE_CREATE_MUTATION,
+ {
+ "input": {
+ "title": title,
+ "description": description,
+ "teamId": team_id,
+ "projectId": project_id,
+ },
+ },
+ )
+ result = data.get("issueCreate", {})
+ if not result.get("success"):
+ return ErrorResponse(
+ message="Failed to create feature request issue.",
+ error=str(data),
+ session_id=session_id,
+ )
+ issue = result["issue"]
+ issue_id = issue["id"]
+ issue_identifier = issue.get("identifier")
+ except Exception as e:
+ logger.exception("Failed to create feature request issue")
+ return ErrorResponse(
+ message="Failed to create feature request.",
+ error=str(e),
+ session_id=session_id,
+ )
+ is_new_issue = True
+
+ # Step 3: Create customer need on the issue
+ try:
+ data = await client.mutate(
+ CUSTOMER_NEED_CREATE_MUTATION,
+ {
+ "input": {
+ "customerId": customer_id,
+ "issueId": issue_id,
+ "body": description,
+ "priority": 0,
+ },
+ },
+ )
+ need_result = data.get("customerNeedCreate", {})
+ if not need_result.get("success"):
+ orphaned = (
+ {"issue_id": issue_id, "issue_identifier": issue_identifier}
+ if is_new_issue
+ else None
+ )
+ return ErrorResponse(
+ message="Failed to attach customer need to the feature request.",
+ error=str(data),
+ details=orphaned,
+ session_id=session_id,
+ )
+ need = need_result["need"]
+ issue_info = need["issue"]
+ except Exception as e:
+ logger.exception("Failed to create customer need")
+ orphaned = (
+ {"issue_id": issue_id, "issue_identifier": issue_identifier}
+ if is_new_issue
+ else None
+ )
+ return ErrorResponse(
+ message="Failed to attach customer need to the feature request.",
+ error=str(e),
+ details=orphaned,
+ session_id=session_id,
+ )
+
+ return FeatureRequestCreatedResponse(
+ message=(
+ f"{'Created new feature request' if is_new_issue else 'Added your request to existing feature request'}: "
+ f"{issue_info['title']}."
+ ),
+ issue_id=issue_info["id"],
+ issue_identifier=issue_info["identifier"],
+ issue_title=issue_info["title"],
+ issue_url=issue_info.get("url", ""),
+ is_new_issue=is_new_issue,
+ customer_name=customer_name,
+ session_id=session_id,
+ )
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/feature_requests_test.py b/autogpt_platform/backend/backend/api/features/chat/tools/feature_requests_test.py
new file mode 100644
index 0000000000..438725368f
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/feature_requests_test.py
@@ -0,0 +1,615 @@
+"""Tests for SearchFeatureRequestsTool and CreateFeatureRequestTool."""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from backend.api.features.chat.tools.feature_requests import (
+ CreateFeatureRequestTool,
+ SearchFeatureRequestsTool,
+)
+from backend.api.features.chat.tools.models import (
+ ErrorResponse,
+ FeatureRequestCreatedResponse,
+ FeatureRequestSearchResponse,
+ NoResultsResponse,
+)
+
+from ._test_data import make_session
+
+_TEST_USER_ID = "test-user-feature-requests"
+_TEST_USER_EMAIL = "[email protected]"
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+_FAKE_PROJECT_ID = "test-project-id"
+_FAKE_TEAM_ID = "test-team-id"
+
+
+def _mock_linear_config(*, query_return=None, mutate_return=None):
+ """Return a patched _get_linear_config that yields a mock LinearClient."""
+ client = AsyncMock()
+ if query_return is not None:
+ client.query.return_value = query_return
+ if mutate_return is not None:
+ client.mutate.return_value = mutate_return
+ return (
+ patch(
+ "backend.api.features.chat.tools.feature_requests._get_linear_config",
+ return_value=(client, _FAKE_PROJECT_ID, _FAKE_TEAM_ID),
+ ),
+ client,
+ )
+
+
+def _search_response(nodes: list[dict]) -> dict:
+ return {"searchIssues": {"nodes": nodes}}
+
+
+def _customer_upsert_response(
+ customer_id: str = "cust-1", name: str = _TEST_USER_EMAIL, success: bool = True
+) -> dict:
+ return {
+ "customerUpsert": {
+ "success": success,
+ "customer": {"id": customer_id, "name": name, "externalIds": [name]},
+ }
+ }
+
+
+def _issue_create_response(
+ issue_id: str = "issue-1",
+ identifier: str = "FR-1",
+ title: str = "New Feature",
+ success: bool = True,
+) -> dict:
+ return {
+ "issueCreate": {
+ "success": success,
+ "issue": {
+ "id": issue_id,
+ "identifier": identifier,
+ "title": title,
+ "url": f"https://linear.app/issue/{identifier}",
+ },
+ }
+ }
+
+
+def _need_create_response(
+ need_id: str = "need-1",
+ issue_id: str = "issue-1",
+ identifier: str = "FR-1",
+ title: str = "New Feature",
+ success: bool = True,
+) -> dict:
+ return {
+ "customerNeedCreate": {
+ "success": success,
+ "need": {
+ "id": need_id,
+ "body": "description",
+ "customer": {"id": "cust-1", "name": _TEST_USER_EMAIL},
+ "issue": {
+ "id": issue_id,
+ "identifier": identifier,
+ "title": title,
+ "url": f"https://linear.app/issue/{identifier}",
+ },
+ },
+ }
+ }
+
+
+# ===========================================================================
+# SearchFeatureRequestsTool
+# ===========================================================================
+
+
+class TestSearchFeatureRequestsTool:
+ """Tests for SearchFeatureRequestsTool._execute."""
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_successful_search(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ nodes = [
+ {
+ "id": "id-1",
+ "identifier": "FR-1",
+ "title": "Dark mode",
+ "description": "Add dark mode support",
+ },
+ {
+ "id": "id-2",
+ "identifier": "FR-2",
+ "title": "Dark theme",
+ "description": None,
+ },
+ ]
+ patcher, _ = _mock_linear_config(query_return=_search_response(nodes))
+ with patcher:
+ tool = SearchFeatureRequestsTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID, session=session, query="dark mode"
+ )
+
+ assert isinstance(resp, FeatureRequestSearchResponse)
+ assert resp.count == 2
+ assert resp.results[0].id == "id-1"
+ assert resp.results[1].identifier == "FR-2"
+ assert resp.query == "dark mode"
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_no_results(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, _ = _mock_linear_config(query_return=_search_response([]))
+ with patcher:
+ tool = SearchFeatureRequestsTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID, session=session, query="nonexistent"
+ )
+
+ assert isinstance(resp, NoResultsResponse)
+ assert "nonexistent" in resp.message
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_empty_query_returns_error(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ tool = SearchFeatureRequestsTool()
+ resp = await tool._execute(user_id=_TEST_USER_ID, session=session, query=" ")
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "query" in resp.error.lower()
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_missing_query_returns_error(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ tool = SearchFeatureRequestsTool()
+ resp = await tool._execute(user_id=_TEST_USER_ID, session=session)
+
+ assert isinstance(resp, ErrorResponse)
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_api_failure(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.query.side_effect = RuntimeError("Linear API down")
+ with patcher:
+ tool = SearchFeatureRequestsTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID, session=session, query="test"
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "Linear API down" in resp.error
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_malformed_node_returns_error(self):
+ """A node missing required keys should be caught by the try/except."""
+ session = make_session(user_id=_TEST_USER_ID)
+ # Node missing 'identifier' key
+ bad_nodes = [{"id": "id-1", "title": "Missing identifier"}]
+ patcher, _ = _mock_linear_config(query_return=_search_response(bad_nodes))
+ with patcher:
+ tool = SearchFeatureRequestsTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID, session=session, query="test"
+ )
+
+ assert isinstance(resp, ErrorResponse)
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_linear_client_init_failure(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ with patch(
+ "backend.api.features.chat.tools.feature_requests._get_linear_config",
+ side_effect=RuntimeError("No API key"),
+ ):
+ tool = SearchFeatureRequestsTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID, session=session, query="test"
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "No API key" in resp.error
+
+
+# ===========================================================================
+# CreateFeatureRequestTool
+# ===========================================================================
+
+
+class TestCreateFeatureRequestTool:
+ """Tests for CreateFeatureRequestTool._execute."""
+
+ @pytest.fixture(autouse=True)
+ def _patch_email_lookup(self):
+ with patch(
+ "backend.api.features.chat.tools.feature_requests.get_user_email_by_id",
+ new_callable=AsyncMock,
+ return_value=_TEST_USER_EMAIL,
+ ):
+ yield
+
+ # ---- Happy paths -------------------------------------------------------
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_create_new_issue(self):
+ """Full happy path: upsert customer -> create issue -> attach need."""
+ session = make_session(user_id=_TEST_USER_ID)
+
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ _issue_create_response(),
+ _need_create_response(),
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="New Feature",
+ description="Please add this",
+ )
+
+ assert isinstance(resp, FeatureRequestCreatedResponse)
+ assert resp.is_new_issue is True
+ assert resp.issue_identifier == "FR-1"
+ assert resp.customer_name == _TEST_USER_EMAIL
+ assert client.mutate.call_count == 3
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_add_need_to_existing_issue(self):
+ """When existing_issue_id is provided, skip issue creation."""
+ session = make_session(user_id=_TEST_USER_ID)
+
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ _need_create_response(issue_id="existing-1", identifier="FR-99"),
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Existing Feature",
+ description="Me too",
+ existing_issue_id="existing-1",
+ )
+
+ assert isinstance(resp, FeatureRequestCreatedResponse)
+ assert resp.is_new_issue is False
+ assert resp.issue_id == "existing-1"
+ # Only 2 mutations: customer upsert + need create (no issue create)
+ assert client.mutate.call_count == 2
+
+ # ---- Validation errors -------------------------------------------------
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_missing_title(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="",
+ description="some desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "required" in resp.error.lower()
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_missing_description(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Some title",
+ description="",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "required" in resp.error.lower()
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_missing_user_id(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=None,
+ session=session,
+ title="Some title",
+ description="Some desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "user_id" in resp.error.lower()
+
+ # ---- Linear client init failure ----------------------------------------
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_linear_client_init_failure(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ with patch(
+ "backend.api.features.chat.tools.feature_requests._get_linear_config",
+ side_effect=RuntimeError("No API key"),
+ ):
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "No API key" in resp.error
+
+ # ---- Customer upsert failures ------------------------------------------
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_customer_upsert_api_error(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = RuntimeError("Customer API error")
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "Customer API error" in resp.error
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_customer_upsert_not_success(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.return_value = _customer_upsert_response(success=False)
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_customer_malformed_response(self):
+ """Customer dict missing 'id' key should be caught."""
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ # success=True but customer has no 'id'
+ client.mutate.return_value = {
+ "customerUpsert": {
+ "success": True,
+ "customer": {"name": _TEST_USER_ID},
+ }
+ }
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+
+ # ---- Issue creation failures -------------------------------------------
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_issue_create_api_error(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ RuntimeError("Issue create failed"),
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "Issue create failed" in resp.error
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_issue_create_not_success(self):
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ _issue_create_response(success=False),
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert "Failed to create feature request issue" in resp.message
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_issue_create_malformed_response(self):
+ """issueCreate success=True but missing 'issue' key."""
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ {"issueCreate": {"success": True}}, # no 'issue' key
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+
+ # ---- Customer need attachment failures ---------------------------------
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_need_create_api_error_new_issue(self):
+ """Need creation fails after new issue was created -> orphaned issue info."""
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ _issue_create_response(issue_id="orphan-1", identifier="FR-10"),
+ RuntimeError("Need attach failed"),
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.error is not None
+ assert "Need attach failed" in resp.error
+ assert resp.details is not None
+ assert resp.details["issue_id"] == "orphan-1"
+ assert resp.details["issue_identifier"] == "FR-10"
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_need_create_api_error_existing_issue(self):
+ """Need creation fails on existing issue -> no orphaned info."""
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ RuntimeError("Need attach failed"),
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ existing_issue_id="existing-1",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.details is None
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_need_create_not_success_includes_orphaned_info(self):
+ """customerNeedCreate returns success=False -> includes orphaned issue."""
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ _issue_create_response(issue_id="orphan-2", identifier="FR-20"),
+ _need_create_response(success=False),
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.details is not None
+ assert resp.details["issue_id"] == "orphan-2"
+ assert resp.details["issue_identifier"] == "FR-20"
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_need_create_not_success_existing_issue_no_details(self):
+ """customerNeedCreate fails on existing issue -> no orphaned info."""
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ _need_create_response(success=False),
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ existing_issue_id="existing-1",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.details is None
+
+ @pytest.mark.asyncio(loop_scope="session")
+ async def test_need_create_malformed_response(self):
+ """need_result missing 'need' key after success=True."""
+ session = make_session(user_id=_TEST_USER_ID)
+ patcher, client = _mock_linear_config()
+ client.mutate.side_effect = [
+ _customer_upsert_response(),
+ _issue_create_response(),
+ {"customerNeedCreate": {"success": True}}, # no 'need' key
+ ]
+
+ with patcher:
+ tool = CreateFeatureRequestTool()
+ resp = await tool._execute(
+ user_id=_TEST_USER_ID,
+ session=session,
+ title="Title",
+ description="Desc",
+ )
+
+ assert isinstance(resp, ErrorResponse)
+ assert resp.details is not None
+ assert resp.details["issue_id"] == "issue-1"
diff --git a/autogpt_platform/backend/backend/api/features/chat/tools/models.py b/autogpt_platform/backend/backend/api/features/chat/tools/models.py
index bd19d590a6..f2d8f364e4 100644
--- a/autogpt_platform/backend/backend/api/features/chat/tools/models.py
+++ b/autogpt_platform/backend/backend/api/features/chat/tools/models.py
@@ -41,6 +41,9 @@ class ResponseType(str, Enum):
OPERATION_IN_PROGRESS = "operation_in_progress"
# Input validation
INPUT_VALIDATION_ERROR = "input_validation_error"
+ # Feature request types
+ FEATURE_REQUEST_SEARCH = "feature_request_search"
+ FEATURE_REQUEST_CREATED = "feature_request_created"
# Base response model
@@ -430,3 +433,34 @@ class AsyncProcessingResponse(ToolResponseBase):
status: str = "accepted" # Must be "accepted" for detection
operation_id: str | None = None
task_id: str | None = None
+
+
+# Feature request models
+class FeatureRequestInfo(BaseModel):
+ """Information about a feature request issue."""
+
+ id: str
+ identifier: str
+ title: str
+ description: str | None = None
+
+
+class FeatureRequestSearchResponse(ToolResponseBase):
+ """Response for search_feature_requests tool."""
+
+ type: ResponseType = ResponseType.FEATURE_REQUEST_SEARCH
+ results: list[FeatureRequestInfo]
+ count: int
+ query: str
+
+
+class FeatureRequestCreatedResponse(ToolResponseBase):
+ """Response for create_feature_request tool."""
+
+ type: ResponseType = ResponseType.FEATURE_REQUEST_CREATED
+ issue_id: str
+ issue_identifier: str
+ issue_title: str
+ issue_url: str
+ is_new_issue: bool # False if added to existing
+ customer_name: str
diff --git a/autogpt_platform/backend/backend/util/settings.py b/autogpt_platform/backend/backend/util/settings.py
index 48dadb88f1..c5cca87b6e 100644
--- a/autogpt_platform/backend/backend/util/settings.py
+++ b/autogpt_platform/backend/backend/util/settings.py
@@ -662,6 +662,17 @@ class Secrets(UpdateTrackingModel["Secrets"], BaseSettings):
mem0_api_key: str = Field(default="", description="Mem0 API key")
elevenlabs_api_key: str = Field(default="", description="ElevenLabs API key")
+ linear_api_key: str = Field(
+ default="", description="Linear API key for system-level operations"
+ )
+ linear_feature_request_project_id: str = Field(
+ default="",
+ description="Linear project ID where feature requests are tracked",
+ )
+ linear_feature_request_team_id: str = Field(
+ default="",
+ description="Linear team ID used when creating feature request issues",
+ )
linear_client_id: str = Field(default="", description="Linear client ID")
linear_client_secret: str = Field(default="", description="Linear client secret")
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
index 71ade81a9f..b62e96f58a 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
@@ -15,6 +15,10 @@ import { ToolUIPart, UIDataTypes, UIMessage, UITools } from "ai";
import { useEffect, useRef, useState } from "react";
import { CreateAgentTool } from "../../tools/CreateAgent/CreateAgent";
import { EditAgentTool } from "../../tools/EditAgent/EditAgent";
+import {
+ CreateFeatureRequestTool,
+ SearchFeatureRequestsTool,
+} from "../../tools/FeatureRequests/FeatureRequests";
import { FindAgentsTool } from "../../tools/FindAgents/FindAgents";
import { FindBlocksTool } from "../../tools/FindBlocks/FindBlocks";
import { RunAgentTool } from "../../tools/RunAgent/RunAgent";
@@ -254,6 +258,20 @@ export const ChatMessagesContainer = ({
part={part as ToolUIPart}
/>
);
+ case "tool-search_feature_requests":
+ return (
+ <SearchFeatureRequestsTool
+ key={`${message.id}-${i}`}
+ part={part as ToolUIPart}
+ />
+ );
+ case "tool-create_feature_request":
+ return (
+ <CreateFeatureRequestTool
+ key={`${message.id}-${i}`}
+ part={part as ToolUIPart}
+ />
+ );
default:
return null;
}
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/styleguide/page.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/styleguide/page.tsx
index 6030665f1c..8a35f939ca 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/styleguide/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/styleguide/page.tsx
@@ -14,6 +14,10 @@ import { Text } from "@/components/atoms/Text/Text";
import { CopilotChatActionsProvider } from "../components/CopilotChatActionsProvider/CopilotChatActionsProvider";
import { CreateAgentTool } from "../tools/CreateAgent/CreateAgent";
import { EditAgentTool } from "../tools/EditAgent/EditAgent";
+import {
+ CreateFeatureRequestTool,
+ SearchFeatureRequestsTool,
+} from "../tools/FeatureRequests/FeatureRequests";
import { FindAgentsTool } from "../tools/FindAgents/FindAgents";
import { FindBlocksTool } from "../tools/FindBlocks/FindBlocks";
import { RunAgentTool } from "../tools/RunAgent/RunAgent";
@@ -45,6 +49,8 @@ const SECTIONS = [
"Tool: Create Agent",
"Tool: Edit Agent",
"Tool: View Agent Output",
+ "Tool: Search Feature Requests",
+ "Tool: Create Feature Request",
"Full Conversation Example",
] as const;
@@ -1421,6 +1427,235 @@ export default function StyleguidePage() {
</SubSection>
</Section>
+ {/* ============================================================= */}
+ {/* SEARCH FEATURE REQUESTS */}
+ {/* ============================================================= */}
+
+ <Section title="Tool: Search Feature Requests">
+ <SubSection label="Input streaming">
+ <SearchFeatureRequestsTool
+ part={{
+ type: "tool-search_feature_requests",
+ toolCallId: uid(),
+ state: "input-streaming",
+ input: { query: "dark mode" },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Input available">
+ <SearchFeatureRequestsTool
+ part={{
+ type: "tool-search_feature_requests",
+ toolCallId: uid(),
+ state: "input-available",
+ input: { query: "dark mode" },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Output available (with results)">
+ <SearchFeatureRequestsTool
+ part={{
+ type: "tool-search_feature_requests",
+ toolCallId: uid(),
+ state: "output-available",
+ input: { query: "dark mode" },
+ output: {
+ type: "feature_request_search",
+ message:
+ 'Found 2 feature request(s) matching "dark mode".',
+ query: "dark mode",
+ count: 2,
+ results: [
+ {
+ id: "fr-001",
+ identifier: "INT-42",
+ title: "Add dark mode to the platform",
+ description:
+ "Users have requested a dark mode option for the builder and copilot interfaces to reduce eye strain during long sessions.",
+ },
+ {
+ id: "fr-002",
+ identifier: "INT-87",
+ title: "Dark theme for agent output viewer",
+ description:
+ "Specifically requesting dark theme support for the agent output/execution viewer panel.",
+ },
+ ],
+ },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Output available (no results)">
+ <SearchFeatureRequestsTool
+ part={{
+ type: "tool-search_feature_requests",
+ toolCallId: uid(),
+ state: "output-available",
+ input: { query: "teleportation" },
+ output: {
+ type: "no_results",
+ message:
+ "No feature requests found matching 'teleportation'.",
+ suggestions: [
+ "Try different keywords",
+ "Use broader search terms",
+ "You can create a new feature request if none exists",
+ ],
+ },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Output available (error)">
+ <SearchFeatureRequestsTool
+ part={{
+ type: "tool-search_feature_requests",
+ toolCallId: uid(),
+ state: "output-available",
+ input: { query: "dark mode" },
+ output: {
+ type: "error",
+ message: "Failed to search feature requests.",
+ error: "LINEAR_API_KEY environment variable is not set",
+ },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Output error">
+ <SearchFeatureRequestsTool
+ part={{
+ type: "tool-search_feature_requests",
+ toolCallId: uid(),
+ state: "output-error",
+ input: { query: "dark mode" },
+ }}
+ />
+ </SubSection>
+ </Section>
+
+ {/* ============================================================= */}
+ {/* CREATE FEATURE REQUEST */}
+ {/* ============================================================= */}
+
+ <Section title="Tool: Create Feature Request">
+ <SubSection label="Input streaming">
+ <CreateFeatureRequestTool
+ part={{
+ type: "tool-create_feature_request",
+ toolCallId: uid(),
+ state: "input-streaming",
+ input: {
+ title: "Add dark mode",
+ description: "I would love dark mode for the platform.",
+ },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Input available">
+ <CreateFeatureRequestTool
+ part={{
+ type: "tool-create_feature_request",
+ toolCallId: uid(),
+ state: "input-available",
+ input: {
+ title: "Add dark mode",
+ description: "I would love dark mode for the platform.",
+ },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Output available (new issue created)">
+ <CreateFeatureRequestTool
+ part={{
+ type: "tool-create_feature_request",
+ toolCallId: uid(),
+ state: "output-available",
+ input: {
+ title: "Add dark mode",
+ description: "I would love dark mode for the platform.",
+ },
+ output: {
+ type: "feature_request_created",
+ message:
+ "Created new feature request [INT-105] Add dark mode.",
+ issue_id: "issue-new-123",
+ issue_identifier: "INT-105",
+ issue_title: "Add dark mode",
+ issue_url:
+ "https://linear.app/autogpt/issue/INT-105/add-dark-mode",
+ is_new_issue: true,
+ customer_name: "user-abc-123",
+ },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Output available (added to existing issue)">
+ <CreateFeatureRequestTool
+ part={{
+ type: "tool-create_feature_request",
+ toolCallId: uid(),
+ state: "output-available",
+ input: {
+ title: "Dark mode support",
+ description:
+ "Please add dark mode, it would help with long sessions.",
+ existing_issue_id: "fr-001",
+ },
+ output: {
+ type: "feature_request_created",
+ message:
+ "Added your request to existing feature request [INT-42] Add dark mode to the platform.",
+ issue_id: "fr-001",
+ issue_identifier: "INT-42",
+ issue_title: "Add dark mode to the platform",
+ issue_url:
+ "https://linear.app/autogpt/issue/INT-42/add-dark-mode-to-the-platform",
+ is_new_issue: false,
+ customer_name: "user-xyz-789",
+ },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Output available (error)">
+ <CreateFeatureRequestTool
+ part={{
+ type: "tool-create_feature_request",
+ toolCallId: uid(),
+ state: "output-available",
+ input: {
+ title: "Add dark mode",
+ description: "I would love dark mode.",
+ },
+ output: {
+ type: "error",
+ message:
+ "Failed to attach customer need to the feature request.",
+ error: "Linear API request failed (500): Internal error",
+ },
+ }}
+ />
+ </SubSection>
+
+ <SubSection label="Output error">
+ <CreateFeatureRequestTool
+ part={{
+ type: "tool-create_feature_request",
+ toolCallId: uid(),
+ state: "output-error",
+ input: { title: "Add dark mode" },
+ }}
+ />
+ </SubSection>
+ </Section>
+
{/* ============================================================= */}
{/* FULL CONVERSATION EXAMPLE */}
{/* ============================================================= */}
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FeatureRequests/FeatureRequests.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FeatureRequests/FeatureRequests.tsx
new file mode 100644
index 0000000000..fcd4624b6a
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FeatureRequests/FeatureRequests.tsx
@@ -0,0 +1,227 @@
+"use client";
+
+import type { ToolUIPart } from "ai";
+import { useMemo } from "react";
+
+import { MorphingTextAnimation } from "../../components/MorphingTextAnimation/MorphingTextAnimation";
+import {
+ ContentBadge,
+ ContentCard,
+ ContentCardDescription,
+ ContentCardHeader,
+ ContentCardTitle,
+ ContentGrid,
+ ContentMessage,
+ ContentSuggestionsList,
+} from "../../components/ToolAccordion/AccordionContent";
+import { ToolAccordion } from "../../components/ToolAccordion/ToolAccordion";
+import {
+ AccordionIcon,
+ getAccordionTitle,
+ getAnimationText,
+ getFeatureRequestOutput,
+ isCreatedOutput,
+ isErrorOutput,
+ isNoResultsOutput,
+ isSearchResultsOutput,
+ ToolIcon,
+ type FeatureRequestToolType,
+} from "./helpers";
+
+export interface FeatureRequestToolPart {
+ type: FeatureRequestToolType;
+ toolCallId: string;
+ state: ToolUIPart["state"];
+ input?: unknown;
+ output?: unknown;
+}
+
+interface Props {
+ part: FeatureRequestToolPart;
+}
+
+function truncate(text: string, maxChars: number): string {
+ const trimmed = text.trim();
+ if (trimmed.length <= maxChars) return trimmed;
+ return `${trimmed.slice(0, maxChars).trimEnd()}…`;
+}
+
+export function SearchFeatureRequestsTool({ part }: Props) {
+ const output = getFeatureRequestOutput(part);
+ const text = getAnimationText(part);
+ const isStreaming =
+ part.state === "input-streaming" || part.state === "input-available";
+ const isError =
+ part.state === "output-error" || (!!output && isErrorOutput(output));
+
+ const normalized = useMemo(() => {
+ if (!output) return null;
+ return { title: getAccordionTitle(part.type, output) };
+ }, [output, part.type]);
+
+ const isOutputAvailable = part.state === "output-available" && !!output;
+
+ const searchOutput =
+ isOutputAvailable && output && isSearchResultsOutput(output)
+ ? output
+ : null;
+ const noResultsOutput =
+ isOutputAvailable && output && isNoResultsOutput(output) ? output : null;
+ const errorOutput =
+ isOutputAvailable && output && isErrorOutput(output) ? output : null;
+
+ const hasExpandableContent =
+ isOutputAvailable &&
+ ((!!searchOutput && searchOutput.count > 0) ||
+ !!noResultsOutput ||
+ !!errorOutput);
+
+ const accordionDescription =
+ hasExpandableContent && searchOutput
+ ? `Found ${searchOutput.count} result${searchOutput.count === 1 ? "" : "s"} for "${searchOutput.query}"`
+ : hasExpandableContent && (noResultsOutput || errorOutput)
+ ? ((noResultsOutput ?? errorOutput)?.message ?? null)
+ : null;
+
+ return (
+ <div className="py-2">
+ <div className="flex items-center gap-2 text-sm text-muted-foreground">
+ <ToolIcon
+ toolType={part.type}
+ isStreaming={isStreaming}
+ isError={isError}
+ />
+ <MorphingTextAnimation
+ text={text}
+ className={isError ? "text-red-500" : undefined}
+ />
+ </div>
+
+ {hasExpandableContent && normalized && (
+ <ToolAccordion
+ icon={<AccordionIcon toolType={part.type} />}
+ title={normalized.title}
+ description={accordionDescription}
+ >
+ {searchOutput && (
+ <ContentGrid>
+ {searchOutput.results.map((r) => (
+ <ContentCard key={r.id}>
+ <ContentCardHeader>
+ <ContentCardTitle>{r.title}</ContentCardTitle>
+ </ContentCardHeader>
+ {r.description && (
+ <ContentCardDescription>
+ {truncate(r.description, 200)}
+ </ContentCardDescription>
+ )}
+ </ContentCard>
+ ))}
+ </ContentGrid>
+ )}
+
+ {noResultsOutput && (
+ <div>
+ <ContentMessage>{noResultsOutput.message}</ContentMessage>
+ {noResultsOutput.suggestions &&
+ noResultsOutput.suggestions.length > 0 && (
+ <ContentSuggestionsList items={noResultsOutput.suggestions} />
+ )}
+ </div>
+ )}
+
+ {errorOutput && (
+ <div>
+ <ContentMessage>{errorOutput.message}</ContentMessage>
+ {errorOutput.error && (
+ <ContentCardDescription>
+ {errorOutput.error}
+ </ContentCardDescription>
+ )}
+ </div>
+ )}
+ </ToolAccordion>
+ )}
+ </div>
+ );
+}
+
+export function CreateFeatureRequestTool({ part }: Props) {
+ const output = getFeatureRequestOutput(part);
+ const text = getAnimationText(part);
+ const isStreaming =
+ part.state === "input-streaming" || part.state === "input-available";
+ const isError =
+ part.state === "output-error" || (!!output && isErrorOutput(output));
+
+ const normalized = useMemo(() => {
+ if (!output) return null;
+ return { title: getAccordionTitle(part.type, output) };
+ }, [output, part.type]);
+
+ const isOutputAvailable = part.state === "output-available" && !!output;
+
+ const createdOutput =
+ isOutputAvailable && output && isCreatedOutput(output) ? output : null;
+ const errorOutput =
+ isOutputAvailable && output && isErrorOutput(output) ? output : null;
+
+ const hasExpandableContent =
+ isOutputAvailable && (!!createdOutput || !!errorOutput);
+
+ const accordionDescription =
+ hasExpandableContent && createdOutput
+ ? createdOutput.issue_title
+ : hasExpandableContent && errorOutput
+ ? errorOutput.message
+ : null;
+
+ return (
+ <div className="py-2">
+ <div className="flex items-center gap-2 text-sm text-muted-foreground">
+ <ToolIcon
+ toolType={part.type}
+ isStreaming={isStreaming}
+ isError={isError}
+ />
+ <MorphingTextAnimation
+ text={text}
+ className={isError ? "text-red-500" : undefined}
+ />
+ </div>
+
+ {hasExpandableContent && normalized && (
+ <ToolAccordion
+ icon={<AccordionIcon toolType={part.type} />}
+ title={normalized.title}
+ description={accordionDescription}
+ >
+ {createdOutput && (
+ <ContentCard>
+ <ContentCardHeader>
+ <ContentCardTitle>{createdOutput.issue_title}</ContentCardTitle>
+ </ContentCardHeader>
+ <div className="mt-2 flex items-center gap-2">
+ <ContentBadge>
+ {createdOutput.is_new_issue ? "New" : "Existing"}
+ </ContentBadge>
+ </div>
+ <ContentMessage>{createdOutput.message}</ContentMessage>
+ </ContentCard>
+ )}
+
+ {errorOutput && (
+ <div>
+ <ContentMessage>{errorOutput.message}</ContentMessage>
+ {errorOutput.error && (
+ <ContentCardDescription>
+ {errorOutput.error}
+ </ContentCardDescription>
+ )}
+ </div>
+ )}
+ </ToolAccordion>
+ )}
+ </div>
+ );
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FeatureRequests/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FeatureRequests/helpers.tsx
new file mode 100644
index 0000000000..75133905b1
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/FeatureRequests/helpers.tsx
@@ -0,0 +1,271 @@
+import {
+ CheckCircleIcon,
+ LightbulbIcon,
+ MagnifyingGlassIcon,
+ PlusCircleIcon,
+} from "@phosphor-icons/react";
+import type { ToolUIPart } from "ai";
+
+/* ------------------------------------------------------------------ */
+/* Types (local until API client is regenerated) */
+/* ------------------------------------------------------------------ */
+
+interface FeatureRequestInfo {
+ id: string;
+ identifier: string;
+ title: string;
+ description?: string | null;
+}
+
+export interface FeatureRequestSearchResponse {
+ type: "feature_request_search";
+ message: string;
+ results: FeatureRequestInfo[];
+ count: number;
+ query: string;
+}
+
+export interface FeatureRequestCreatedResponse {
+ type: "feature_request_created";
+ message: string;
+ issue_id: string;
+ issue_identifier: string;
+ issue_title: string;
+ issue_url: string;
+ is_new_issue: boolean;
+ customer_name: string;
+}
+
+interface NoResultsResponse {
+ type: "no_results";
+ message: string;
+ suggestions?: string[];
+}
+
+interface ErrorResponse {
+ type: "error";
+ message: string;
+ error?: string;
+}
+
+export type FeatureRequestOutput =
+ | FeatureRequestSearchResponse
+ | FeatureRequestCreatedResponse
+ | NoResultsResponse
+ | ErrorResponse;
+
+export type FeatureRequestToolType =
+ | "tool-search_feature_requests"
+ | "tool-create_feature_request"
+ | string;
+
+/* ------------------------------------------------------------------ */
+/* Output parsing */
+/* ------------------------------------------------------------------ */
+
+function parseOutput(output: unknown): FeatureRequestOutput | null {
+ if (!output) return null;
+ if (typeof output === "string") {
+ const trimmed = output.trim();
+ if (!trimmed) return null;
+ try {
+ return parseOutput(JSON.parse(trimmed) as unknown);
+ } catch {
+ return null;
+ }
+ }
+ if (typeof output === "object") {
+ const type = (output as { type?: unknown }).type;
+ if (
+ type === "feature_request_search" ||
+ type === "feature_request_created" ||
+ type === "no_results" ||
+ type === "error"
+ ) {
+ return output as FeatureRequestOutput;
+ }
+ // Fallback structural checks
+ if ("results" in output && "query" in output)
+ return output as FeatureRequestSearchResponse;
+ if ("issue_identifier" in output)
+ return output as FeatureRequestCreatedResponse;
+ if ("suggestions" in output && !("error" in output))
+ return output as NoResultsResponse;
+ if ("error" in output || "details" in output)
+ return output as ErrorResponse;
+ }
+ return null;
+}
+
+export function getFeatureRequestOutput(
+ part: unknown,
+): FeatureRequestOutput | null {
+ if (!part || typeof part !== "object") return null;
+ return parseOutput((part as { output?: unknown }).output);
+}
+
+/* ------------------------------------------------------------------ */
+/* Type guards */
+/* ------------------------------------------------------------------ */
+
+export function isSearchResultsOutput(
+ output: FeatureRequestOutput,
+): output is FeatureRequestSearchResponse {
+ return (
+ output.type === "feature_request_search" ||
+ ("results" in output && "query" in output)
+ );
+}
+
+export function isCreatedOutput(
+ output: FeatureRequestOutput,
+): output is FeatureRequestCreatedResponse {
+ return (
+ output.type === "feature_request_created" || "issue_identifier" in output
+ );
+}
+
+export function isNoResultsOutput(
+ output: FeatureRequestOutput,
+): output is NoResultsResponse {
+ return (
+ output.type === "no_results" ||
+ ("suggestions" in output && !("error" in output))
+ );
+}
+
+export function isErrorOutput(
+ output: FeatureRequestOutput,
+): output is ErrorResponse {
+ return output.type === "error" || "error" in output;
+}
+
+/* ------------------------------------------------------------------ */
+/* Accordion metadata */
+/* ------------------------------------------------------------------ */
+
+export function getAccordionTitle(
+ toolType: FeatureRequestToolType,
+ output: FeatureRequestOutput,
+): string {
+ if (toolType === "tool-search_feature_requests") {
+ if (isSearchResultsOutput(output)) return "Feature requests";
+ if (isNoResultsOutput(output)) return "No feature requests found";
+ return "Feature request search error";
+ }
+ if (isCreatedOutput(output)) {
+ return output.is_new_issue
+ ? "Feature request created"
+ : "Added to feature request";
+ }
+ if (isErrorOutput(output)) return "Feature request error";
+ return "Feature request";
+}
+
+/* ------------------------------------------------------------------ */
+/* Animation text */
+/* ------------------------------------------------------------------ */
+
+interface AnimationPart {
+ type: FeatureRequestToolType;
+ state: ToolUIPart["state"];
+ input?: unknown;
+ output?: unknown;
+}
+
+export function getAnimationText(part: AnimationPart): string {
+ if (part.type === "tool-search_feature_requests") {
+ const query = (part.input as { query?: string } | undefined)?.query?.trim();
+ const queryText = query ? ` for "${query}"` : "";
+
+ switch (part.state) {
+ case "input-streaming":
+ case "input-available":
+ return `Searching feature requests${queryText}`;
+ case "output-available": {
+ const output = parseOutput(part.output);
+ if (!output) return `Searching feature requests${queryText}`;
+ if (isSearchResultsOutput(output)) {
+ return `Found ${output.count} feature request${output.count === 1 ? "" : "s"}${queryText}`;
+ }
+ if (isNoResultsOutput(output))
+ return `No feature requests found${queryText}`;
+ return `Error searching feature requests${queryText}`;
+ }
+ case "output-error":
+ return `Error searching feature requests${queryText}`;
+ default:
+ return "Searching feature requests";
+ }
+ }
+
+ // create_feature_request
+ const title = (part.input as { title?: string } | undefined)?.title?.trim();
+ const titleText = title ? ` "${title}"` : "";
+
+ switch (part.state) {
+ case "input-streaming":
+ case "input-available":
+ return `Creating feature request${titleText}`;
+ case "output-available": {
+ const output = parseOutput(part.output);
+ if (!output) return `Creating feature request${titleText}`;
+ if (isCreatedOutput(output)) {
+ return output.is_new_issue
+ ? "Feature request created"
+ : "Added to existing feature request";
+ }
+ if (isErrorOutput(output)) return "Error creating feature request";
+ return `Created feature request${titleText}`;
+ }
+ case "output-error":
+ return "Error creating feature request";
+ default:
+ return "Creating feature request";
+ }
+}
+
+/* ------------------------------------------------------------------ */
+/* Icons */
+/* ------------------------------------------------------------------ */
+
+export function ToolIcon({
+ toolType,
+ isStreaming,
+ isError,
+}: {
+ toolType: FeatureRequestToolType;
+ isStreaming?: boolean;
+ isError?: boolean;
+}) {
+ const IconComponent =
+ toolType === "tool-create_feature_request"
+ ? PlusCircleIcon
+ : MagnifyingGlassIcon;
+
+ return (
+ <IconComponent
+ size={14}
+ weight="regular"
+ className={
+ isError
+ ? "text-red-500"
+ : isStreaming
+ ? "text-neutral-500"
+ : "text-neutral-400"
+ }
+ />
+ );
+}
+
+export function AccordionIcon({
+ toolType,
+}: {
+ toolType: FeatureRequestToolType;
+}) {
+ const IconComponent =
+ toolType === "tool-create_feature_request"
+ ? CheckCircleIcon
+ : LightbulbIcon;
+ return <IconComponent size={32} weight="light" />;
+}
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 496a714ba5..1e8dca865c 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -10495,7 +10495,9 @@
"operation_started",
"operation_pending",
"operation_in_progress",
- "input_validation_error"
+ "input_validation_error",
+ "feature_request_search",
+ "feature_request_created"
],
"title": "ResponseType",
"description": "Types of tool responses."