feat(backend): Implement node-specific auto-approval using key pattern

- Add auto-approval via special nodeExecId key pattern (auto_approve_{graph_exec_id}_{node_id})
- Create auto-approval records in PendingHumanReview when user approves with auto-approve flag
- Check for existing auto-approval before requiring human review
- Remove node_id parameter from get_or_create_human_review
- Load graph settings properly when resuming execution after review

AGENTS.md

@@ -16,32 +16,6 @@ See `docs/content/platform/getting-started.md` for setup instructions.
 - Format Python code with `poetry run format`.
 - Format frontend code using `pnpm format`.
 
-
-## Frontend guidelines:
-
-See `/frontend/CONTRIBUTING.md` for complete patterns. Quick reference:
-
-1. **Pages**: Create in `src/app/(platform)/feature-name/page.tsx`
-   - Add `usePageName.ts` hook for logic
-   - Put sub-components in local `components/` folder
-2. **Components**: Structure as `ComponentName/ComponentName.tsx` + `useComponentName.ts` + `helpers.ts`
-   - Use design system components from `src/components/` (atoms, molecules, organisms)
-   - Never use `src/components/__legacy__/*`
-3. **Data fetching**: Use generated API hooks from `@/app/api/__generated__/endpoints/`
-   - Regenerate with `pnpm generate:api`
-   - Pattern: `use{Method}{Version}{OperationName}`
-4. **Styling**: Tailwind CSS only, use design tokens, Phosphor Icons only
-5. **Testing**: Add Storybook stories for new components, Playwright for E2E
-6. **Code conventions**: Function declarations (not arrow functions) for components/handlers
-- Component props should be `interface Props { ... }` (not exported) unless the interface needs to be used outside the component
-- Separate render logic from business logic (component.tsx + useComponent.ts + helpers.ts)
-- Colocate state when possible and avoid creating large components, use sub-components ( local `/components` folder next to the parent component ) when sensible
-- Avoid large hooks, abstract logic into `helpers.ts` files when sensible
-- Use function declarations for components, arrow functions only for callbacks
-- No barrel files or `index.ts` re-exports
-- Do not use `useCallback` or `useMemo` unless strictly needed
-- Avoid comments at all times unless the code is very complex
-
 ## Testing
 
 - Backend: `poetry run test` (runs pytest with a docker based postgres + prisma).

autogpt_platform/CLAUDE.md

@@ -201,7 +201,7 @@ If you get any pushback or hit complex block conditions check the new_blocks gui
 3. Write tests alongside the route file
 4. Run `poetry run test` to verify
 
-### Frontend guidelines:
+**Frontend feature development:**
 
 See `/frontend/CONTRIBUTING.md` for complete patterns. Quick reference:
 
@@ -217,14 +217,6 @@ See `/frontend/CONTRIBUTING.md` for complete patterns. Quick reference:
 4. **Styling**: Tailwind CSS only, use design tokens, Phosphor Icons only
 5. **Testing**: Add Storybook stories for new components, Playwright for E2E
 6. **Code conventions**: Function declarations (not arrow functions) for components/handlers
-- Component props should be `interface Props { ... }` (not exported) unless the interface needs to be used outside the component
-- Separate render logic from business logic (component.tsx + useComponent.ts + helpers.ts)
-- Colocate state when possible and avoid creating large components, use sub-components ( local `/components` folder next to the parent component ) when sensible
-- Avoid large hooks, abstract logic into `helpers.ts` files when sensible
-- Use function declarations for components, arrow functions only for callbacks
-- No barrel files or `index.ts` re-exports
-- Do not use `useCallback` or `useMemo` unless strictly needed
-- Avoid comments at all times unless the code is very complex
 
 ### Security Implementation
 

autogpt_platform/backend/backend/api/features/chat/model.py

@@ -290,11 +290,6 @@ async def _cache_session(session: ChatSession) -> None:
     await async_redis.setex(redis_key, config.session_ttl, session.model_dump_json())
 
 
-async def cache_chat_session(session: ChatSession) -> None:
-    """Cache a chat session without persisting to the database."""
-    await _cache_session(session)
-
-
 async def _get_session_from_db(session_id: str) -> ChatSession | None:
     """Get a chat session from the database."""
     prisma_session = await chat_db.get_chat_session(session_id)

autogpt_platform/backend/backend/api/features/chat/routes.py

@@ -172,12 +172,12 @@ async def get_session(
         user_id: The optional authenticated user ID, or None for anonymous access.
 
     Returns:
-        SessionDetailResponse: Details for the requested session, or None if not found.
+        SessionDetailResponse: Details for the requested session; raises NotFoundError if not found.
 
     """
     session = await get_chat_session(session_id, user_id)
     if not session:
-        raise NotFoundError(f"Session {session_id} not found.")
+        raise NotFoundError(f"Session {session_id} not found")
 
     messages = [message.model_dump() for message in session.messages]
     logger.info(
@@ -222,8 +222,6 @@ async def stream_chat_post(
     session = await _validate_and_get_session(session_id, user_id)
 
     async def event_generator() -> AsyncGenerator[str, None]:
-        chunk_count = 0
-        first_chunk_type: str | None = None
         async for chunk in chat_service.stream_chat_completion(
             session_id,
             request.message,
@@ -232,26 +230,7 @@ async def stream_chat_post(
             session=session,  # Pass pre-fetched session to avoid double-fetch
             context=request.context,
         ):
-            if chunk_count < 3:
-                logger.info(
-                    "Chat stream chunk",
-                    extra={
-                        "session_id": session_id,
-                        "chunk_type": str(chunk.type),
-                    },
-                )
-            if not first_chunk_type:
-                first_chunk_type = str(chunk.type)
-            chunk_count += 1
             yield chunk.to_sse()
-        logger.info(
-            "Chat stream completed",
-            extra={
-                "session_id": session_id,
-                "chunk_count": chunk_count,
-                "first_chunk_type": first_chunk_type,
-            },
-        )
         # AI SDK protocol termination
         yield "data: [DONE]\n\n"
 
@@ -296,8 +275,6 @@ async def stream_chat_get(
     session = await _validate_and_get_session(session_id, user_id)
 
     async def event_generator() -> AsyncGenerator[str, None]:
-        chunk_count = 0
-        first_chunk_type: str | None = None
         async for chunk in chat_service.stream_chat_completion(
             session_id,
             message,
@@ -305,26 +282,7 @@ async def stream_chat_get(
             user_id=user_id,
             session=session,  # Pass pre-fetched session to avoid double-fetch
         ):
-            if chunk_count < 3:
-                logger.info(
-                    "Chat stream chunk",
-                    extra={
-                        "session_id": session_id,
-                        "chunk_type": str(chunk.type),
-                    },
-                )
-            if not first_chunk_type:
-                first_chunk_type = str(chunk.type)
-            chunk_count += 1
             yield chunk.to_sse()
-        logger.info(
-            "Chat stream completed",
-            extra={
-                "session_id": session_id,
-                "chunk_count": chunk_count,
-                "first_chunk_type": first_chunk_type,
-            },
-        )
         # AI SDK protocol termination
         yield "data: [DONE]\n\n"
 

autogpt_platform/backend/backend/api/features/chat/service.py

@@ -1,20 +1,12 @@
 import asyncio
 import logging
-import time
-from asyncio import CancelledError
 from collections.abc import AsyncGenerator
 from typing import Any
 
 import orjson
 from langfuse import get_client, propagate_attributes
 from langfuse.openai import openai  # type: ignore
-from openai import (
+from openai import APIConnectionError, APIError, APIStatusError, RateLimitError
-    APIConnectionError,
-    APIError,
-    APIStatusError,
-    PermissionDeniedError,
-    RateLimitError,
-)
 from openai.types.chat import ChatCompletionChunk, ChatCompletionToolParam
 
 from backend.data.understanding import (
@@ -29,7 +21,6 @@ from .model import (
     ChatMessage,
     ChatSession,
     Usage,
-    cache_chat_session,
     get_chat_session,
     update_session_title,
     upsert_chat_session,
@@ -305,10 +296,6 @@ async def stream_chat_completion(
                 content="",
             )
             accumulated_tool_calls: list[dict[str, Any]] = []
-            has_saved_assistant_message = False
-            has_appended_streaming_message = False
-            last_cache_time = 0.0
-            last_cache_content_len = 0
 
             # Wrap main logic in try/finally to ensure Langfuse observations are always ended
             has_yielded_end = False
@@ -345,23 +332,6 @@ async def stream_chat_completion(
                         assert assistant_response.content is not None
                         assistant_response.content += delta
                         has_received_text = True
-                        if not has_appended_streaming_message:
-                            session.messages.append(assistant_response)
-                            has_appended_streaming_message = True
-                        current_time = time.monotonic()
-                        content_len = len(assistant_response.content)
-                        if (
-                            current_time - last_cache_time >= 1.0
-                            and content_len > last_cache_content_len
-                        ):
-                            try:
-                                await cache_chat_session(session)
-                            except Exception as e:
-                                logger.warning(
-                                    f"Failed to cache partial session {session.session_id}: {e}"
-                                )
-                            last_cache_time = current_time
-                            last_cache_content_len = content_len
                         yield chunk
                     elif isinstance(chunk, StreamTextEnd):
                         # Emit text-end after text completes
@@ -420,42 +390,10 @@ async def stream_chat_completion(
                             if has_received_text and not text_streaming_ended:
                                 yield StreamTextEnd(id=text_block_id)
                                 text_streaming_ended = True
-
-                            # Save assistant message before yielding finish to ensure it's persisted
-                            # even if client disconnects immediately after receiving StreamFinish
-                            if not has_saved_assistant_message:
-                                messages_to_save_early: list[ChatMessage] = []
-                                if accumulated_tool_calls:
-                                    assistant_response.tool_calls = (
-                                        accumulated_tool_calls
-                                    )
-                                if not has_appended_streaming_message and (
-                                    assistant_response.content
-                                    or assistant_response.tool_calls
-                                ):
-                                    messages_to_save_early.append(assistant_response)
-                                messages_to_save_early.extend(tool_response_messages)
-
-                                if messages_to_save_early:
-                                    session.messages.extend(messages_to_save_early)
-                                    logger.info(
-                                        f"Saving assistant message before StreamFinish: "
-                                        f"content_len={len(assistant_response.content or '')}, "
-                                        f"tool_calls={len(assistant_response.tool_calls or [])}, "
-                                        f"tool_responses={len(tool_response_messages)}"
-                                    )
-                                if (
-                                    messages_to_save_early
-                                    or has_appended_streaming_message
-                                ):
-                                    await upsert_chat_session(session)
-                                    has_saved_assistant_message = True
-
                             has_yielded_end = True
                             yield chunk
                     elif isinstance(chunk, StreamError):
                         has_yielded_error = True
-                        yield chunk
                     elif isinstance(chunk, StreamUsage):
                         session.usage.append(
                             Usage(
@@ -475,27 +413,6 @@ async def stream_chat_completion(
                     langfuse.update_current_trace(output=str(tool_response_messages))
                     langfuse.update_current_span(output=str(tool_response_messages))
 
-            except CancelledError:
-                if not has_saved_assistant_message:
-                    if accumulated_tool_calls:
-                        assistant_response.tool_calls = accumulated_tool_calls
-                    if assistant_response.content:
-                        assistant_response.content = (
-                            f"{assistant_response.content}\n\n[interrupted]"
-                        )
-                    else:
-                        assistant_response.content = "[interrupted]"
-                    if not has_appended_streaming_message:
-                        session.messages.append(assistant_response)
-                    if tool_response_messages:
-                        session.messages.extend(tool_response_messages)
-                    try:
-                        await upsert_chat_session(session)
-                    except Exception as e:
-                        logger.warning(
-                            f"Failed to save interrupted session {session.session_id}: {e}"
-                        )
-                raise
             except Exception as e:
                 logger.error(f"Error during stream: {e!s}", exc_info=True)
 
@@ -517,19 +434,14 @@ async def stream_chat_completion(
                     # Add assistant message if it has content or tool calls
                     if accumulated_tool_calls:
                         assistant_response.tool_calls = accumulated_tool_calls
-                    if not has_appended_streaming_message and (
+                    if assistant_response.content or assistant_response.tool_calls:
-                        assistant_response.content or assistant_response.tool_calls
-                    ):
                         messages_to_save.append(assistant_response)
 
                     # Add tool response messages after assistant message
                     messages_to_save.extend(tool_response_messages)
 
-                    if not has_saved_assistant_message:
+                    session.messages.extend(messages_to_save)
-                        if messages_to_save:
+                    await upsert_chat_session(session)
-                            session.messages.extend(messages_to_save)
-                        if messages_to_save or has_appended_streaming_message:
-                            await upsert_chat_session(session)
 
                     if not has_yielded_error:
                         error_message = str(e)
@@ -560,49 +472,38 @@ async def stream_chat_completion(
                 return  # Exit after retry to avoid double-saving in finally block
 
             # Normal completion path - save session and handle tool call continuation
-            # Only save if we haven't already saved when StreamFinish was received
+            logger.info(
-            if not has_saved_assistant_message:
+                f"Normal completion path: session={session.session_id}, "
+                f"current message_count={len(session.messages)}"
+            )
+
+            # Build the messages list in the correct order
+            messages_to_save: list[ChatMessage] = []
+
+            # Add assistant message with tool_calls if any
+            if accumulated_tool_calls:
+                assistant_response.tool_calls = accumulated_tool_calls
                 logger.info(
-                    f"Normal completion path: session={session.session_id}, "
+                    f"Added {len(accumulated_tool_calls)} tool calls to assistant message"
-                    f"current message_count={len(session.messages)}"
+                )
+            if assistant_response.content or assistant_response.tool_calls:
+                messages_to_save.append(assistant_response)
+                logger.info(
+                    f"Saving assistant message with content_len={len(assistant_response.content or '')}, tool_calls={len(assistant_response.tool_calls or [])}"
                 )
 
-                # Build the messages list in the correct order
+            # Add tool response messages after assistant message
-                messages_to_save: list[ChatMessage] = []
+            messages_to_save.extend(tool_response_messages)
+            logger.info(
+                f"Saving {len(tool_response_messages)} tool response messages, "
+                f"total_to_save={len(messages_to_save)}"
+            )
 
-                # Add assistant message with tool_calls if any
+            session.messages.extend(messages_to_save)
-                if accumulated_tool_calls:
+            logger.info(
-                    assistant_response.tool_calls = accumulated_tool_calls
+                f"Extended session messages, new message_count={len(session.messages)}"
-                    logger.info(
+            )
-                        f"Added {len(accumulated_tool_calls)} tool calls to assistant message"
+            await upsert_chat_session(session)
-                    )
-                if not has_appended_streaming_message and (
-                    assistant_response.content or assistant_response.tool_calls
-                ):
-                    messages_to_save.append(assistant_response)
-                    logger.info(
-                        f"Saving assistant message with content_len={len(assistant_response.content or '')}, tool_calls={len(assistant_response.tool_calls or [])}"
-                    )
-
-                # Add tool response messages after assistant message
-                messages_to_save.extend(tool_response_messages)
-                logger.info(
-                    f"Saving {len(tool_response_messages)} tool response messages, "
-                    f"total_to_save={len(messages_to_save)}"
-                )
-
-                if messages_to_save:
-                    session.messages.extend(messages_to_save)
-                    logger.info(
-                        f"Extended session messages, new message_count={len(session.messages)}"
-                    )
-                if messages_to_save or has_appended_streaming_message:
-                    await upsert_chat_session(session)
-            else:
-                logger.info(
-                    "Assistant message already saved when StreamFinish was received, "
-                    "skipping duplicate save"
-                )
 
             # If we did a tool call, stream the chat completion again to get the next response
             if has_done_tool_call:
@@ -644,12 +545,6 @@ def _is_retryable_error(error: Exception) -> bool:
     return False
 
 
-def _is_region_blocked_error(error: Exception) -> bool:
-    if isinstance(error, PermissionDeniedError):
-        return "not available in your region" in str(error).lower()
-    return "not available in your region" in str(error).lower()
-
-
 async def _stream_chat_chunks(
     session: ChatSession,
     tools: list[ChatCompletionToolParam],
@@ -842,18 +737,7 @@ async def _stream_chat_chunks(
                         f"Error in stream (not retrying): {e!s}",
                         exc_info=True,
                     )
-                    error_code = None
+                    error_response = StreamError(errorText=str(e))
-                    error_text = str(e)
-                    if _is_region_blocked_error(e):
-                        error_code = "MODEL_NOT_AVAILABLE_REGION"
-                        error_text = (
-                            "This model is not available in your region. "
-                            "Please connect via VPN and try again."
-                        )
-                    error_response = StreamError(
-                        errorText=error_text,
-                        code=error_code,
-                    )
                     yield error_response
                     yield StreamFinish()
                     return

autogpt_platform/backend/backend/api/features/executions/review/model.py

@@ -179,6 +179,14 @@ class ReviewRequest(BaseModel):
     reviews: List[ReviewItem] = Field(
         description="All reviews with their approval status, data, and messages"
     )
+    auto_approve_future_actions: bool = Field(
+        default=False,
+        description=(
+            "If true, future reviews from the same blocks (nodes) being approved "
+            "will be automatically approved for the remainder of this execution. "
+            "This only affects the current execution run."
+        ),
+    )
 
     @model_validator(mode="after")
     def validate_review_completeness(self):

autogpt_platform/backend/backend/api/features/executions/review/review_routes_test.py

@@ -490,3 +490,321 @@ def test_process_review_action_invalid_node_exec_id(
     # Should be a 400 Bad Request, not 500 Internal Server Error
     assert response.status_code == 400
     assert "Invalid node execution ID format" in response.json()["detail"]
+
+
+def test_process_review_action_auto_approve_creates_auto_approval_records(
+    mocker: pytest_mock.MockerFixture,
+    sample_pending_review: PendingHumanReviewModel,
+    test_user_id: str,
+) -> None:
+    """Test that auto_approve_future_actions flag creates auto-approval records"""
+    from backend.data.execution import ExecutionContext, NodeExecutionResult
+    from backend.data.graph import GraphSettings
+
+    # Mock process_all_reviews
+    mock_process_all_reviews = mocker.patch(
+        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
+    )
+    approved_review = PendingHumanReviewModel(
+        node_exec_id="test_node_123",
+        user_id=test_user_id,
+        graph_exec_id="test_graph_exec_456",
+        graph_id="test_graph_789",
+        graph_version=1,
+        payload={"data": "test payload"},
+        instructions="Please review",
+        editable=True,
+        status=ReviewStatus.APPROVED,
+        review_message="Approved",
+        was_edited=False,
+        processed=False,
+        created_at=FIXED_NOW,
+        updated_at=FIXED_NOW,
+        reviewed_at=FIXED_NOW,
+    )
+    mock_process_all_reviews.return_value = {"test_node_123": approved_review}
+
+    # Mock get_node_execution to return node_id
+    mock_get_node_execution = mocker.patch(
+        "backend.api.features.executions.review.routes.get_node_execution"
+    )
+    mock_node_exec = mocker.Mock(spec=NodeExecutionResult)
+    mock_node_exec.node_id = "test_node_def_456"
+    mock_get_node_execution.return_value = mock_node_exec
+
+    # Mock create_auto_approval_record
+    mock_create_auto_approval = mocker.patch(
+        "backend.api.features.executions.review.routes.create_auto_approval_record"
+    )
+
+    # Mock has_pending_reviews_for_graph_exec
+    mock_has_pending = mocker.patch(
+        "backend.api.features.executions.review.routes.has_pending_reviews_for_graph_exec"
+    )
+    mock_has_pending.return_value = False
+
+    # Mock get_graph_settings to return custom settings
+    mock_get_settings = mocker.patch(
+        "backend.api.features.executions.review.routes.get_graph_settings"
+    )
+    mock_get_settings.return_value = GraphSettings(
+        human_in_the_loop_safe_mode=True,
+        sensitive_action_safe_mode=True,
+    )
+
+    # Mock add_graph_execution
+    mock_add_execution = mocker.patch(
+        "backend.api.features.executions.review.routes.add_graph_execution"
+    )
+
+    request_data = {
+        "reviews": [
+            {
+                "node_exec_id": "test_node_123",
+                "approved": True,
+                "message": "Approved",
+            }
+        ],
+        "auto_approve_future_actions": True,
+    }
+
+    response = client.post("/api/review/action", json=request_data)
+
+    assert response.status_code == 200
+
+    # Verify process_all_reviews_for_execution was called (without auto_approve param)
+    mock_process_all_reviews.assert_called_once()
+
+    # Verify create_auto_approval_record was called for the approved review
+    mock_create_auto_approval.assert_called_once_with(
+        user_id=test_user_id,
+        graph_exec_id="test_graph_exec_456",
+        graph_id="test_graph_789",
+        graph_version=1,
+        node_id="test_node_def_456",
+        payload={"data": "test payload"},
+    )
+
+    # Verify get_graph_settings was called with correct parameters
+    mock_get_settings.assert_called_once_with(
+        user_id=test_user_id, graph_id="test_graph_789"
+    )
+
+    # Verify add_graph_execution was called with proper ExecutionContext
+    mock_add_execution.assert_called_once()
+    call_kwargs = mock_add_execution.call_args.kwargs
+    execution_context = call_kwargs["execution_context"]
+
+    assert isinstance(execution_context, ExecutionContext)
+    assert execution_context.human_in_the_loop_safe_mode is True
+    assert execution_context.sensitive_action_safe_mode is True
+
+
+def test_process_review_action_without_auto_approve_still_loads_settings(
+    mocker: pytest_mock.MockerFixture,
+    sample_pending_review: PendingHumanReviewModel,
+    test_user_id: str,
+) -> None:
+    """Test that execution context is created with settings even without auto-approve"""
+    from backend.data.execution import ExecutionContext
+    from backend.data.graph import GraphSettings
+
+    # Mock process_all_reviews
+    mock_process_all_reviews = mocker.patch(
+        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
+    )
+    approved_review = PendingHumanReviewModel(
+        node_exec_id="test_node_123",
+        user_id=test_user_id,
+        graph_exec_id="test_graph_exec_456",
+        graph_id="test_graph_789",
+        graph_version=1,
+        payload={"data": "test payload"},
+        instructions="Please review",
+        editable=True,
+        status=ReviewStatus.APPROVED,
+        review_message="Approved",
+        was_edited=False,
+        processed=False,
+        created_at=FIXED_NOW,
+        updated_at=FIXED_NOW,
+        reviewed_at=FIXED_NOW,
+    )
+    mock_process_all_reviews.return_value = {"test_node_123": approved_review}
+
+    # Mock create_auto_approval_record - should NOT be called when auto_approve is False
+    mock_create_auto_approval = mocker.patch(
+        "backend.api.features.executions.review.routes.create_auto_approval_record"
+    )
+
+    # Mock has_pending_reviews_for_graph_exec
+    mock_has_pending = mocker.patch(
+        "backend.api.features.executions.review.routes.has_pending_reviews_for_graph_exec"
+    )
+    mock_has_pending.return_value = False
+
+    # Mock get_graph_settings with sensitive_action_safe_mode enabled
+    mock_get_settings = mocker.patch(
+        "backend.api.features.executions.review.routes.get_graph_settings"
+    )
+    mock_get_settings.return_value = GraphSettings(
+        human_in_the_loop_safe_mode=False,
+        sensitive_action_safe_mode=True,
+    )
+
+    # Mock add_graph_execution
+    mock_add_execution = mocker.patch(
+        "backend.api.features.executions.review.routes.add_graph_execution"
+    )
+
+    # Request WITHOUT auto_approve_future_actions
+    request_data = {
+        "reviews": [
+            {
+                "node_exec_id": "test_node_123",
+                "approved": True,
+                "message": "Approved",
+            }
+        ],
+        "auto_approve_future_actions": False,
+    }
+
+    response = client.post("/api/review/action", json=request_data)
+
+    assert response.status_code == 200
+
+    # Verify process_all_reviews_for_execution was called
+    mock_process_all_reviews.assert_called_once()
+
+    # Verify create_auto_approval_record was NOT called (auto_approve_future_actions=False)
+    mock_create_auto_approval.assert_not_called()
+
+    # Verify settings were loaded
+    mock_get_settings.assert_called_once()
+
+    # Verify ExecutionContext has proper settings
+    mock_add_execution.assert_called_once()
+    call_kwargs = mock_add_execution.call_args.kwargs
+    execution_context = call_kwargs["execution_context"]
+
+    assert isinstance(execution_context, ExecutionContext)
+    assert execution_context.human_in_the_loop_safe_mode is False
+    assert execution_context.sensitive_action_safe_mode is True
+
+
+def test_process_review_action_auto_approve_only_applies_to_approved_reviews(
+    mocker: pytest_mock.MockerFixture,
+    test_user_id: str,
+) -> None:
+    """Test that auto_approve record is created only for approved reviews"""
+    from backend.data.execution import ExecutionContext, NodeExecutionResult
+    from backend.data.graph import GraphSettings
+
+    # Create two reviews - one approved, one rejected
+    approved_review = PendingHumanReviewModel(
+        node_exec_id="node_exec_approved",
+        user_id=test_user_id,
+        graph_exec_id="test_graph_exec_456",
+        graph_id="test_graph_789",
+        graph_version=1,
+        payload={"data": "approved"},
+        instructions="Review",
+        editable=True,
+        status=ReviewStatus.APPROVED,
+        review_message=None,
+        was_edited=False,
+        processed=False,
+        created_at=FIXED_NOW,
+        updated_at=FIXED_NOW,
+        reviewed_at=FIXED_NOW,
+    )
+    rejected_review = PendingHumanReviewModel(
+        node_exec_id="node_exec_rejected",
+        user_id=test_user_id,
+        graph_exec_id="test_graph_exec_456",
+        graph_id="test_graph_789",
+        graph_version=1,
+        payload={"data": "rejected"},
+        instructions="Review",
+        editable=True,
+        status=ReviewStatus.REJECTED,
+        review_message="Rejected",
+        was_edited=False,
+        processed=False,
+        created_at=FIXED_NOW,
+        updated_at=FIXED_NOW,
+        reviewed_at=FIXED_NOW,
+    )
+
+    # Mock process_all_reviews
+    mock_process_all_reviews = mocker.patch(
+        "backend.api.features.executions.review.routes.process_all_reviews_for_execution"
+    )
+    mock_process_all_reviews.return_value = {
+        "node_exec_approved": approved_review,
+        "node_exec_rejected": rejected_review,
+    }
+
+    # Mock get_node_execution to return node_id (only called for approved review)
+    mock_get_node_execution = mocker.patch(
+        "backend.api.features.executions.review.routes.get_node_execution"
+    )
+    mock_node_exec = mocker.Mock(spec=NodeExecutionResult)
+    mock_node_exec.node_id = "test_node_def_approved"
+    mock_get_node_execution.return_value = mock_node_exec
+
+    # Mock create_auto_approval_record
+    mock_create_auto_approval = mocker.patch(
+        "backend.api.features.executions.review.routes.create_auto_approval_record"
+    )
+
+    # Mock has_pending_reviews_for_graph_exec
+    mock_has_pending = mocker.patch(
+        "backend.api.features.executions.review.routes.has_pending_reviews_for_graph_exec"
+    )
+    mock_has_pending.return_value = False
+
+    # Mock get_graph_settings
+    mock_get_settings = mocker.patch(
+        "backend.api.features.executions.review.routes.get_graph_settings"
+    )
+    mock_get_settings.return_value = GraphSettings()
+
+    # Mock add_graph_execution
+    mock_add_execution = mocker.patch(
+        "backend.api.features.executions.review.routes.add_graph_execution"
+    )
+
+    request_data = {
+        "reviews": [
+            {"node_exec_id": "node_exec_approved", "approved": True},
+            {"node_exec_id": "node_exec_rejected", "approved": False},
+        ],
+        "auto_approve_future_actions": True,
+    }
+
+    response = client.post("/api/review/action", json=request_data)
+
+    assert response.status_code == 200
+
+    # Verify process_all_reviews_for_execution was called
+    mock_process_all_reviews.assert_called_once()
+
+    # Verify create_auto_approval_record was called ONLY for the approved review
+    # (not for the rejected one)
+    mock_create_auto_approval.assert_called_once_with(
+        user_id=test_user_id,
+        graph_exec_id="test_graph_exec_456",
+        graph_id="test_graph_789",
+        graph_version=1,
+        node_id="test_node_def_approved",
+        payload={"data": "approved"},
+    )
+
+    # Verify get_node_execution was called only for approved review
+    mock_get_node_execution.assert_called_once_with("node_exec_approved")
+
+    # Verify ExecutionContext was created (auto-approval is now DB-based)
+    call_kwargs = mock_add_execution.call_args.kwargs
+    execution_context = call_kwargs["execution_context"]
+    assert isinstance(execution_context, ExecutionContext)

autogpt_platform/backend/backend/api/features/executions/review/routes.py

@@ -5,8 +5,14 @@ import autogpt_libs.auth as autogpt_auth_lib
 from fastapi import APIRouter, HTTPException, Query, Security, status
 from prisma.enums import ReviewStatus
 
-from backend.data.execution import get_graph_execution_meta
+from backend.data.execution import (
+    ExecutionContext,
+    get_graph_execution_meta,
+    get_node_execution,
+)
+from backend.data.graph import get_graph_settings
 from backend.data.human_review import (
+    create_auto_approval_record,
     get_pending_reviews_for_execution,
     get_pending_reviews_for_user,
     has_pending_reviews_for_graph_exec,
@@ -128,14 +134,20 @@ async def process_review_action(
         )
 
     # Build review decisions map
+    # When auto_approve_future_actions is true, ignore any edited data
+    # (auto-approved reviews should use original data for consistency)
     review_decisions = {}
     for review in request.reviews:
         review_status = (
             ReviewStatus.APPROVED if review.approved else ReviewStatus.REJECTED
         )
+        # If auto-approving future actions, don't allow data modifications
+        reviewed_data = (
+            None if request.auto_approve_future_actions else review.reviewed_data
+        )
         review_decisions[review.node_exec_id] = (
             review_status,
-            review.reviewed_data,
+            reviewed_data,
             review.message,
         )
 
@@ -145,6 +157,22 @@ async def process_review_action(
         review_decisions=review_decisions,
     )
 
+    # Create auto-approval records for approved reviews if requested
+    if request.auto_approve_future_actions:
+        for node_exec_id, review in updated_reviews.items():
+            if review.status == ReviewStatus.APPROVED:
+                # Look up the node_id from the node execution
+                node_exec = await get_node_execution(node_exec_id)
+                if node_exec:
+                    await create_auto_approval_record(
+                        user_id=user_id,
+                        graph_exec_id=review.graph_exec_id,
+                        graph_id=review.graph_id,
+                        graph_version=review.graph_version,
+                        node_id=node_exec.node_id,
+                        payload=review.payload,
+                    )
+
     # Count results
     approved_count = sum(
         1
@@ -169,10 +197,24 @@ async def process_review_action(
         if not still_has_pending:
             # Resume execution
             try:
+                # Load graph settings to create proper execution context
+                settings = await get_graph_settings(
+                    user_id=user_id, graph_id=first_review.graph_id
+                )
+
+                # Create execution context with settings
+                # Note: auto-approval is now handled via database lookup in
+                # check_auto_approval(), no need to pass auto_approved_node_ids
+                execution_context = ExecutionContext(
+                    human_in_the_loop_safe_mode=settings.human_in_the_loop_safe_mode,
+                    sensitive_action_safe_mode=settings.sensitive_action_safe_mode,
+                )
+
                 await add_graph_execution(
                     graph_id=first_review.graph_id,
                     user_id=user_id,
                     graph_exec_id=graph_exec_id,
+                    execution_context=execution_context,
                 )
                 logger.info(f"Resumed execution {graph_exec_id}")
             except Exception as e:

autogpt_platform/backend/backend/blocks/basic.py

@@ -116,6 +116,7 @@ class PrintToConsoleBlock(Block):
             input_schema=PrintToConsoleBlock.Input,
             output_schema=PrintToConsoleBlock.Output,
             test_input={"text": "Hello, World!"},
+            is_sensitive_action=True,
             test_output=[
                 ("output", "Hello, World!"),
                 ("status", "printed"),

autogpt_platform/backend/backend/blocks/helpers/review.py

@@ -10,7 +10,7 @@ from prisma.enums import ReviewStatus
 from pydantic import BaseModel
 
 from backend.data.execution import ExecutionContext, ExecutionStatus
-from backend.data.human_review import ReviewResult
+from backend.data.human_review import ReviewResult, check_auto_approval
 from backend.executor.manager import async_update_node_execution_status
 from backend.util.clients import get_database_manager_async_client
 
@@ -55,6 +55,7 @@ class HITLReviewHelper:
     async def _handle_review_request(
         input_data: Any,
         user_id: str,
+        node_id: str,
         node_exec_id: str,
         graph_exec_id: str,
         graph_id: str,
@@ -69,6 +70,7 @@ class HITLReviewHelper:
         Args:
             input_data: The input data to be reviewed
             user_id: ID of the user requesting the review
+            node_id: ID of the node in the graph definition
             node_exec_id: ID of the node execution
             graph_exec_id: ID of the graph execution
             graph_id: ID of the graph
@@ -83,15 +85,27 @@ class HITLReviewHelper:
         Raises:
             Exception: If review creation or status update fails
         """
-        # Skip review if safe mode is disabled - return auto-approved result
+        # Note: Safe mode checks (human_in_the_loop_safe_mode, sensitive_action_safe_mode)
-        if not execution_context.human_in_the_loop_safe_mode:
+        # are handled by the caller:
+        # - HITL blocks check human_in_the_loop_safe_mode in their run() method
+        # - Sensitive action blocks check sensitive_action_safe_mode in is_block_exec_need_review()
+        # This function only handles auto-approval for specific nodes.
+
+        # Check if this node has been auto-approved in a previous review
+        auto_approval = await check_auto_approval(
+            graph_exec_id=graph_exec_id,
+            node_id=node_id,
+        )
+        if auto_approval:
             logger.info(
-                f"Block {block_name} skipping review for node {node_exec_id} - safe mode disabled"
+                f"Block {block_name} skipping review for node {node_exec_id} - "
+                f"node {node_id} has auto-approval from previous review"
             )
+            # Return a new ReviewResult with the current node_exec_id but approved status
             return ReviewResult(
                 data=input_data,
                 status=ReviewStatus.APPROVED,
-                message="Auto-approved (safe mode disabled)",
+                message="Auto-approved (user approved all future actions for this block)",
                 processed=True,
                 node_exec_id=node_exec_id,
             )
@@ -129,6 +143,7 @@ class HITLReviewHelper:
     async def handle_review_decision(
         input_data: Any,
         user_id: str,
+        node_id: str,
         node_exec_id: str,
         graph_exec_id: str,
         graph_id: str,
@@ -143,6 +158,7 @@ class HITLReviewHelper:
         Args:
             input_data: The input data to be reviewed
             user_id: ID of the user requesting the review
+            node_id: ID of the node in the graph definition
             node_exec_id: ID of the node execution
             graph_exec_id: ID of the graph execution
             graph_id: ID of the graph
@@ -158,6 +174,7 @@ class HITLReviewHelper:
         review_result = await HITLReviewHelper._handle_review_request(
             input_data=input_data,
             user_id=user_id,
+            node_id=node_id,
             node_exec_id=node_exec_id,
             graph_exec_id=graph_exec_id,
             graph_id=graph_id,

autogpt_platform/backend/backend/blocks/human_in_the_loop.py

@@ -97,6 +97,7 @@ class HumanInTheLoopBlock(Block):
         input_data: Input,
         *,
         user_id: str,
+        node_id: str,
         node_exec_id: str,
         graph_exec_id: str,
         graph_id: str,
@@ -115,6 +116,7 @@ class HumanInTheLoopBlock(Block):
         decision = await self.handle_review_decision(
             input_data=input_data.data,
             user_id=user_id,
+            node_id=node_id,
             node_exec_id=node_exec_id,
             graph_exec_id=graph_exec_id,
             graph_id=graph_id,

autogpt_platform/backend/backend/data/block.py

@@ -441,6 +441,7 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         static_output: bool = False,
         block_type: BlockType = BlockType.STANDARD,
         webhook_config: Optional[BlockWebhookConfig | BlockManualWebhookConfig] = None,
+        is_sensitive_action: bool = False,
     ):
         """
         Initialize the block with the given schema.
@@ -473,8 +474,8 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         self.static_output = static_output
         self.block_type = block_type
         self.webhook_config = webhook_config
+        self.is_sensitive_action = is_sensitive_action
         self.execution_stats: NodeExecutionStats = NodeExecutionStats()
-        self.is_sensitive_action: bool = False
 
         if self.webhook_config:
             if isinstance(self.webhook_config, BlockWebhookConfig):
@@ -622,6 +623,7 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         input_data: BlockInput,
         *,
         user_id: str,
+        node_id: str,
         node_exec_id: str,
         graph_exec_id: str,
         graph_id: str,
@@ -648,6 +650,7 @@ class Block(ABC, Generic[BlockSchemaInputType, BlockSchemaOutputType]):
         decision = await HITLReviewHelper.handle_review_decision(
             input_data=input_data,
             user_id=user_id,
+            node_id=node_id,
             node_exec_id=node_exec_id,
             graph_exec_id=graph_exec_id,
             graph_id=graph_id,

autogpt_platform/backend/backend/data/human_review.py

@@ -32,6 +32,87 @@ class ReviewResult(BaseModel):
     node_exec_id: str
 
 
+def get_auto_approve_key(graph_exec_id: str, node_id: str) -> str:
+    """Generate the special nodeExecId key for auto-approval records."""
+    return f"auto_approve_{graph_exec_id}_{node_id}"
+
+
+async def check_auto_approval(
+    graph_exec_id: str,
+    node_id: str,
+) -> Optional[ReviewResult]:
+    """
+    Check if there's an existing auto-approval record for this node in this execution.
+
+    Auto-approval records are stored as PendingHumanReview entries with a special
+    nodeExecId pattern: "auto_approve_{graph_exec_id}_{node_id}"
+
+    Args:
+        graph_exec_id: ID of the graph execution
+        node_id: ID of the node definition (not execution)
+
+    Returns:
+        ReviewResult if auto-approval found, None otherwise
+    """
+    auto_approve_key = get_auto_approve_key(graph_exec_id, node_id)
+
+    # Look for the auto-approval record by its special key
+    auto_approved_review = await PendingHumanReview.prisma().find_unique(
+        where={"nodeExecId": auto_approve_key},
+    )
+
+    if auto_approved_review and auto_approved_review.status == ReviewStatus.APPROVED:
+        logger.info(
+            f"Found auto-approval for node {node_id} in execution {graph_exec_id}"
+        )
+        return ReviewResult(
+            data=auto_approved_review.payload,
+            status=ReviewStatus.APPROVED,
+            message="Auto-approved (user approved all future actions for this block)",
+            processed=True,
+            node_exec_id=auto_approve_key,
+        )
+
+    return None
+
+
+async def create_auto_approval_record(
+    user_id: str,
+    graph_exec_id: str,
+    graph_id: str,
+    graph_version: int,
+    node_id: str,
+    payload: SafeJsonData,
+) -> None:
+    """
+    Create an auto-approval record for a node in this execution.
+
+    This is stored as a PendingHumanReview with a special nodeExecId pattern
+    and status=APPROVED, so future executions of the same node can skip review.
+    """
+    auto_approve_key = get_auto_approve_key(graph_exec_id, node_id)
+
+    await PendingHumanReview.prisma().upsert(
+        where={"nodeExecId": auto_approve_key},
+        data={
+            "create": {
+                "nodeExecId": auto_approve_key,
+                "userId": user_id,
+                "graphExecId": graph_exec_id,
+                "graphId": graph_id,
+                "graphVersion": graph_version,
+                "payload": SafeJson(payload),
+                "instructions": "Auto-approval record",
+                "editable": False,
+                "status": ReviewStatus.APPROVED,
+                "processed": True,
+                "reviewedAt": datetime.now(timezone.utc),
+            },
+            "update": {},  # Already exists, no update needed
+        },
+    )
+
+
 async def get_or_create_human_review(
     user_id: str,
     node_exec_id: str,

autogpt_platform/backend/backend/data/human_review_test.py

@@ -46,8 +46,8 @@ async def test_get_or_create_human_review_new(
     sample_db_review.status = ReviewStatus.WAITING
     sample_db_review.processed = False
 
-    mock_upsert = mocker.patch("backend.data.human_review.PendingHumanReview.prisma")
+    mock_prisma = mocker.patch("backend.data.human_review.PendingHumanReview.prisma")
-    mock_upsert.return_value.upsert = AsyncMock(return_value=sample_db_review)
+    mock_prisma.return_value.upsert = AsyncMock(return_value=sample_db_review)
 
     result = await get_or_create_human_review(
         user_id="test-user-123",
@@ -75,8 +75,8 @@ async def test_get_or_create_human_review_approved(
     sample_db_review.processed = False
     sample_db_review.reviewMessage = "Looks good"
 
-    mock_upsert = mocker.patch("backend.data.human_review.PendingHumanReview.prisma")
+    mock_prisma = mocker.patch("backend.data.human_review.PendingHumanReview.prisma")
-    mock_upsert.return_value.upsert = AsyncMock(return_value=sample_db_review)
+    mock_prisma.return_value.upsert = AsyncMock(return_value=sample_db_review)
 
     result = await get_or_create_human_review(
         user_id="test-user-123",

autogpt_platform/backend/migrations/20260121200000_remove_node_execution_fk_from_pending_human_review/migration.sql

@@ -0,0 +1,7 @@
+-- Remove NodeExecution foreign key from PendingHumanReview
+-- The nodeExecId column remains as the primary key, but we remove the FK constraint
+-- to AgentNodeExecution since PendingHumanReview records can persist after node
+-- execution records are deleted.
+
+-- Drop foreign key constraint that linked PendingHumanReview.nodeExecId to AgentNodeExecution.id
+ALTER TABLE "platform"."PendingHumanReview" DROP CONSTRAINT IF EXISTS "PendingHumanReview_nodeExecId_fkey";

autogpt_platform/backend/schema.prisma

@@ -517,8 +517,6 @@ model AgentNodeExecution {
 
   stats Json?
 
-  PendingHumanReview PendingHumanReview?
-
   @@index([agentGraphExecutionId, agentNodeId, executionStatus])
   @@index([agentNodeId, executionStatus])
   @@index([addedTime, queuedTime])
@@ -567,6 +565,7 @@ enum ReviewStatus {
 }
 
 // Pending human reviews for Human-in-the-loop blocks
+// Also stores auto-approval records with special nodeExecId patterns (e.g., "auto_approve_{graph_exec_id}_{node_id}")
 model PendingHumanReview {
   nodeExecId    String       @id
   userId        String
@@ -585,7 +584,6 @@ model PendingHumanReview {
   reviewedAt    DateTime?
 
   User           User                @relation(fields: [userId], references: [id], onDelete: Cascade)
-  NodeExecution  AgentNodeExecution  @relation(fields: [nodeExecId], references: [id], onDelete: Cascade)
   GraphExecution AgentGraphExecution @relation(fields: [graphExecId], references: [id], onDelete: Cascade)
 
   @@unique([nodeExecId]) // One pending review per node execution

autogpt_platform/frontend/CONTRIBUTING.md

@@ -175,8 +175,6 @@ While server components and actions are cool and cutting-edge, they introduce a
 
 - Prefer [React Query](https://tanstack.com/query/latest/docs/framework/react/overview) for server state, colocated near consumers (see [state colocation](https://kentcdodds.com/blog/state-colocation-will-make-your-react-app-faster))
 - Co-locate UI state inside components/hooks; keep global state minimal
-- Avoid `useMemo` and `useCallback` unless you have a measured performance issue
-- Do not abuse `useEffect`; prefer state colocation and derive values directly when possible
 
 ### Styling and components
 
@@ -551,48 +549,9 @@ Files:
 Types:
 
 - Prefer `interface` for object shapes
-- Component props should be `interface Props { ... }` (not exported)
+- Component props should be `interface Props { ... }`
-- Only use specific exported names (e.g., `export interface MyComponentProps`) when the interface needs to be used outside the component
-- Keep type definitions inline with the component - do not create separate `types.ts` files unless types are shared across multiple files
 - Use precise types; avoid `any` and unsafe casts
 
-**Props naming examples:**
-
-```tsx
-// ✅ Good - internal props, not exported
-interface Props {
-  title: string;
-  onClose: () => void;
-}
-
-export function Modal({ title, onClose }: Props) {
-  // ...
-}
-
-// ✅ Good - exported when needed externally
-export interface ModalProps {
-  title: string;
-  onClose: () => void;
-}
-
-export function Modal({ title, onClose }: ModalProps) {
-  // ...
-}
-
-// ❌ Bad - unnecessarily specific name for internal use
-interface ModalComponentProps {
-  title: string;
-  onClose: () => void;
-}
-
-// ❌ Bad - separate types.ts file for single component
-// types.ts
-export interface ModalProps { ... }
-
-// Modal.tsx
-import type { ModalProps } from './types';
-```
-
 Parameters:
 
 - If more than one parameter is needed, pass a single `Args` object for clarity

autogpt_platform/frontend/src/app/(no-navbar)/logout/page.tsx

@@ -1,58 +0,0 @@
-"use client";
-
-import { LoadingSpinner } from "@/components/atoms/LoadingSpinner/LoadingSpinner";
-import { Text } from "@/components/atoms/Text/Text";
-import { useToast } from "@/components/molecules/Toast/use-toast";
-import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
-import { useRouter } from "next/navigation";
-import { useEffect, useRef } from "react";
-
-const LOGOUT_REDIRECT_DELAY_MS = 400;
-
-function wait(ms: number): Promise<void> {
-  return new Promise(function resolveAfterDelay(resolve) {
-    setTimeout(resolve, ms);
-  });
-}
-
-export default function LogoutPage() {
-  const { logOut } = useSupabase();
-  const { toast } = useToast();
-  const router = useRouter();
-  const hasStartedRef = useRef(false);
-
-  useEffect(
-    function handleLogoutEffect() {
-      if (hasStartedRef.current) return;
-      hasStartedRef.current = true;
-
-      async function runLogout() {
-        try {
-          await logOut();
-        } catch {
-          toast({
-            title: "Failed to log out. Redirecting to login.",
-            variant: "destructive",
-          });
-        } finally {
-          await wait(LOGOUT_REDIRECT_DELAY_MS);
-          router.replace("/login");
-        }
-      }
-
-      void runLogout();
-    },
-    [logOut, router, toast],
-  );
-
-  return (
-    <div className="flex min-h-screen items-center justify-center px-4">
-      <div className="flex flex-col items-center justify-center gap-4 py-8">
-        <LoadingSpinner size="large" />
-        <Text variant="body" className="text-center">
-          Logging you out...
-        </Text>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/auth/callback/route.ts

@@ -9,7 +9,7 @@ export async function GET(request: Request) {
   const { searchParams, origin } = new URL(request.url);
   const code = searchParams.get("code");
 
-  let next = "/";
+  let next = "/marketplace";
 
   if (code) {
     const supabase = await getServerSupabase();

autogpt_platform/frontend/src/app/(platform)/build/components/FloatingSafeModeToogle.tsx

@@ -86,7 +86,6 @@ export function FloatingSafeModeToggle({
   const {
     currentHITLSafeMode,
     showHITLToggle,
-    isHITLStateUndetermined,
     handleHITLToggle,
     currentSensitiveActionSafeMode,
     showSensitiveActionToggle,
@@ -99,16 +98,9 @@ export function FloatingSafeModeToggle({
     return null;
   }
 
-  const showHITL = showHITLToggle && !isHITLStateUndetermined;
-  const showSensitive = showSensitiveActionToggle;
-
-  if (!showHITL && !showSensitive) {
-    return null;
-  }
-
   return (
     <div className={cn("fixed z-50 flex flex-col gap-2", className)}>
-      {showHITL && (
+      {showHITLToggle && (
         <SafeModeButton
           isEnabled={currentHITLSafeMode}
           label="Human in the loop block approval"
@@ -119,7 +111,7 @@ export function FloatingSafeModeToggle({
           fullWidth={fullWidth}
         />
       )}
-      {showSensitive && (
+      {showSensitiveActionToggle && (
         <SafeModeButton
           isEnabled={currentSensitiveActionSafeMode}
           label="Sensitive actions blocks approval"

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/Chat.tsx

@@ -0,0 +1,134 @@
+"use client";
+
+import { Button } from "@/components/atoms/Button/Button";
+import { Text } from "@/components/atoms/Text/Text";
+import { cn } from "@/lib/utils";
+import { List } from "@phosphor-icons/react";
+import React, { useState } from "react";
+import { ChatContainer } from "./components/ChatContainer/ChatContainer";
+import { ChatErrorState } from "./components/ChatErrorState/ChatErrorState";
+import { ChatLoadingState } from "./components/ChatLoadingState/ChatLoadingState";
+import { SessionsDrawer } from "./components/SessionsDrawer/SessionsDrawer";
+import { useChat } from "./useChat";
+
+export interface ChatProps {
+  className?: string;
+  headerTitle?: React.ReactNode;
+  showHeader?: boolean;
+  showSessionInfo?: boolean;
+  showNewChatButton?: boolean;
+  onNewChat?: () => void;
+  headerActions?: React.ReactNode;
+}
+
+export function Chat({
+  className,
+  headerTitle = "AutoGPT Copilot",
+  showHeader = true,
+  showSessionInfo = true,
+  showNewChatButton = true,
+  onNewChat,
+  headerActions,
+}: ChatProps) {
+  const {
+    messages,
+    isLoading,
+    isCreating,
+    error,
+    sessionId,
+    createSession,
+    clearSession,
+    loadSession,
+  } = useChat();
+
+  const [isSessionsDrawerOpen, setIsSessionsDrawerOpen] = useState(false);
+
+  const handleNewChat = () => {
+    clearSession();
+    onNewChat?.();
+  };
+
+  const handleSelectSession = async (sessionId: string) => {
+    try {
+      await loadSession(sessionId);
+    } catch (err) {
+      console.error("Failed to load session:", err);
+    }
+  };
+
+  return (
+    <div className={cn("flex h-full flex-col", className)}>
+      {/* Header */}
+      {showHeader && (
+        <header className="shrink-0 border-t border-zinc-200 bg-white p-3">
+          <div className="flex items-center justify-between">
+            <div className="flex items-center gap-3">
+              <button
+                aria-label="View sessions"
+                onClick={() => setIsSessionsDrawerOpen(true)}
+                className="flex size-8 items-center justify-center rounded hover:bg-zinc-100"
+              >
+                <List width="1.25rem" height="1.25rem" />
+              </button>
+              {typeof headerTitle === "string" ? (
+                <Text variant="h2" className="text-lg font-semibold">
+                  {headerTitle}
+                </Text>
+              ) : (
+                headerTitle
+              )}
+            </div>
+            <div className="flex items-center gap-3">
+              {showSessionInfo && sessionId && (
+                <>
+                  {showNewChatButton && (
+                    <Button
+                      variant="outline"
+                      size="small"
+                      onClick={handleNewChat}
+                    >
+                      New Chat
+                    </Button>
+                  )}
+                </>
+              )}
+              {headerActions}
+            </div>
+          </div>
+        </header>
+      )}
+
+      {/* Main Content */}
+      <main className="flex min-h-0 flex-1 flex-col overflow-hidden">
+        {/* Loading State - show when explicitly loading/creating OR when we don't have a session yet and no error */}
+        {(isLoading || isCreating || (!sessionId && !error)) && (
+          <ChatLoadingState
+            message={isCreating ? "Creating session..." : "Loading..."}
+          />
+        )}
+
+        {/* Error State */}
+        {error && !isLoading && (
+          <ChatErrorState error={error} onRetry={createSession} />
+        )}
+
+        {/* Session Content */}
+        {sessionId && !isLoading && !error && (
+          <ChatContainer
+            sessionId={sessionId}
+            initialMessages={messages}
+            className="flex-1"
+          />
+        )}
+      </main>
+
+      {/* Sessions Drawer */}
+      <SessionsDrawer
+        isOpen={isSessionsDrawerOpen}
+        onClose={() => setIsSessionsDrawerOpen(false)}
+        onSelectSession={handleSelectSession}
+        currentSessionId={sessionId}
+      />
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/AuthPromptWidget/AuthPromptWidget.tsx

@@ -21,7 +21,7 @@ export function AuthPromptWidget({
   message,
   sessionId,
   agentInfo,
-  returnUrl = "/copilot/chat",
+  returnUrl = "/chat",
   className,
 }: AuthPromptWidgetProps) {
   const router = useRouter();

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatContainer/ChatContainer.tsx

@@ -0,0 +1,88 @@
+import type { SessionDetailResponse } from "@/app/api/__generated__/models/sessionDetailResponse";
+import { cn } from "@/lib/utils";
+import { useCallback } from "react";
+import { usePageContext } from "../../usePageContext";
+import { ChatInput } from "../ChatInput/ChatInput";
+import { MessageList } from "../MessageList/MessageList";
+import { QuickActionsWelcome } from "../QuickActionsWelcome/QuickActionsWelcome";
+import { useChatContainer } from "./useChatContainer";
+
+export interface ChatContainerProps {
+  sessionId: string | null;
+  initialMessages: SessionDetailResponse["messages"];
+  className?: string;
+}
+
+export function ChatContainer({
+  sessionId,
+  initialMessages,
+  className,
+}: ChatContainerProps) {
+  const { messages, streamingChunks, isStreaming, sendMessage } =
+    useChatContainer({
+      sessionId,
+      initialMessages,
+    });
+  const { capturePageContext } = usePageContext();
+
+  // Wrap sendMessage to automatically capture page context
+  const sendMessageWithContext = useCallback(
+    async (content: string, isUserMessage: boolean = true) => {
+      const context = capturePageContext();
+      await sendMessage(content, isUserMessage, context);
+    },
+    [sendMessage, capturePageContext],
+  );
+
+  const quickActions = [
+    "Find agents for social media management",
+    "Show me agents for content creation",
+    "Help me automate my business",
+    "What can you help me with?",
+  ];
+
+  return (
+    <div
+      className={cn("flex h-full min-h-0 flex-col", className)}
+      style={{
+        backgroundColor: "#ffffff",
+        backgroundImage:
+          "radial-gradient(#e5e5e5 0.5px, transparent 0.5px), radial-gradient(#e5e5e5 0.5px, #ffffff 0.5px)",
+        backgroundSize: "20px 20px",
+        backgroundPosition: "0 0, 10px 10px",
+      }}
+    >
+      {/* Messages or Welcome Screen */}
+      <div className="flex min-h-0 flex-1 flex-col overflow-hidden pb-24">
+        {messages.length === 0 ? (
+          <QuickActionsWelcome
+            title="Welcome to AutoGPT Copilot"
+            description="Start a conversation to discover and run AI agents."
+            actions={quickActions}
+            onActionClick={sendMessageWithContext}
+            disabled={isStreaming || !sessionId}
+          />
+        ) : (
+          <MessageList
+            messages={messages}
+            streamingChunks={streamingChunks}
+            isStreaming={isStreaming}
+            onSendMessage={sendMessageWithContext}
+            className="flex-1"
+          />
+        )}
+      </div>
+
+      {/* Input - Always visible */}
+      <div className="fixed bottom-0 left-0 right-0 z-50 border-t border-zinc-200 bg-white p-4">
+        <ChatInput
+          onSend={sendMessageWithContext}
+          disabled={isStreaming || !sessionId}
+          placeholder={
+            sessionId ? "Type your message..." : "Creating session..."
+          }
+        />
+      </div>
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatContainer/createStreamEventDispatcher.ts

@@ -1,6 +1,6 @@
 import { toast } from "sonner";
 import { StreamChunk } from "../../useChatStream";
-import type { HandlerDependencies } from "./handlers";
+import type { HandlerDependencies } from "./useChatContainer.handlers";
 import {
   handleError,
   handleLoginNeeded,
@@ -9,30 +9,12 @@ import {
   handleTextEnded,
   handleToolCallStart,
   handleToolResponse,
-  isRegionBlockedError,
+} from "./useChatContainer.handlers";
-} from "./handlers";
 
 export function createStreamEventDispatcher(
   deps: HandlerDependencies,
 ): (chunk: StreamChunk) => void {
   return function dispatchStreamEvent(chunk: StreamChunk): void {
-    if (
-      chunk.type === "text_chunk" ||
-      chunk.type === "tool_call_start" ||
-      chunk.type === "tool_response" ||
-      chunk.type === "login_needed" ||
-      chunk.type === "need_login" ||
-      chunk.type === "error"
-    ) {
-      if (!deps.hasResponseRef.current) {
-        console.info("[ChatStream] First response chunk:", {
-          type: chunk.type,
-          sessionId: deps.sessionId,
-        });
-      }
-      deps.hasResponseRef.current = true;
-    }
-
     switch (chunk.type) {
       case "text_chunk":
         handleTextChunk(chunk, deps);
@@ -56,23 +38,15 @@ export function createStreamEventDispatcher(
         break;
 
       case "stream_end":
-        console.info("[ChatStream] Stream ended:", {
-          sessionId: deps.sessionId,
-          hasResponse: deps.hasResponseRef.current,
-          chunkCount: deps.streamingChunksRef.current.length,
-        });
         handleStreamEnd(chunk, deps);
         break;
 
       case "error":
-        const isRegionBlocked = isRegionBlockedError(chunk);
         handleError(chunk, deps);
         // Show toast at dispatcher level to avoid circular dependencies
-        if (!isRegionBlocked) {
+        toast.error("Chat Error", {
-          toast.error("Chat Error", {
+          description: chunk.message || chunk.content || "An error occurred",
-            description: chunk.message || chunk.content || "An error occurred",
+        });
-          });
-        }
         break;
 
       case "usage":

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatContainer/helpers.ts

@@ -1,33 +1,6 @@
-import { SessionKey, sessionStorage } from "@/services/storage/session-storage";
 import type { ToolResult } from "@/types/chat";
 import type { ChatMessageData } from "../ChatMessage/useChatMessage";
 
-export function hasSentInitialPrompt(sessionId: string): boolean {
-  try {
-    const sent = JSON.parse(
-      sessionStorage.get(SessionKey.CHAT_SENT_INITIAL_PROMPTS) || "{}",
-    );
-    return sent[sessionId] === true;
-  } catch {
-    return false;
-  }
-}
-
-export function markInitialPromptSent(sessionId: string): void {
-  try {
-    const sent = JSON.parse(
-      sessionStorage.get(SessionKey.CHAT_SENT_INITIAL_PROMPTS) || "{}",
-    );
-    sent[sessionId] = true;
-    sessionStorage.set(
-      SessionKey.CHAT_SENT_INITIAL_PROMPTS,
-      JSON.stringify(sent),
-    );
-  } catch {
-    // Ignore storage errors
-  }
-}
-
 export function removePageContext(content: string): string {
   // Remove "Page URL: ..." pattern at start of line (case insensitive, handles various formats)
   let cleaned = content.replace(/^\s*Page URL:\s*[^\n\r]*/gim, "");
@@ -234,22 +207,12 @@ export function parseToolResponse(
     if (responseType === "setup_requirements") {
       return null;
     }
-    if (responseType === "understanding_updated") {
-      return {
-        type: "tool_response",
-        toolId,
-        toolName,
-        result: (parsedResult || result) as ToolResult,
-        success: true,
-        timestamp: timestamp || new Date(),
-      };
-    }
   }
   return {
     type: "tool_response",
     toolId,
     toolName,
-    result: parsedResult ? (parsedResult as ToolResult) : result,
+    result,
     success: true,
     timestamp: timestamp || new Date(),
   };

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatContainer/useChatContainer.handlers.ts

@@ -7,30 +7,15 @@ import {
   parseToolResponse,
 } from "./helpers";
 
-function isToolCallMessage(
-  message: ChatMessageData,
-): message is Extract<ChatMessageData, { type: "tool_call" }> {
-  return message.type === "tool_call";
-}
-
 export interface HandlerDependencies {
   setHasTextChunks: Dispatch<SetStateAction<boolean>>;
   setStreamingChunks: Dispatch<SetStateAction<string[]>>;
   streamingChunksRef: MutableRefObject<string[]>;
-  hasResponseRef: MutableRefObject<boolean>;
   setMessages: Dispatch<SetStateAction<ChatMessageData[]>>;
   setIsStreamingInitiated: Dispatch<SetStateAction<boolean>>;
-  setIsRegionBlockedModalOpen: Dispatch<SetStateAction<boolean>>;
   sessionId: string;
 }
 
-export function isRegionBlockedError(chunk: StreamChunk): boolean {
-  if (chunk.code === "MODEL_NOT_AVAILABLE_REGION") return true;
-  const message = chunk.message || chunk.content;
-  if (typeof message !== "string") return false;
-  return message.toLowerCase().includes("not available in your region");
-}
-
 export function handleTextChunk(chunk: StreamChunk, deps: HandlerDependencies) {
   if (!chunk.content) return;
   deps.setHasTextChunks(true);
@@ -45,17 +30,16 @@ export function handleTextEnded(
   _chunk: StreamChunk,
   deps: HandlerDependencies,
 ) {
+  console.log("[Text Ended] Saving streamed text as assistant message");
   const completedText = deps.streamingChunksRef.current.join("");
   if (completedText.trim()) {
-    deps.setMessages((prev) => {
+    const assistantMessage: ChatMessageData = {
-      const assistantMessage: ChatMessageData = {
+      type: "message",
-        type: "message",
+      role: "assistant",
-        role: "assistant",
+      content: completedText,
-        content: completedText,
+      timestamp: new Date(),
-        timestamp: new Date(),
+    };
-      };
+    deps.setMessages((prev) => [...prev, assistantMessage]);
-      return [...prev, assistantMessage];
-    });
   }
   deps.setStreamingChunks([]);
   deps.streamingChunksRef.current = [];
@@ -66,45 +50,30 @@ export function handleToolCallStart(
   chunk: StreamChunk,
   deps: HandlerDependencies,
 ) {
-  const toolCallMessage: Extract<ChatMessageData, { type: "tool_call" }> = {
+  const toolCallMessage: ChatMessageData = {
     type: "tool_call",
     toolId: chunk.tool_id || `tool-${Date.now()}-${chunk.idx || 0}`,
-    toolName: chunk.tool_name || "Executing",
+    toolName: chunk.tool_name || "Executing...",
     arguments: chunk.arguments || {},
     timestamp: new Date(),
   };
-
+  deps.setMessages((prev) => [...prev, toolCallMessage]);
-  function updateToolCallMessages(prev: ChatMessageData[]) {
+  console.log("[Tool Call Start]", {
-    const existingIndex = prev.findIndex(function findToolCallIndex(msg) {
+    toolId: toolCallMessage.toolId,
-      return isToolCallMessage(msg) && msg.toolId === toolCallMessage.toolId;
+    toolName: toolCallMessage.toolName,
-    });
+    timestamp: new Date().toISOString(),
-    if (existingIndex === -1) {
+  });
-      return [...prev, toolCallMessage];
-    }
-    const nextMessages = [...prev];
-    const existing = nextMessages[existingIndex];
-    if (!isToolCallMessage(existing)) return prev;
-    const nextArguments =
-      toolCallMessage.arguments &&
-      Object.keys(toolCallMessage.arguments).length > 0
-        ? toolCallMessage.arguments
-        : existing.arguments;
-    nextMessages[existingIndex] = {
-      ...existing,
-      toolName: toolCallMessage.toolName || existing.toolName,
-      arguments: nextArguments,
-      timestamp: toolCallMessage.timestamp,
-    };
-    return nextMessages;
-  }
-
-  deps.setMessages(updateToolCallMessages);
 }
 
 export function handleToolResponse(
   chunk: StreamChunk,
   deps: HandlerDependencies,
 ) {
+  console.log("[Tool Response] Received:", {
+    toolId: chunk.tool_id,
+    toolName: chunk.tool_name,
+    timestamp: new Date().toISOString(),
+  });
   let toolName = chunk.tool_name || "unknown";
   if (!chunk.tool_name || chunk.tool_name === "unknown") {
     deps.setMessages((prev) => {
@@ -158,15 +127,22 @@ export function handleToolResponse(
     const toolCallIndex = prev.findIndex(
       (msg) => msg.type === "tool_call" && msg.toolId === chunk.tool_id,
     );
-    const hasResponse = prev.some(
-      (msg) => msg.type === "tool_response" && msg.toolId === chunk.tool_id,
-    );
-    if (hasResponse) return prev;
     if (toolCallIndex !== -1) {
       const newMessages = [...prev];
-      newMessages.splice(toolCallIndex + 1, 0, responseMessage);
+      newMessages[toolCallIndex] = responseMessage;
+      console.log(
+        "[Tool Response] Replaced tool_call with matching tool_id:",
+        chunk.tool_id,
+        "at index:",
+        toolCallIndex,
+      );
       return newMessages;
     }
+    console.warn(
+      "[Tool Response] No tool_call found with tool_id:",
+      chunk.tool_id,
+      "appending instead",
+    );
     return [...prev, responseMessage];
   });
 }
@@ -191,38 +167,55 @@ export function handleStreamEnd(
   deps: HandlerDependencies,
 ) {
   const completedContent = deps.streamingChunksRef.current.join("");
-  if (!completedContent.trim() && !deps.hasResponseRef.current) {
+  // Only save message if there are uncommitted chunks
-    deps.setMessages((prev) => [
+  // (text_ended already saved if there were tool calls)
-      ...prev,
-      {
-        type: "message",
-        role: "assistant",
-        content: "No response received. Please try again.",
-        timestamp: new Date(),
-      },
-    ]);
-  }
   if (completedContent.trim()) {
+    console.log(
+      "[Stream End] Saving remaining streamed text as assistant message",
+    );
     const assistantMessage: ChatMessageData = {
       type: "message",
       role: "assistant",
       content: completedContent,
       timestamp: new Date(),
     };
-    deps.setMessages((prev) => [...prev, assistantMessage]);
+    deps.setMessages((prev) => {
+      const updated = [...prev, assistantMessage];
+      console.log("[Stream End] Final state:", {
+        localMessages: updated.map((m) => ({
+          type: m.type,
+          ...(m.type === "message" && {
+            role: m.role,
+            contentLength: m.content.length,
+          }),
+          ...(m.type === "tool_call" && {
+            toolId: m.toolId,
+            toolName: m.toolName,
+          }),
+          ...(m.type === "tool_response" && {
+            toolId: m.toolId,
+            toolName: m.toolName,
+            success: m.success,
+          }),
+        })),
+        streamingChunks: deps.streamingChunksRef.current,
+        timestamp: new Date().toISOString(),
+      });
+      return updated;
+    });
+  } else {
+    console.log("[Stream End] No uncommitted chunks, message already saved");
   }
   deps.setStreamingChunks([]);
   deps.streamingChunksRef.current = [];
   deps.setHasTextChunks(false);
   deps.setIsStreamingInitiated(false);
+  console.log("[Stream End] Stream complete, messages in local state");
 }
 
 export function handleError(chunk: StreamChunk, deps: HandlerDependencies) {
   const errorMessage = chunk.message || chunk.content || "An error occurred";
   console.error("Stream error:", errorMessage);
-  if (isRegionBlockedError(chunk)) {
-    deps.setIsRegionBlockedModalOpen(true);
-  }
   deps.setIsStreamingInitiated(false);
   deps.setHasTextChunks(false);
   deps.setStreamingChunks([]);

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatContainer/useChatContainer.ts

@@ -1,17 +1,14 @@
 import type { SessionDetailResponse } from "@/app/api/__generated__/models/sessionDetailResponse";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
 import { toast } from "sonner";
 import { useChatStream } from "../../useChatStream";
-import { usePageContext } from "../../usePageContext";
 import type { ChatMessageData } from "../ChatMessage/useChatMessage";
 import { createStreamEventDispatcher } from "./createStreamEventDispatcher";
 import {
   createUserMessage,
   filterAuthMessages,
-  hasSentInitialPrompt,
   isToolCallArray,
   isValidMessage,
-  markInitialPromptSent,
   parseToolResponse,
   removePageContext,
 } from "./helpers";
@@ -19,45 +16,20 @@ import {
 interface Args {
   sessionId: string | null;
   initialMessages: SessionDetailResponse["messages"];
-  initialPrompt?: string;
 }
 
-export function useChatContainer({
+export function useChatContainer({ sessionId, initialMessages }: Args) {
-  sessionId,
-  initialMessages,
-  initialPrompt,
-}: Args) {
   const [messages, setMessages] = useState<ChatMessageData[]>([]);
   const [streamingChunks, setStreamingChunks] = useState<string[]>([]);
   const [hasTextChunks, setHasTextChunks] = useState(false);
   const [isStreamingInitiated, setIsStreamingInitiated] = useState(false);
-  const [isRegionBlockedModalOpen, setIsRegionBlockedModalOpen] =
-    useState(false);
-  const hasResponseRef = useRef(false);
   const streamingChunksRef = useRef<string[]>([]);
-  const previousSessionIdRef = useRef<string | null>(null);
+  const { error, sendMessage: sendStreamMessage } = useChatStream();
-  const {
-    error,
-    sendMessage: sendStreamMessage,
-    stopStreaming,
-  } = useChatStream();
   const isStreaming = isStreamingInitiated || hasTextChunks;
 
-  useEffect(() => {
-    if (sessionId !== previousSessionIdRef.current) {
-      stopStreaming(previousSessionIdRef.current ?? undefined, true);
-      previousSessionIdRef.current = sessionId;
-      setMessages([]);
-      setStreamingChunks([]);
-      streamingChunksRef.current = [];
-      setHasTextChunks(false);
-      setIsStreamingInitiated(false);
-      hasResponseRef.current = false;
-    }
-  }, [sessionId, stopStreaming]);
-
   const allMessages = useMemo(() => {
     const processedInitialMessages: ChatMessageData[] = [];
+    // Map to track tool calls by their ID so we can look up tool names for tool responses
     const toolCallMap = new Map<string, string>();
 
     for (const msg of initialMessages) {
@@ -73,9 +45,13 @@ export function useChatContainer({
         ? new Date(msg.timestamp as string)
         : undefined;
 
+      // Remove page context from user messages when loading existing sessions
       if (role === "user") {
         content = removePageContext(content);
-        if (!content.trim()) continue;
+        // Skip user messages that become empty after removing page context
+        if (!content.trim()) {
+          continue;
+        }
         processedInitialMessages.push({
           type: "message",
           role: "user",
@@ -85,15 +61,19 @@ export function useChatContainer({
         continue;
       }
 
+      // Handle assistant messages first (before tool messages) to build tool call map
       if (role === "assistant") {
+        // Strip <thinking> tags from content
         content = content
           .replace(/<thinking>[\s\S]*?<\/thinking>/gi, "")
           .trim();
 
+        // If assistant has tool calls, create tool_call messages for each
         if (toolCalls && isToolCallArray(toolCalls) && toolCalls.length > 0) {
           for (const toolCall of toolCalls) {
             const toolName = toolCall.function.name;
             const toolId = toolCall.id;
+            // Store tool name for later lookup
             toolCallMap.set(toolId, toolName);
 
             try {
@@ -116,6 +96,7 @@ export function useChatContainer({
               });
             }
           }
+          // Only add assistant message if there's content after stripping thinking tags
           if (content.trim()) {
             processedInitialMessages.push({
               type: "message",
@@ -125,6 +106,7 @@ export function useChatContainer({
             });
           }
         } else if (content.trim()) {
+          // Assistant message without tool calls, but with content
           processedInitialMessages.push({
             type: "message",
             role: "assistant",
@@ -135,6 +117,7 @@ export function useChatContainer({
         continue;
       }
 
+      // Handle tool messages - look up tool name from tool call map
       if (role === "tool") {
         const toolCallId = (msg.tool_call_id as string) || "";
         const toolName = toolCallMap.get(toolCallId) || "unknown";
@@ -150,6 +133,7 @@ export function useChatContainer({
         continue;
       }
 
+      // Handle other message types (system, etc.)
       if (content.trim()) {
         processedInitialMessages.push({
           type: "message",
@@ -170,10 +154,9 @@ export function useChatContainer({
       context?: { url: string; content: string },
     ) {
       if (!sessionId) {
-        console.error("[useChatContainer] Cannot send message: no session ID");
+        console.error("Cannot send message: no session ID");
         return;
       }
-      setIsRegionBlockedModalOpen(false);
       if (isUserMessage) {
         const userMessage = createUserMessage(content);
         setMessages((prev) => [...filterAuthMessages(prev), userMessage]);
@@ -184,19 +167,14 @@ export function useChatContainer({
       streamingChunksRef.current = [];
       setHasTextChunks(false);
       setIsStreamingInitiated(true);
-      hasResponseRef.current = false;
-
       const dispatcher = createStreamEventDispatcher({
         setHasTextChunks,
         setStreamingChunks,
         streamingChunksRef,
-        hasResponseRef,
         setMessages,
-        setIsRegionBlockedModalOpen,
         sessionId,
         setIsStreamingInitiated,
       });
-
       try {
         await sendStreamMessage(
           sessionId,
@@ -206,12 +184,8 @@ export function useChatContainer({
           context,
         );
       } catch (err) {
-        console.error("[useChatContainer] Failed to send message:", err);
+        console.error("Failed to send message:", err);
         setIsStreamingInitiated(false);
-
-        // Don't show error toast for AbortError (expected during cleanup)
-        if (err instanceof Error && err.name === "AbortError") return;
-
         const errorMessage =
           err instanceof Error ? err.message : "Failed to send message";
         toast.error("Failed to send message", {
@@ -222,63 +196,11 @@ export function useChatContainer({
     [sessionId, sendStreamMessage],
   );
 
-  const handleStopStreaming = useCallback(() => {
-    stopStreaming();
-    setStreamingChunks([]);
-    streamingChunksRef.current = [];
-    setHasTextChunks(false);
-    setIsStreamingInitiated(false);
-  }, [stopStreaming]);
-
-  const { capturePageContext } = usePageContext();
-
-  // Send initial prompt if provided (for new sessions from homepage)
-  useEffect(
-    function handleInitialPrompt() {
-      if (!initialPrompt || !sessionId) return;
-      if (initialMessages.length > 0) return;
-      if (hasSentInitialPrompt(sessionId)) return;
-
-      markInitialPromptSent(sessionId);
-      const context = capturePageContext();
-      sendMessage(initialPrompt, true, context);
-    },
-    [
-      initialPrompt,
-      sessionId,
-      initialMessages.length,
-      sendMessage,
-      capturePageContext,
-    ],
-  );
-
-  async function sendMessageWithContext(
-    content: string,
-    isUserMessage: boolean = true,
-  ) {
-    const context = capturePageContext();
-    await sendMessage(content, isUserMessage, context);
-  }
-
-  function handleRegionModalOpenChange(open: boolean) {
-    setIsRegionBlockedModalOpen(open);
-  }
-
-  function handleRegionModalClose() {
-    setIsRegionBlockedModalOpen(false);
-  }
-
   return {
     messages: allMessages,
     streamingChunks,
     isStreaming,
     error,
-    isRegionBlockedModalOpen,
-    setIsRegionBlockedModalOpen,
-    sendMessageWithContext,
-    handleRegionModalOpenChange,
-    handleRegionModalClose,
     sendMessage,
-    stopStreaming: handleStopStreaming,
   };
 }

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatInput/ChatInput.tsx

@@ -0,0 +1,64 @@
+import { Input } from "@/components/atoms/Input/Input";
+import { cn } from "@/lib/utils";
+import { ArrowUpIcon } from "@phosphor-icons/react";
+import { useChatInput } from "./useChatInput";
+
+export interface ChatInputProps {
+  onSend: (message: string) => void;
+  disabled?: boolean;
+  placeholder?: string;
+  className?: string;
+}
+
+export function ChatInput({
+  onSend,
+  disabled = false,
+  placeholder = "Type your message...",
+  className,
+}: ChatInputProps) {
+  const inputId = "chat-input";
+  const { value, setValue, handleKeyDown, handleSend } = useChatInput({
+    onSend,
+    disabled,
+    maxRows: 5,
+    inputId,
+  });
+
+  return (
+    <div className={cn("relative flex-1", className)}>
+      <Input
+        id={inputId}
+        label="Chat message input"
+        hideLabel
+        type="textarea"
+        value={value}
+        onChange={(e) => setValue(e.target.value)}
+        onKeyDown={handleKeyDown}
+        placeholder={placeholder}
+        disabled={disabled}
+        rows={1}
+        wrapperClassName="mb-0 relative"
+        className="pr-12"
+      />
+      <span id="chat-input-hint" className="sr-only">
+        Press Enter to send, Shift+Enter for new line
+      </span>
+
+      <button
+        onClick={handleSend}
+        disabled={disabled || !value.trim()}
+        className={cn(
+          "absolute right-3 top-1/2 flex h-8 w-8 -translate-y-1/2 items-center justify-center rounded-full",
+          "border border-zinc-800 bg-zinc-800 text-white",
+          "hover:border-zinc-900 hover:bg-zinc-900",
+          "disabled:border-zinc-200 disabled:bg-zinc-200 disabled:text-white disabled:opacity-50",
+          "transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-neutral-950",
+          "disabled:pointer-events-none",
+        )}
+        aria-label="Send message"
+      >
+        <ArrowUpIcon className="h-3 w-3" weight="bold" />
+      </button>
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatInput/useChatInput.ts

@@ -0,0 +1,60 @@
+import { KeyboardEvent, useCallback, useEffect, useState } from "react";
+
+interface UseChatInputArgs {
+  onSend: (message: string) => void;
+  disabled?: boolean;
+  maxRows?: number;
+  inputId?: string;
+}
+
+export function useChatInput({
+  onSend,
+  disabled = false,
+  maxRows = 5,
+  inputId = "chat-input",
+}: UseChatInputArgs) {
+  const [value, setValue] = useState("");
+
+  useEffect(() => {
+    const textarea = document.getElementById(inputId) as HTMLTextAreaElement;
+    if (!textarea) return;
+    textarea.style.height = "auto";
+    const lineHeight = parseInt(
+      window.getComputedStyle(textarea).lineHeight,
+      10,
+    );
+    const maxHeight = lineHeight * maxRows;
+    const newHeight = Math.min(textarea.scrollHeight, maxHeight);
+    textarea.style.height = `${newHeight}px`;
+    textarea.style.overflowY =
+      textarea.scrollHeight > maxHeight ? "auto" : "hidden";
+  }, [value, maxRows, inputId]);
+
+  const handleSend = useCallback(() => {
+    if (disabled || !value.trim()) return;
+    onSend(value.trim());
+    setValue("");
+    const textarea = document.getElementById(inputId) as HTMLTextAreaElement;
+    if (textarea) {
+      textarea.style.height = "auto";
+    }
+  }, [value, onSend, disabled, inputId]);
+
+  const handleKeyDown = useCallback(
+    (event: KeyboardEvent<HTMLInputElement | HTMLTextAreaElement>) => {
+      if (event.key === "Enter" && !event.shiftKey) {
+        event.preventDefault();
+        handleSend();
+      }
+      // Shift+Enter allows default behavior (new line) - no need to handle explicitly
+    },
+    [handleSend],
+  );
+
+  return {
+    value,
+    setValue,
+    handleKeyDown,
+    handleSend,
+  };
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ChatMessage/ChatMessage.tsx

@@ -1,65 +1,48 @@
 "use client";
 
+import { useGetV2GetUserProfile } from "@/app/api/__generated__/endpoints/store/store";
+import Avatar, {
+  AvatarFallback,
+  AvatarImage,
+} from "@/components/atoms/Avatar/Avatar";
 import { Button } from "@/components/atoms/Button/Button";
 import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
 import { cn } from "@/lib/utils";
 import {
-  ArrowsClockwiseIcon,
+  ArrowClockwise,
   CheckCircleIcon,
   CheckIcon,
   CopyIcon,
+  RobotIcon,
 } from "@phosphor-icons/react";
 import { useRouter } from "next/navigation";
 import { useCallback, useState } from "react";
+import { getToolActionPhrase } from "../../helpers";
 import { AgentCarouselMessage } from "../AgentCarouselMessage/AgentCarouselMessage";
-import { AIChatBubble } from "../AIChatBubble/AIChatBubble";
 import { AuthPromptWidget } from "../AuthPromptWidget/AuthPromptWidget";
 import { ChatCredentialsSetup } from "../ChatCredentialsSetup/ChatCredentialsSetup";
 import { ExecutionStartedMessage } from "../ExecutionStartedMessage/ExecutionStartedMessage";
 import { MarkdownContent } from "../MarkdownContent/MarkdownContent";
+import { MessageBubble } from "../MessageBubble/MessageBubble";
 import { NoResultsMessage } from "../NoResultsMessage/NoResultsMessage";
 import { ToolCallMessage } from "../ToolCallMessage/ToolCallMessage";
 import { ToolResponseMessage } from "../ToolResponseMessage/ToolResponseMessage";
-import { UserChatBubble } from "../UserChatBubble/UserChatBubble";
 import { useChatMessage, type ChatMessageData } from "./useChatMessage";
-
-function stripInternalReasoning(content: string): string {
-  const cleaned = content.replace(
-    /<internal_reasoning>[\s\S]*?<\/internal_reasoning>/gi,
-    "",
-  );
-  return cleaned.replace(/\n{3,}/g, "\n\n").trim();
-}
-
-function getDisplayContent(message: ChatMessageData, isUser: boolean): string {
-  if (message.type !== "message") return "";
-  if (isUser) return message.content;
-  return stripInternalReasoning(message.content);
-}
-
 export interface ChatMessageProps {
   message: ChatMessageData;
-  messages?: ChatMessageData[];
-  index?: number;
-  isStreaming?: boolean;
   className?: string;
   onDismissLogin?: () => void;
   onDismissCredentials?: () => void;
   onSendMessage?: (content: string, isUserMessage?: boolean) => void;
   agentOutput?: ChatMessageData;
-  isFinalMessage?: boolean;
 }
 
 export function ChatMessage({
   message,
-  messages = [],
-  index = -1,
-  isStreaming = false,
   className,
   onDismissCredentials,
   onSendMessage,
   agentOutput,
-  isFinalMessage = true,
 }: ChatMessageProps) {
   const { user } = useSupabase();
   const router = useRouter();
@@ -71,7 +54,14 @@ export function ChatMessage({
     isLoginNeeded,
     isCredentialsNeeded,
   } = useChatMessage(message);
-  const displayContent = getDisplayContent(message, isUser);
+
+  const { data: profile } = useGetV2GetUserProfile({
+    query: {
+      select: (res) => (res.status === 200 ? res.data : null),
+      enabled: isUser && !!user,
+      queryKey: ["/api/store/profile", user?.id],
+    },
+  });
 
   const handleAllCredentialsComplete = useCallback(
     function handleAllCredentialsComplete() {
@@ -97,25 +87,17 @@ export function ChatMessage({
     }
   }
 
-  const handleCopy = useCallback(
+  const handleCopy = useCallback(async () => {
-    async function handleCopy() {
+    if (message.type !== "message") return;
-      if (message.type !== "message") return;
-      if (!displayContent) return;
 
-      try {
+    try {
-        await navigator.clipboard.writeText(displayContent);
+      await navigator.clipboard.writeText(message.content);
-        setCopied(true);
+      setCopied(true);
-        setTimeout(() => setCopied(false), 2000);
+      setTimeout(() => setCopied(false), 2000);
-      } catch (error) {
+    } catch (error) {
-        console.error("Failed to copy:", error);
+      console.error("Failed to copy:", error);
-      }
+    }
-    },
+  }, [message]);
-    [displayContent, message],
-  );
-
-  function isLongResponse(content: string): boolean {
-    return content.split("\n").length > 5;
-  }
 
   const handleTryAgain = useCallback(() => {
     if (message.type !== "message" || !onSendMessage) return;
@@ -187,45 +169,9 @@ export function ChatMessage({
 
   // Render tool call messages
   if (isToolCall && message.type === "tool_call") {
-    // Check if this tool call is currently streaming
-    // A tool call is streaming if:
-    // 1. isStreaming is true
-    // 2. This is the last tool_call message
-    // 3. There's no tool_response for this tool call yet
-    const isToolCallStreaming =
-      isStreaming &&
-      index >= 0 &&
-      (() => {
-        // Find the last tool_call index
-        let lastToolCallIndex = -1;
-        for (let i = messages.length - 1; i >= 0; i--) {
-          if (messages[i].type === "tool_call") {
-            lastToolCallIndex = i;
-            break;
-          }
-        }
-        // Check if this is the last tool_call and there's no response yet
-        if (index === lastToolCallIndex) {
-          // Check if there's a tool_response for this tool call
-          const hasResponse = messages
-            .slice(index + 1)
-            .some(
-              (msg) =>
-                msg.type === "tool_response" && msg.toolId === message.toolId,
-            );
-          return !hasResponse;
-        }
-        return false;
-      })();
-
     return (
       <div className={cn("px-4 py-2", className)}>
-        <ToolCallMessage
+        <ToolCallMessage toolName={message.toolName} />
-          toolId={message.toolId}
-          toolName={message.toolName}
-          arguments={message.arguments}
-          isStreaming={isToolCallStreaming}
-        />
       </div>
     );
   }
@@ -272,11 +218,27 @@ export function ChatMessage({
 
   // Render tool response messages (but skip agent_output if it's being rendered inside assistant message)
   if (isToolResponse && message.type === "tool_response") {
+    // Check if this is an agent_output that should be rendered inside assistant message
+    if (message.result) {
+      let parsedResult: Record<string, unknown> | null = null;
+      try {
+        parsedResult =
+          typeof message.result === "string"
+            ? JSON.parse(message.result)
+            : (message.result as Record<string, unknown>);
+      } catch {
+        parsedResult = null;
+      }
+      if (parsedResult?.type === "agent_output") {
+        // Skip rendering - this will be rendered inside the assistant message
+        return null;
+      }
+    }
+
     return (
       <div className={cn("px-4 py-2", className)}>
         <ToolResponseMessage
-          toolId={message.toolId}
+          toolName={getToolActionPhrase(message.toolName)}
-          toolName={message.toolName}
           result={message.result}
         />
       </div>
@@ -294,33 +256,40 @@ export function ChatMessage({
         )}
       >
         <div className="flex w-full max-w-3xl gap-3">
+          {!isUser && (
+            <div className="flex-shrink-0">
+              <div className="flex h-7 w-7 items-center justify-center rounded-lg bg-indigo-500">
+                <RobotIcon className="h-4 w-4 text-indigo-50" />
+              </div>
+            </div>
+          )}
+
           <div
             className={cn(
               "flex min-w-0 flex-1 flex-col",
               isUser && "items-end",
             )}
           >
-            {isUser ? (
+            <MessageBubble variant={isUser ? "user" : "assistant"}>
-              <UserChatBubble>
+              <MarkdownContent content={message.content} />
-                <MarkdownContent content={displayContent} />
+              {agentOutput &&
-              </UserChatBubble>
+                agentOutput.type === "tool_response" &&
-            ) : (
+                !isUser && (
-              <AIChatBubble>
-                <MarkdownContent content={displayContent} />
-                {agentOutput && agentOutput.type === "tool_response" && (
                   <div className="mt-4">
                     <ToolResponseMessage
-                      toolId={agentOutput.toolId}
+                      toolName={
-                      toolName={agentOutput.toolName || "Agent Output"}
+                        agentOutput.toolName
+                          ? getToolActionPhrase(agentOutput.toolName)
+                          : "Agent Output"
+                      }
                       result={agentOutput.result}
                     />
                   </div>
                 )}
-              </AIChatBubble>
+            </MessageBubble>
-            )}
             <div
               className={cn(
-                "flex gap-0",
+                "mt-1 flex gap-1",
                 isUser ? "justify-end" : "justify-start",
               )}
             >
@@ -331,25 +300,37 @@ export function ChatMessage({
                   onClick={handleTryAgain}
                   aria-label="Try again"
                 >
-                  <ArrowsClockwiseIcon className="size-4 text-zinc-600" />
+                  <ArrowClockwise className="size-3 text-neutral-500" />
-                </Button>
-              )}
-              {!isUser && isFinalMessage && isLongResponse(displayContent) && (
-                <Button
-                  variant="ghost"
-                  size="icon"
-                  onClick={handleCopy}
-                  aria-label="Copy message"
-                >
-                  {copied ? (
-                    <CheckIcon className="size-4 text-green-600" />
-                  ) : (
-                    <CopyIcon className="size-4 text-zinc-600" />
-                  )}
                 </Button>
               )}
+              <Button
+                variant="ghost"
+                size="icon"
+                onClick={handleCopy}
+                aria-label="Copy message"
+              >
+                {copied ? (
+                  <CheckIcon className="size-3 text-green-600" />
+                ) : (
+                  <CopyIcon className="size-3 text-neutral-500" />
+                )}
+              </Button>
             </div>
           </div>
+
+          {isUser && (
+            <div className="flex-shrink-0">
+              <Avatar className="h-7 w-7">
+                <AvatarImage
+                  src={profile?.avatar_url ?? ""}
+                  alt={profile?.username ?? "User"}
+                />
+                <AvatarFallback className="rounded-lg bg-neutral-200 text-neutral-600">
+                  {profile?.username?.charAt(0)?.toUpperCase() || "U"}
+                </AvatarFallback>
+              </Avatar>
+            </div>
+          )}
         </div>
       </div>
     );

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/MessageBubble/MessageBubble.tsx

@@ -13,9 +13,10 @@ export function MessageBubble({
   className,
 }: MessageBubbleProps) {
   const userTheme = {
-    bg: "bg-purple-100",
+    bg: "bg-slate-900",
-    border: "border-purple-100",
+    border: "border-slate-800",
-    text: "text-slate-900",
+    gradient: "from-slate-900/30 via-slate-800/20 to-transparent",
+    text: "text-slate-50",
   };
 
   const assistantTheme = {
@@ -39,7 +40,9 @@ export function MessageBubble({
       )}
     >
       {/* Gradient flare background */}
-      <div className={cn("absolute inset-0 bg-gradient-to-br")} />
+      <div
+        className={cn("absolute inset-0 bg-gradient-to-br", theme.gradient)}
+      />
       <div
         className={cn(
           "relative z-10 transition-all duration-500 ease-in-out",

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/MessageList/MessageList.tsx

@@ -0,0 +1,121 @@
+"use client";
+
+import { cn } from "@/lib/utils";
+import { ChatMessage } from "../ChatMessage/ChatMessage";
+import type { ChatMessageData } from "../ChatMessage/useChatMessage";
+import { StreamingMessage } from "../StreamingMessage/StreamingMessage";
+import { ThinkingMessage } from "../ThinkingMessage/ThinkingMessage";
+import { useMessageList } from "./useMessageList";
+
+export interface MessageListProps {
+  messages: ChatMessageData[];
+  streamingChunks?: string[];
+  isStreaming?: boolean;
+  className?: string;
+  onStreamComplete?: () => void;
+  onSendMessage?: (content: string) => void;
+}
+
+export function MessageList({
+  messages,
+  streamingChunks = [],
+  isStreaming = false,
+  className,
+  onStreamComplete,
+  onSendMessage,
+}: MessageListProps) {
+  const { messagesEndRef, messagesContainerRef } = useMessageList({
+    messageCount: messages.length,
+    isStreaming,
+  });
+
+  return (
+    <div
+      ref={messagesContainerRef}
+      className={cn(
+        "flex-1 overflow-y-auto",
+        "scrollbar-thin scrollbar-track-transparent scrollbar-thumb-zinc-300",
+        className,
+      )}
+    >
+      <div className="mx-auto flex max-w-3xl flex-col py-4">
+        {/* Render all persisted messages */}
+        {messages.map((message, index) => {
+          // Check if current message is an agent_output tool_response
+          // and if previous message is an assistant message
+          let agentOutput: ChatMessageData | undefined;
+
+          if (message.type === "tool_response" && message.result) {
+            let parsedResult: Record<string, unknown> | null = null;
+            try {
+              parsedResult =
+                typeof message.result === "string"
+                  ? JSON.parse(message.result)
+                  : (message.result as Record<string, unknown>);
+            } catch {
+              parsedResult = null;
+            }
+            if (parsedResult?.type === "agent_output") {
+              const prevMessage = messages[index - 1];
+              if (
+                prevMessage &&
+                prevMessage.type === "message" &&
+                prevMessage.role === "assistant"
+              ) {
+                // This agent output will be rendered inside the previous assistant message
+                // Skip rendering this message separately
+                return null;
+              }
+            }
+          }
+
+          // Check if next message is an agent_output tool_response to include in current assistant message
+          if (message.type === "message" && message.role === "assistant") {
+            const nextMessage = messages[index + 1];
+            if (
+              nextMessage &&
+              nextMessage.type === "tool_response" &&
+              nextMessage.result
+            ) {
+              let parsedResult: Record<string, unknown> | null = null;
+              try {
+                parsedResult =
+                  typeof nextMessage.result === "string"
+                    ? JSON.parse(nextMessage.result)
+                    : (nextMessage.result as Record<string, unknown>);
+              } catch {
+                parsedResult = null;
+              }
+              if (parsedResult?.type === "agent_output") {
+                agentOutput = nextMessage;
+              }
+            }
+          }
+
+          return (
+            <ChatMessage
+              key={index}
+              message={message}
+              onSendMessage={onSendMessage}
+              agentOutput={agentOutput}
+            />
+          );
+        })}
+
+        {/* Render thinking message when streaming but no chunks yet */}
+        {isStreaming && streamingChunks.length === 0 && <ThinkingMessage />}
+
+        {/* Render streaming message if active */}
+        {isStreaming && streamingChunks.length > 0 && (
+          <StreamingMessage
+            chunks={streamingChunks}
+            onComplete={onStreamComplete}
+          />
+        )}
+
+        {/* Invisible div to scroll to */}
+        <div ref={messagesEndRef} />
+      </div>
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/SessionsDrawer/SessionsDrawer.tsx

@@ -81,9 +81,9 @@ export function SessionsDrawer({
                 </Text>
               </div>
             ) : sessions.length === 0 ? (
-              <div className="flex h-full items-center justify-center">
+              <div className="flex items-center justify-center py-8">
                 <Text variant="body" className="text-zinc-500">
-                  You don&apos;t have previously started chats
+                  No sessions found
                 </Text>
               </div>
             ) : (

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/StreamingMessage/StreamingMessage.tsx

@@ -1,6 +1,7 @@
 import { cn } from "@/lib/utils";
-import { AIChatBubble } from "../AIChatBubble/AIChatBubble";
+import { RobotIcon } from "@phosphor-icons/react";
 import { MarkdownContent } from "../MarkdownContent/MarkdownContent";
+import { MessageBubble } from "../MessageBubble/MessageBubble";
 import { useStreamingMessage } from "./useStreamingMessage";
 
 export interface StreamingMessageProps {
@@ -24,10 +25,16 @@ export function StreamingMessage({
       )}
     >
       <div className="flex w-full max-w-3xl gap-3">
+        <div className="flex-shrink-0">
+          <div className="flex h-7 w-7 items-center justify-center rounded-lg bg-indigo-600">
+            <RobotIcon className="h-4 w-4 text-indigo-50" />
+          </div>
+        </div>
+
         <div className="flex min-w-0 flex-1 flex-col">
-          <AIChatBubble>
+          <MessageBubble variant="assistant">
             <MarkdownContent content={displayText} />
-          </AIChatBubble>
+          </MessageBubble>
         </div>
       </div>
     </div>

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ThinkingMessage/ThinkingMessage.tsx

@@ -1,7 +1,7 @@
 import { cn } from "@/lib/utils";
+import { RobotIcon } from "@phosphor-icons/react";
 import { useEffect, useRef, useState } from "react";
-import { AIChatBubble } from "../AIChatBubble/AIChatBubble";
+import { MessageBubble } from "../MessageBubble/MessageBubble";
-import { ChatLoader } from "../ChatLoader/ChatLoader";
 
 export interface ThinkingMessageProps {
   className?: string;
@@ -34,11 +34,22 @@ export function ThinkingMessage({ className }: ThinkingMessageProps) {
       )}
     >
       <div className="flex w-full max-w-3xl gap-3">
+        <div className="flex-shrink-0">
+          <div className="flex h-7 w-7 items-center justify-center rounded-lg bg-indigo-500">
+            <RobotIcon className="h-4 w-4 text-indigo-50" />
+          </div>
+        </div>
+
         <div className="flex min-w-0 flex-1 flex-col">
-          <AIChatBubble>
+          <MessageBubble variant="assistant">
             <div className="transition-all duration-500 ease-in-out">
               {showSlowLoader ? (
-                <ChatLoader />
+                <div className="flex flex-col items-center gap-3 py-2">
+                  <div className="loader" style={{ flexShrink: 0 }} />
+                  <p className="text-sm text-slate-700">
+                    Taking a bit longer to think, wait a moment please
+                  </p>
+                </div>
               ) : (
                 <span
                   className="inline-block bg-gradient-to-r from-neutral-400 via-neutral-600 to-neutral-400 bg-clip-text text-transparent"
@@ -51,7 +62,7 @@ export function ThinkingMessage({ className }: ThinkingMessageProps) {
                 </span>
               )}
             </div>
-          </AIChatBubble>
+          </MessageBubble>
         </div>
       </div>
     </div>

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ToolCallMessage/ToolCallMessage.tsx

@@ -0,0 +1,24 @@
+import { Text } from "@/components/atoms/Text/Text";
+import { cn } from "@/lib/utils";
+import { WrenchIcon } from "@phosphor-icons/react";
+import { getToolActionPhrase } from "../../helpers";
+
+export interface ToolCallMessageProps {
+  toolName: string;
+  className?: string;
+}
+
+export function ToolCallMessage({ toolName, className }: ToolCallMessageProps) {
+  return (
+    <div className={cn("flex items-center justify-center gap-2", className)}>
+      <WrenchIcon
+        size={14}
+        weight="bold"
+        className="flex-shrink-0 text-neutral-500"
+      />
+      <Text variant="small" className="text-neutral-500">
+        {getToolActionPhrase(toolName)}...
+      </Text>
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/components/ToolResponseMessage/ToolResponseMessage.tsx

@@ -0,0 +1,260 @@
+import { Text } from "@/components/atoms/Text/Text";
+import "@/components/contextual/OutputRenderers";
+import {
+  globalRegistry,
+  OutputItem,
+} from "@/components/contextual/OutputRenderers";
+import { cn } from "@/lib/utils";
+import type { ToolResult } from "@/types/chat";
+import { WrenchIcon } from "@phosphor-icons/react";
+import { getToolActionPhrase } from "../../helpers";
+
+export interface ToolResponseMessageProps {
+  toolName: string;
+  result?: ToolResult;
+  success?: boolean;
+  className?: string;
+}
+
+export function ToolResponseMessage({
+  toolName,
+  result,
+  success: _success = true,
+  className,
+}: ToolResponseMessageProps) {
+  if (!result) {
+    return (
+      <div className={cn("flex items-center justify-center gap-2", className)}>
+        <WrenchIcon
+          size={14}
+          weight="bold"
+          className="flex-shrink-0 text-neutral-500"
+        />
+        <Text variant="small" className="text-neutral-500">
+          {getToolActionPhrase(toolName)}...
+        </Text>
+      </div>
+    );
+  }
+
+  let parsedResult: Record<string, unknown> | null = null;
+  try {
+    parsedResult =
+      typeof result === "string"
+        ? JSON.parse(result)
+        : (result as Record<string, unknown>);
+  } catch {
+    parsedResult = null;
+  }
+
+  if (parsedResult && typeof parsedResult === "object") {
+    const responseType = parsedResult.type as string | undefined;
+
+    if (responseType === "agent_output") {
+      const execution = parsedResult.execution as
+        | {
+            outputs?: Record<string, unknown[]>;
+          }
+        | null
+        | undefined;
+      const outputs = execution?.outputs || {};
+      const message = parsedResult.message as string | undefined;
+
+      return (
+        <div className={cn("space-y-4 px-4 py-2", className)}>
+          <div className="flex items-center gap-2">
+            <WrenchIcon
+              size={14}
+              weight="bold"
+              className="flex-shrink-0 text-neutral-500"
+            />
+            <Text variant="small" className="text-neutral-500">
+              {getToolActionPhrase(toolName)}
+            </Text>
+          </div>
+          {message && (
+            <div className="rounded border p-4">
+              <Text variant="small" className="text-neutral-600">
+                {message}
+              </Text>
+            </div>
+          )}
+          {Object.keys(outputs).length > 0 && (
+            <div className="space-y-4">
+              {Object.entries(outputs).map(([outputName, values]) =>
+                values.map((value, index) => {
+                  const renderer = globalRegistry.getRenderer(value);
+                  if (renderer) {
+                    return (
+                      <OutputItem
+                        key={`${outputName}-${index}`}
+                        value={value}
+                        renderer={renderer}
+                        label={outputName}
+                      />
+                    );
+                  }
+                  return (
+                    <div
+                      key={`${outputName}-${index}`}
+                      className="rounded border p-4"
+                    >
+                      <Text variant="large-medium" className="mb-2 capitalize">
+                        {outputName}
+                      </Text>
+                      <pre className="overflow-auto text-sm">
+                        {JSON.stringify(value, null, 2)}
+                      </pre>
+                    </div>
+                  );
+                }),
+              )}
+            </div>
+          )}
+        </div>
+      );
+    }
+
+    if (responseType === "block_output" && parsedResult.outputs) {
+      const outputs = parsedResult.outputs as Record<string, unknown[]>;
+
+      return (
+        <div className={cn("space-y-4 px-4 py-2", className)}>
+          <div className="flex items-center gap-2">
+            <WrenchIcon
+              size={14}
+              weight="bold"
+              className="flex-shrink-0 text-neutral-500"
+            />
+            <Text variant="small" className="text-neutral-500">
+              {getToolActionPhrase(toolName)}
+            </Text>
+          </div>
+          <div className="space-y-4">
+            {Object.entries(outputs).map(([outputName, values]) =>
+              values.map((value, index) => {
+                const renderer = globalRegistry.getRenderer(value);
+                if (renderer) {
+                  return (
+                    <OutputItem
+                      key={`${outputName}-${index}`}
+                      value={value}
+                      renderer={renderer}
+                      label={outputName}
+                    />
+                  );
+                }
+                return (
+                  <div
+                    key={`${outputName}-${index}`}
+                    className="rounded border p-4"
+                  >
+                    <Text variant="large-medium" className="mb-2 capitalize">
+                      {outputName}
+                    </Text>
+                    <pre className="overflow-auto text-sm">
+                      {JSON.stringify(value, null, 2)}
+                    </pre>
+                  </div>
+                );
+              }),
+            )}
+          </div>
+        </div>
+      );
+    }
+
+    // Handle other response types with a message field (e.g., understanding_updated)
+    if (parsedResult.message && typeof parsedResult.message === "string") {
+      // Format tool name from snake_case to Title Case
+      const formattedToolName = toolName
+        .split("_")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(" ");
+
+      // Clean up message - remove incomplete user_name references
+      let cleanedMessage = parsedResult.message;
+      // Remove "Updated understanding with: user_name" pattern if user_name is just a placeholder
+      cleanedMessage = cleanedMessage.replace(
+        /Updated understanding with:\s*user_name\.?\s*/gi,
+        "",
+      );
+      // Remove standalone user_name references
+      cleanedMessage = cleanedMessage.replace(/\buser_name\b\.?\s*/gi, "");
+      cleanedMessage = cleanedMessage.trim();
+
+      // Only show message if it has content after cleaning
+      if (!cleanedMessage) {
+        return (
+          <div
+            className={cn(
+              "flex items-center justify-center gap-2 px-4 py-2",
+              className,
+            )}
+          >
+            <WrenchIcon
+              size={14}
+              weight="bold"
+              className="flex-shrink-0 text-neutral-500"
+            />
+            <Text variant="small" className="text-neutral-500">
+              {formattedToolName}
+            </Text>
+          </div>
+        );
+      }
+
+      return (
+        <div className={cn("space-y-2 px-4 py-2", className)}>
+          <div className="flex items-center justify-center gap-2">
+            <WrenchIcon
+              size={14}
+              weight="bold"
+              className="flex-shrink-0 text-neutral-500"
+            />
+            <Text variant="small" className="text-neutral-500">
+              {formattedToolName}
+            </Text>
+          </div>
+          <div className="rounded border p-4">
+            <Text variant="small" className="text-neutral-600">
+              {cleanedMessage}
+            </Text>
+          </div>
+        </div>
+      );
+    }
+  }
+
+  const renderer = globalRegistry.getRenderer(result);
+  if (renderer) {
+    return (
+      <div className={cn("px-4 py-2", className)}>
+        <div className="mb-2 flex items-center gap-2">
+          <WrenchIcon
+            size={14}
+            weight="bold"
+            className="flex-shrink-0 text-neutral-500"
+          />
+          <Text variant="small" className="text-neutral-500">
+            {getToolActionPhrase(toolName)}
+          </Text>
+        </div>
+        <OutputItem value={result} renderer={renderer} />
+      </div>
+    );
+  }
+
+  return (
+    <div className={cn("flex items-center justify-center gap-2", className)}>
+      <WrenchIcon
+        size={14}
+        weight="bold"
+        className="flex-shrink-0 text-neutral-500"
+      />
+      <Text variant="small" className="text-neutral-500">
+        {getToolActionPhrase(toolName)}...
+      </Text>
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/helpers.ts

@@ -0,0 +1,66 @@
+/**
+ * Maps internal tool names to user-friendly display names with emojis.
+ * @deprecated Use getToolActionPhrase or getToolCompletionPhrase for status messages
+ *
+ * @param toolName - The internal tool name from the backend
+ * @returns A user-friendly display name with an emoji prefix
+ */
+export function getToolDisplayName(toolName: string): string {
+  const toolDisplayNames: Record<string, string> = {
+    find_agent: "🔍 Search Marketplace",
+    get_agent_details: "📋 Get Agent Details",
+    check_credentials: "🔑 Check Credentials",
+    setup_agent: "⚙️ Setup Agent",
+    run_agent: "▶️ Run Agent",
+    get_required_setup_info: "📝 Get Setup Requirements",
+  };
+  return toolDisplayNames[toolName] || toolName;
+}
+
+/**
+ * Maps internal tool names to human-friendly action phrases (present continuous).
+ * Used for tool call messages to indicate what action is currently happening.
+ *
+ * @param toolName - The internal tool name from the backend
+ * @returns A human-friendly action phrase in present continuous tense
+ */
+export function getToolActionPhrase(toolName: string): string {
+  const toolActionPhrases: Record<string, string> = {
+    find_agent: "Looking for agents in the marketplace",
+    agent_carousel: "Looking for agents in the marketplace",
+    get_agent_details: "Learning about the agent",
+    check_credentials: "Checking your credentials",
+    setup_agent: "Setting up the agent",
+    execution_started: "Running the agent",
+    run_agent: "Running the agent",
+    get_required_setup_info: "Getting setup requirements",
+    schedule_agent: "Scheduling the agent to run",
+  };
+
+  // Return mapped phrase or generate human-friendly fallback
+  return toolActionPhrases[toolName] || toolName;
+}
+
+/**
+ * Maps internal tool names to human-friendly completion phrases (past tense).
+ * Used for tool response messages to indicate what action was completed.
+ *
+ * @param toolName - The internal tool name from the backend
+ * @returns A human-friendly completion phrase in past tense
+ */
+export function getToolCompletionPhrase(toolName: string): string {
+  const toolCompletionPhrases: Record<string, string> = {
+    find_agent: "Finished searching the marketplace",
+    get_agent_details: "Got agent details",
+    check_credentials: "Checked credentials",
+    setup_agent: "Agent setup complete",
+    run_agent: "Agent execution started",
+    get_required_setup_info: "Got setup requirements",
+  };
+
+  // Return mapped phrase or generate human-friendly fallback
+  return (
+    toolCompletionPhrases[toolName] ||
+    `Finished ${toolName.replace(/_/g, " ").replace("...", "")}`
+  );
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/useChat.ts

@@ -1,20 +1,17 @@
 "use client";
 
 import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useRef } from "react";
 import { toast } from "sonner";
 import { useChatSession } from "./useChatSession";
 import { useChatStream } from "./useChatStream";
 
-interface UseChatArgs {
+export function useChat() {
-  urlSessionId?: string | null;
+  const hasCreatedSessionRef = useRef(false);
-}
-
-export function useChat({ urlSessionId }: UseChatArgs = {}) {
   const hasClaimedSessionRef = useRef(false);
   const { user } = useSupabase();
   const { sendMessage: sendStreamMessage } = useChatStream();
-  const [showLoader, setShowLoader] = useState(false);
+
   const {
     session,
     sessionId: sessionIdFromHook,
@@ -22,16 +19,27 @@ export function useChat({ urlSessionId }: UseChatArgs = {}) {
     isLoading,
     isCreating,
     error,
-    isSessionNotFound,
     createSession,
     claimSession,
     clearSession: clearSessionBase,
     loadSession,
   } = useChatSession({
-    urlSessionId,
+    urlSessionId: null,
     autoCreate: false,
   });
 
+  useEffect(
+    function autoCreateSession() {
+      if (!hasCreatedSessionRef.current && !isCreating && !sessionIdFromHook) {
+        hasCreatedSessionRef.current = true;
+        createSession().catch((_err) => {
+          hasCreatedSessionRef.current = false;
+        });
+      }
+    },
+    [isCreating, sessionIdFromHook, createSession],
+  );
+
   useEffect(
     function autoClaimSession() {
       if (
@@ -67,17 +75,6 @@ export function useChat({ urlSessionId }: UseChatArgs = {}) {
     ],
   );
 
-  useEffect(() => {
-    if (isLoading || isCreating) {
-      const timer = setTimeout(() => {
-        setShowLoader(true);
-      }, 300);
-      return () => clearTimeout(timer);
-    } else {
-      setShowLoader(false);
-    }
-  }, [isLoading, isCreating]);
-
   useEffect(function monitorNetworkStatus() {
     function handleOnline() {
       toast.success("Connection restored", {
@@ -102,6 +99,7 @@ export function useChat({ urlSessionId }: UseChatArgs = {}) {
 
   function clearSession() {
     clearSessionBase();
+    hasCreatedSessionRef.current = false;
     hasClaimedSessionRef.current = false;
   }
 
@@ -111,11 +109,9 @@ export function useChat({ urlSessionId }: UseChatArgs = {}) {
     isLoading,
     isCreating,
     error,
-    isSessionNotFound,
     createSession,
     clearSession,
     loadSession,
     sessionId: sessionIdFromHook,
-    showLoader,
   };
 }

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/useChatSession.ts

@@ -0,0 +1,271 @@
+import {
+  getGetV2GetSessionQueryKey,
+  getGetV2GetSessionQueryOptions,
+  postV2CreateSession,
+  useGetV2GetSession,
+  usePatchV2SessionAssignUser,
+  usePostV2CreateSession,
+} from "@/app/api/__generated__/endpoints/chat/chat";
+import type { SessionDetailResponse } from "@/app/api/__generated__/models/sessionDetailResponse";
+import { okData } from "@/app/api/helpers";
+import { isValidUUID } from "@/lib/utils";
+import { Key, storage } from "@/services/storage/local-storage";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { toast } from "sonner";
+
+interface UseChatSessionArgs {
+  urlSessionId?: string | null;
+  autoCreate?: boolean;
+}
+
+export function useChatSession({
+  urlSessionId,
+  autoCreate = false,
+}: UseChatSessionArgs = {}) {
+  const queryClient = useQueryClient();
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const justCreatedSessionIdRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    if (urlSessionId) {
+      if (!isValidUUID(urlSessionId)) {
+        console.error("Invalid session ID format:", urlSessionId);
+        toast.error("Invalid session ID", {
+          description:
+            "The session ID in the URL is not valid. Starting a new session...",
+        });
+        setSessionId(null);
+        storage.clean(Key.CHAT_SESSION_ID);
+        return;
+      }
+      setSessionId(urlSessionId);
+      storage.set(Key.CHAT_SESSION_ID, urlSessionId);
+    } else {
+      const storedSessionId = storage.get(Key.CHAT_SESSION_ID);
+      if (storedSessionId) {
+        if (!isValidUUID(storedSessionId)) {
+          console.error("Invalid stored session ID:", storedSessionId);
+          storage.clean(Key.CHAT_SESSION_ID);
+          setSessionId(null);
+        } else {
+          setSessionId(storedSessionId);
+        }
+      } else if (autoCreate) {
+        setSessionId(null);
+      }
+    }
+  }, [urlSessionId, autoCreate]);
+
+  const {
+    mutateAsync: createSessionMutation,
+    isPending: isCreating,
+    error: createError,
+  } = usePostV2CreateSession();
+
+  const {
+    data: sessionData,
+    isLoading: isLoadingSession,
+    error: loadError,
+    refetch,
+  } = useGetV2GetSession(sessionId || "", {
+    query: {
+      enabled: !!sessionId,
+      select: okData,
+      staleTime: Infinity, // Never mark as stale
+      refetchOnMount: false, // Don't refetch on component mount
+      refetchOnWindowFocus: false, // Don't refetch when window regains focus
+      refetchOnReconnect: false, // Don't refetch when network reconnects
+      retry: 1,
+    },
+  });
+
+  const { mutateAsync: claimSessionMutation } = usePatchV2SessionAssignUser();
+
+  const session = useMemo(() => {
+    if (sessionData) return sessionData;
+
+    if (sessionId && justCreatedSessionIdRef.current === sessionId) {
+      return {
+        id: sessionId,
+        user_id: null,
+        messages: [],
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      } as SessionDetailResponse;
+    }
+    return null;
+  }, [sessionData, sessionId]);
+
+  const messages = session?.messages || [];
+  const isLoading = isCreating || isLoadingSession;
+
+  useEffect(() => {
+    if (createError) {
+      setError(
+        createError instanceof Error
+          ? createError
+          : new Error("Failed to create session"),
+      );
+    } else if (loadError) {
+      setError(
+        loadError instanceof Error
+          ? loadError
+          : new Error("Failed to load session"),
+      );
+    } else {
+      setError(null);
+    }
+  }, [createError, loadError]);
+
+  const createSession = useCallback(
+    async function createSession() {
+      try {
+        setError(null);
+        const response = await postV2CreateSession({
+          body: JSON.stringify({}),
+        });
+        if (response.status !== 200) {
+          throw new Error("Failed to create session");
+        }
+        const newSessionId = response.data.id;
+        setSessionId(newSessionId);
+        storage.set(Key.CHAT_SESSION_ID, newSessionId);
+        justCreatedSessionIdRef.current = newSessionId;
+        setTimeout(() => {
+          if (justCreatedSessionIdRef.current === newSessionId) {
+            justCreatedSessionIdRef.current = null;
+          }
+        }, 10000);
+        return newSessionId;
+      } catch (err) {
+        const error =
+          err instanceof Error ? err : new Error("Failed to create session");
+        setError(error);
+        toast.error("Failed to create chat session", {
+          description: error.message,
+        });
+        throw error;
+      }
+    },
+    [createSessionMutation],
+  );
+
+  const loadSession = useCallback(
+    async function loadSession(id: string) {
+      try {
+        setError(null);
+        // Invalidate the query cache for this session to force a fresh fetch
+        await queryClient.invalidateQueries({
+          queryKey: getGetV2GetSessionQueryKey(id),
+        });
+        // Set sessionId after invalidation to ensure the hook refetches
+        setSessionId(id);
+        storage.set(Key.CHAT_SESSION_ID, id);
+        // Force fetch with fresh data (bypass cache)
+        const queryOptions = getGetV2GetSessionQueryOptions(id, {
+          query: {
+            staleTime: 0, // Force fresh fetch
+            retry: 1,
+          },
+        });
+        const result = await queryClient.fetchQuery(queryOptions);
+        if (!result || ("status" in result && result.status !== 200)) {
+          console.warn("Session not found on server, clearing local state");
+          storage.clean(Key.CHAT_SESSION_ID);
+          setSessionId(null);
+          throw new Error("Session not found");
+        }
+      } catch (err) {
+        const error =
+          err instanceof Error ? err : new Error("Failed to load session");
+        setError(error);
+        throw error;
+      }
+    },
+    [queryClient],
+  );
+
+  const refreshSession = useCallback(
+    async function refreshSession() {
+      if (!sessionId) {
+        console.log("[refreshSession] Skipping - no session ID");
+        return;
+      }
+      try {
+        setError(null);
+        await refetch();
+      } catch (err) {
+        const error =
+          err instanceof Error ? err : new Error("Failed to refresh session");
+        setError(error);
+        throw error;
+      }
+    },
+    [sessionId, refetch],
+  );
+
+  const claimSession = useCallback(
+    async function claimSession(id: string) {
+      try {
+        setError(null);
+        await claimSessionMutation({ sessionId: id });
+        if (justCreatedSessionIdRef.current === id) {
+          justCreatedSessionIdRef.current = null;
+        }
+        await queryClient.invalidateQueries({
+          queryKey: getGetV2GetSessionQueryKey(id),
+        });
+        await refetch();
+        toast.success("Session claimed successfully", {
+          description: "Your chat history has been saved to your account",
+        });
+      } catch (err: unknown) {
+        const error =
+          err instanceof Error ? err : new Error("Failed to claim session");
+        const is404 =
+          (typeof err === "object" &&
+            err !== null &&
+            "status" in err &&
+            err.status === 404) ||
+          (typeof err === "object" &&
+            err !== null &&
+            "response" in err &&
+            typeof err.response === "object" &&
+            err.response !== null &&
+            "status" in err.response &&
+            err.response.status === 404);
+        if (!is404) {
+          setError(error);
+          toast.error("Failed to claim session", {
+            description: error.message || "Unable to claim session",
+          });
+        }
+        throw error;
+      }
+    },
+    [claimSessionMutation, queryClient, refetch],
+  );
+
+  const clearSession = useCallback(function clearSession() {
+    setSessionId(null);
+    setError(null);
+    storage.clean(Key.CHAT_SESSION_ID);
+    justCreatedSessionIdRef.current = null;
+  }, []);
+
+  return {
+    session,
+    sessionId,
+    messages,
+    isLoading,
+    isCreating,
+    error,
+    createSession,
+    loadSession,
+    refreshSession,
+    claimSession,
+    clearSession,
+  };
+}

autogpt_platform/frontend/src/app/(platform)/chat/components/Chat/useChatStream.ts

@@ -21,8 +21,6 @@ export interface StreamChunk {
   timestamp?: string;
   content?: string;
   message?: string;
-  code?: string;
-  details?: Record<string, unknown>;
   tool_id?: string;
   tool_name?: string;
   arguments?: ToolArguments;
@@ -140,18 +138,8 @@ function normalizeStreamChunk(
       return { type: "stream_end" };
     case "start":
     case "text-start":
-      return null;
     case "tool-input-start":
-      const toolInputStart = chunk as Extract<
+      return null;
-        VercelStreamChunk,
-        { type: "tool-input-start" }
-      >;
-      return {
-        type: "tool_call_start",
-        tool_id: toolInputStart.toolCallId,
-        tool_name: toolInputStart.toolName,
-        arguments: {},
-      };
   }
 }
 
@@ -161,103 +149,22 @@ export function useChatStream() {
   const retryCountRef = useRef<number>(0);
   const retryTimeoutRef = useRef<NodeJS.Timeout | null>(null);
   const abortControllerRef = useRef<AbortController | null>(null);
-  const currentSessionIdRef = useRef<string | null>(null);
-  const requestStartTimeRef = useRef<number | null>(null);
 
-  const stopStreaming = useCallback(
+  const stopStreaming = useCallback(() => {
-    (sessionId?: string, force: boolean = false) => {
+    if (abortControllerRef.current) {
-      console.log("[useChatStream] stopStreaming called", {
+      abortControllerRef.current.abort();
-        hasAbortController: !!abortControllerRef.current,
+      abortControllerRef.current = null;
-        isAborted: abortControllerRef.current?.signal.aborted,
+    }
-        currentSessionId: currentSessionIdRef.current,
+    if (retryTimeoutRef.current) {
-        requestedSessionId: sessionId,
+      clearTimeout(retryTimeoutRef.current);
-        requestStartTime: requestStartTimeRef.current,
+      retryTimeoutRef.current = null;
-        timeSinceStart: requestStartTimeRef.current
+    }
-          ? Date.now() - requestStartTimeRef.current
+    setIsStreaming(false);
-          : null,
+  }, []);
-        force,
-        stack: new Error().stack,
-      });
-
-      if (
-        sessionId &&
-        currentSessionIdRef.current &&
-        currentSessionIdRef.current !== sessionId
-      ) {
-        console.log(
-          "[useChatStream] Session changed, aborting previous stream",
-          {
-            oldSessionId: currentSessionIdRef.current,
-            newSessionId: sessionId,
-          },
-        );
-      }
-
-      const controller = abortControllerRef.current;
-      if (controller) {
-        const timeSinceStart = requestStartTimeRef.current
-          ? Date.now() - requestStartTimeRef.current
-          : null;
-
-        if (!force && timeSinceStart !== null && timeSinceStart < 100) {
-          console.log(
-            "[useChatStream] Request just started (<100ms), skipping abort to prevent race condition",
-            {
-              timeSinceStart,
-            },
-          );
-          return;
-        }
-
-        try {
-          const signal = controller.signal;
-
-          if (
-            signal &&
-            typeof signal.aborted === "boolean" &&
-            !signal.aborted
-          ) {
-            console.log("[useChatStream] Aborting stream");
-            controller.abort();
-          } else {
-            console.log(
-              "[useChatStream] Stream already aborted or signal invalid",
-            );
-          }
-        } catch (error) {
-          if (error instanceof Error && error.name === "AbortError") {
-            console.log(
-              "[useChatStream] AbortError caught (expected during cleanup)",
-            );
-          } else {
-            console.warn("[useChatStream] Error aborting stream:", error);
-          }
-        } finally {
-          abortControllerRef.current = null;
-          requestStartTimeRef.current = null;
-        }
-      }
-      if (retryTimeoutRef.current) {
-        clearTimeout(retryTimeoutRef.current);
-        retryTimeoutRef.current = null;
-      }
-      setIsStreaming(false);
-    },
-    [],
-  );
 
   useEffect(() => {
-    console.log("[useChatStream] Component mounted");
     return () => {
-      const sessionIdAtUnmount = currentSessionIdRef.current;
+      stopStreaming();
-      console.log(
-        "[useChatStream] Component unmounting, calling stopStreaming",
-        {
-          sessionIdAtUnmount,
-        },
-      );
-      stopStreaming(undefined, false);
-      currentSessionIdRef.current = null;
     };
   }, [stopStreaming]);
 
@@ -270,32 +177,12 @@ export function useChatStream() {
       context?: { url: string; content: string },
       isRetry: boolean = false,
     ) => {
-      console.log("[useChatStream] sendMessage called", {
+      stopStreaming();
-        sessionId,
-        message: message.substring(0, 50),
-        isUserMessage,
-        isRetry,
-        stack: new Error().stack,
-      });
-
-      const previousSessionId = currentSessionIdRef.current;
-      stopStreaming(sessionId, true);
-      currentSessionIdRef.current = sessionId;
 
       const abortController = new AbortController();
       abortControllerRef.current = abortController;
-      requestStartTimeRef.current = Date.now();
-      console.log("[useChatStream] Created new AbortController", {
-        sessionId,
-        previousSessionId,
-        requestStartTime: requestStartTimeRef.current,
-      });
 
       if (abortController.signal.aborted) {
-        console.warn(
-          "[useChatStream] AbortController was aborted before request started",
-        );
-        requestStartTimeRef.current = null;
         return Promise.reject(new Error("Request aborted"));
       }
 
@@ -323,34 +210,18 @@ export function useChatStream() {
           signal: abortController.signal,
         });
 
-        console.info("[useChatStream] Stream response", {
-          sessionId,
-          status: response.status,
-          ok: response.ok,
-          contentType: response.headers.get("content-type"),
-        });
-
         if (!response.ok) {
           const errorText = await response.text();
-          console.warn("[useChatStream] Stream response error", {
-            sessionId,
-            status: response.status,
-            errorText,
-          });
           throw new Error(errorText || `HTTP ${response.status}`);
         }
 
         if (!response.body) {
-          console.warn("[useChatStream] Response body is null", { sessionId });
           throw new Error("Response body is null");
         }
 
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
-        let receivedChunkCount = 0;
-        let firstChunkAt: number | null = null;
-        let loggedLineCount = 0;
 
         return new Promise<void>((resolve, reject) => {
           let didDispatchStreamEnd = false;
@@ -374,13 +245,6 @@ export function useChatStream() {
 
                 if (done) {
                   cleanup();
-                  console.info("[useChatStream] Stream closed", {
-                    sessionId,
-                    receivedChunkCount,
-                    timeSinceStart: requestStartTimeRef.current
-                      ? Date.now() - requestStartTimeRef.current
-                      : null,
-                  });
                   dispatchStreamEnd();
                   retryCountRef.current = 0;
                   stopStreaming();
@@ -395,23 +259,8 @@ export function useChatStream() {
                 for (const line of lines) {
                   if (line.startsWith("data: ")) {
                     const data = line.slice(6);
-                    if (loggedLineCount < 3) {
-                      console.info("[useChatStream] Raw stream line", {
-                        sessionId,
-                        data:
-                          data.length > 300 ? `${data.slice(0, 300)}...` : data,
-                      });
-                      loggedLineCount += 1;
-                    }
                     if (data === "[DONE]") {
                       cleanup();
-                      console.info("[useChatStream] Stream done marker", {
-                        sessionId,
-                        receivedChunkCount,
-                        timeSinceStart: requestStartTimeRef.current
-                          ? Date.now() - requestStartTimeRef.current
-                          : null,
-                      });
                       dispatchStreamEnd();
                       retryCountRef.current = 0;
                       stopStreaming();
@@ -428,18 +277,6 @@ export function useChatStream() {
                         continue;
                       }
 
-                      if (!firstChunkAt) {
-                        firstChunkAt = Date.now();
-                        console.info("[useChatStream] First stream chunk", {
-                          sessionId,
-                          chunkType: chunk.type,
-                          timeSinceStart: requestStartTimeRef.current
-                            ? firstChunkAt - requestStartTimeRef.current
-                            : null,
-                        });
-                      }
-                      receivedChunkCount += 1;
-
                       // Call the chunk handler
                       onChunk(chunk);
 
@@ -447,13 +284,6 @@ export function useChatStream() {
                       if (chunk.type === "stream_end") {
                         didDispatchStreamEnd = true;
                         cleanup();
-                        console.info("[useChatStream] Stream end chunk", {
-                          sessionId,
-                          receivedChunkCount,
-                          timeSinceStart: requestStartTimeRef.current
-                            ? Date.now() - requestStartTimeRef.current
-                            : null,
-                        });
                         retryCountRef.current = 0;
                         stopStreaming();
                         resolve();
@@ -477,9 +307,6 @@ export function useChatStream() {
             } catch (err) {
               if (err instanceof Error && err.name === "AbortError") {
                 cleanup();
-                dispatchStreamEnd();
-                stopStreaming();
-                resolve();
                 return;
               }
 
@@ -525,10 +352,6 @@ export function useChatStream() {
           readStream();
         });
       } catch (err) {
-        if (err instanceof Error && err.name === "AbortError") {
-          setIsStreaming(false);
-          return Promise.resolve();
-        }
         const streamError =
           err instanceof Error ? err : new Error("Failed to start stream");
         setError(streamError);

autogpt_platform/frontend/src/app/(platform)/chat/page.tsx

@@ -0,0 +1,27 @@
+"use client";
+
+import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
+import { useRouter } from "next/navigation";
+import { useEffect } from "react";
+import { Chat } from "./components/Chat/Chat";
+
+export default function ChatPage() {
+  const isChatEnabled = useGetFlag(Flag.CHAT);
+  const router = useRouter();
+
+  useEffect(() => {
+    if (isChatEnabled === false) {
+      router.push("/marketplace");
+    }
+  }, [isChatEnabled, router]);
+
+  if (isChatEnabled === null || isChatEnabled === false) {
+    return null;
+  }
+
+  return (
+    <div className="flex h-full flex-col">
+      <Chat className="flex-1" />
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/CopilotShell.tsx

@@ -1,88 +0,0 @@
-"use client";
-
-import { LoadingSpinner } from "@/components/atoms/LoadingSpinner/LoadingSpinner";
-import { NAVBAR_HEIGHT_PX } from "@/lib/constants";
-import type { ReactNode } from "react";
-import { DesktopSidebar } from "./components/DesktopSidebar/DesktopSidebar";
-import { LoadingState } from "./components/LoadingState/LoadingState";
-import { MobileDrawer } from "./components/MobileDrawer/MobileDrawer";
-import { MobileHeader } from "./components/MobileHeader/MobileHeader";
-import { useCopilotShell } from "./useCopilotShell";
-
-interface Props {
-  children: ReactNode;
-}
-
-export function CopilotShell({ children }: Props) {
-  const {
-    isMobile,
-    isDrawerOpen,
-    isLoading,
-    isLoggedIn,
-    hasActiveSession,
-    sessions,
-    currentSessionId,
-    handleSelectSession,
-    handleOpenDrawer,
-    handleCloseDrawer,
-    handleDrawerOpenChange,
-    handleNewChat,
-    hasNextPage,
-    isFetchingNextPage,
-    fetchNextPage,
-    isReadyToShowContent,
-  } = useCopilotShell();
-
-  if (!isLoggedIn) {
-    return (
-      <div className="flex h-full items-center justify-center">
-        <LoadingSpinner size="large" />
-      </div>
-    );
-  }
-
-  return (
-    <div
-      className="flex overflow-hidden bg-[#EFEFF0]"
-      style={{ height: `calc(100vh - ${NAVBAR_HEIGHT_PX}px)` }}
-    >
-      {!isMobile && (
-        <DesktopSidebar
-          sessions={sessions}
-          currentSessionId={currentSessionId}
-          isLoading={isLoading}
-          hasNextPage={hasNextPage}
-          isFetchingNextPage={isFetchingNextPage}
-          onSelectSession={handleSelectSession}
-          onFetchNextPage={fetchNextPage}
-          onNewChat={handleNewChat}
-          hasActiveSession={Boolean(hasActiveSession)}
-        />
-      )}
-
-      <div className="relative flex min-h-0 flex-1 flex-col">
-        {isMobile && <MobileHeader onOpenDrawer={handleOpenDrawer} />}
-        <div className="flex min-h-0 flex-1 flex-col">
-          {isReadyToShowContent ? children : <LoadingState />}
-        </div>
-      </div>
-
-      {isMobile && (
-        <MobileDrawer
-          isOpen={isDrawerOpen}
-          sessions={sessions}
-          currentSessionId={currentSessionId}
-          isLoading={isLoading}
-          hasNextPage={hasNextPage}
-          isFetchingNextPage={isFetchingNextPage}
-          onSelectSession={handleSelectSession}
-          onFetchNextPage={fetchNextPage}
-          onNewChat={handleNewChat}
-          onClose={handleCloseDrawer}
-          onOpenChange={handleDrawerOpenChange}
-          hasActiveSession={Boolean(hasActiveSession)}
-        />
-      )}
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/components/DesktopSidebar/DesktopSidebar.tsx

@@ -1,70 +0,0 @@
-import type { SessionSummaryResponse } from "@/app/api/__generated__/models/sessionSummaryResponse";
-import { Button } from "@/components/atoms/Button/Button";
-import { Text } from "@/components/atoms/Text/Text";
-import { scrollbarStyles } from "@/components/styles/scrollbars";
-import { cn } from "@/lib/utils";
-import { Plus } from "@phosphor-icons/react";
-import { SessionsList } from "../SessionsList/SessionsList";
-
-interface Props {
-  sessions: SessionSummaryResponse[];
-  currentSessionId: string | null;
-  isLoading: boolean;
-  hasNextPage: boolean;
-  isFetchingNextPage: boolean;
-  onSelectSession: (sessionId: string) => void;
-  onFetchNextPage: () => void;
-  onNewChat: () => void;
-  hasActiveSession: boolean;
-}
-
-export function DesktopSidebar({
-  sessions,
-  currentSessionId,
-  isLoading,
-  hasNextPage,
-  isFetchingNextPage,
-  onSelectSession,
-  onFetchNextPage,
-  onNewChat,
-  hasActiveSession,
-}: Props) {
-  return (
-    <aside className="flex h-full w-80 flex-col border-r border-zinc-100 bg-zinc-50">
-      <div className="shrink-0 px-6 py-4">
-        <Text variant="h3" size="body-medium">
-          Your chats
-        </Text>
-      </div>
-      <div
-        className={cn(
-          "flex min-h-0 flex-1 flex-col overflow-y-auto px-3 py-3",
-          scrollbarStyles,
-        )}
-      >
-        <SessionsList
-          sessions={sessions}
-          currentSessionId={currentSessionId}
-          isLoading={isLoading}
-          hasNextPage={hasNextPage}
-          isFetchingNextPage={isFetchingNextPage}
-          onSelectSession={onSelectSession}
-          onFetchNextPage={onFetchNextPage}
-        />
-      </div>
-      {hasActiveSession && (
-        <div className="shrink-0 bg-zinc-50 p-3 shadow-[0_-4px_6px_-1px_rgba(0,0,0,0.05)]">
-          <Button
-            variant="primary"
-            size="small"
-            onClick={onNewChat}
-            className="w-full"
-            leftIcon={<Plus width="1rem" height="1rem" />}
-          >
-            New Chat
-          </Button>
-        </div>
-      )}
-    </aside>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/components/LoadingState/LoadingState.tsx

@@ -1,15 +0,0 @@
-import { Text } from "@/components/atoms/Text/Text";
-import { ChatLoader } from "@/components/contextual/Chat/components/ChatLoader/ChatLoader";
-
-export function LoadingState() {
-  return (
-    <div className="flex flex-1 items-center justify-center">
-      <div className="flex flex-col items-center gap-4">
-        <ChatLoader />
-        <Text variant="body" className="text-zinc-500">
-          Loading your chats...
-        </Text>
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/components/MobileDrawer/MobileDrawer.tsx

@@ -1,91 +0,0 @@
-import type { SessionSummaryResponse } from "@/app/api/__generated__/models/sessionSummaryResponse";
-import { Button } from "@/components/atoms/Button/Button";
-import { scrollbarStyles } from "@/components/styles/scrollbars";
-import { cn } from "@/lib/utils";
-import { PlusIcon, X } from "@phosphor-icons/react";
-import { Drawer } from "vaul";
-import { SessionsList } from "../SessionsList/SessionsList";
-
-interface Props {
-  isOpen: boolean;
-  sessions: SessionSummaryResponse[];
-  currentSessionId: string | null;
-  isLoading: boolean;
-  hasNextPage: boolean;
-  isFetchingNextPage: boolean;
-  onSelectSession: (sessionId: string) => void;
-  onFetchNextPage: () => void;
-  onNewChat: () => void;
-  onClose: () => void;
-  onOpenChange: (open: boolean) => void;
-  hasActiveSession: boolean;
-}
-
-export function MobileDrawer({
-  isOpen,
-  sessions,
-  currentSessionId,
-  isLoading,
-  hasNextPage,
-  isFetchingNextPage,
-  onSelectSession,
-  onFetchNextPage,
-  onNewChat,
-  onClose,
-  onOpenChange,
-  hasActiveSession,
-}: Props) {
-  return (
-    <Drawer.Root open={isOpen} onOpenChange={onOpenChange} direction="left">
-      <Drawer.Portal>
-        <Drawer.Overlay className="fixed inset-0 z-[60] bg-black/10 backdrop-blur-sm" />
-        <Drawer.Content className="fixed left-0 top-0 z-[70] flex h-full w-80 flex-col border-r border-zinc-200 bg-zinc-50">
-          <div className="shrink-0 border-b border-zinc-200 p-4">
-            <div className="flex items-center justify-between">
-              <Drawer.Title className="text-lg font-semibold text-zinc-800">
-                Your chats
-              </Drawer.Title>
-              <Button
-                variant="icon"
-                size="icon"
-                aria-label="Close sessions"
-                onClick={onClose}
-              >
-                <X width="1.25rem" height="1.25rem" />
-              </Button>
-            </div>
-          </div>
-          <div
-            className={cn(
-              "flex min-h-0 flex-1 flex-col overflow-y-auto px-3 py-3",
-              scrollbarStyles,
-            )}
-          >
-            <SessionsList
-              sessions={sessions}
-              currentSessionId={currentSessionId}
-              isLoading={isLoading}
-              hasNextPage={hasNextPage}
-              isFetchingNextPage={isFetchingNextPage}
-              onSelectSession={onSelectSession}
-              onFetchNextPage={onFetchNextPage}
-            />
-          </div>
-          {hasActiveSession && (
-            <div className="shrink-0 bg-white p-3 shadow-[0_-4px_6px_-1px_rgba(0,0,0,0.05)]">
-              <Button
-                variant="primary"
-                size="small"
-                onClick={onNewChat}
-                className="w-full"
-                leftIcon={<PlusIcon width="1rem" height="1rem" />}
-              >
-                New Chat
-              </Button>
-            </div>
-          )}
-        </Drawer.Content>
-      </Drawer.Portal>
-    </Drawer.Root>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/components/MobileDrawer/useMobileDrawer.ts

@@ -1,24 +0,0 @@
-import { useState } from "react";
-
-export function useMobileDrawer() {
-  const [isDrawerOpen, setIsDrawerOpen] = useState(false);
-
-  function handleOpenDrawer() {
-    setIsDrawerOpen(true);
-  }
-
-  function handleCloseDrawer() {
-    setIsDrawerOpen(false);
-  }
-
-  function handleDrawerOpenChange(open: boolean) {
-    setIsDrawerOpen(open);
-  }
-
-  return {
-    isDrawerOpen,
-    handleOpenDrawer,
-    handleCloseDrawer,
-    handleDrawerOpenChange,
-  };
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/components/MobileHeader/MobileHeader.tsx

@@ -1,22 +0,0 @@
-import { Button } from "@/components/atoms/Button/Button";
-import { NAVBAR_HEIGHT_PX } from "@/lib/constants";
-import { ListIcon } from "@phosphor-icons/react";
-
-interface Props {
-  onOpenDrawer: () => void;
-}
-
-export function MobileHeader({ onOpenDrawer }: Props) {
-  return (
-    <Button
-      variant="icon"
-      size="icon"
-      aria-label="Open sessions"
-      onClick={onOpenDrawer}
-      className="fixed z-50 bg-white shadow-md"
-      style={{ left: "1rem", top: `${NAVBAR_HEIGHT_PX + 20}px` }}
-    >
-      <ListIcon width="1.25rem" height="1.25rem" />
-    </Button>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/components/SessionsList/SessionsList.tsx

@@ -1,80 +0,0 @@
-import type { SessionSummaryResponse } from "@/app/api/__generated__/models/sessionSummaryResponse";
-import { Skeleton } from "@/components/__legacy__/ui/skeleton";
-import { Text } from "@/components/atoms/Text/Text";
-import { InfiniteList } from "@/components/molecules/InfiniteList/InfiniteList";
-import { cn } from "@/lib/utils";
-import { getSessionTitle } from "../../helpers";
-
-interface Props {
-  sessions: SessionSummaryResponse[];
-  currentSessionId: string | null;
-  isLoading: boolean;
-  hasNextPage: boolean;
-  isFetchingNextPage: boolean;
-  onSelectSession: (sessionId: string) => void;
-  onFetchNextPage: () => void;
-}
-
-export function SessionsList({
-  sessions,
-  currentSessionId,
-  isLoading,
-  hasNextPage,
-  isFetchingNextPage,
-  onSelectSession,
-  onFetchNextPage,
-}: Props) {
-  if (isLoading) {
-    return (
-      <div className="space-y-1">
-        {Array.from({ length: 5 }).map((_, i) => (
-          <div key={i} className="rounded-lg px-3 py-2.5">
-            <Skeleton className="h-5 w-full" />
-          </div>
-        ))}
-      </div>
-    );
-  }
-
-  if (sessions.length === 0) {
-    return (
-      <div className="flex h-full items-center justify-center">
-        <Text variant="body" className="text-zinc-500">
-          You don&apos;t have previous chats
-        </Text>
-      </div>
-    );
-  }
-
-  return (
-    <InfiniteList
-      items={sessions}
-      hasMore={hasNextPage}
-      isFetchingMore={isFetchingNextPage}
-      onEndReached={onFetchNextPage}
-      className="space-y-1"
-      renderItem={(session) => {
-        const isActive = session.id === currentSessionId;
-        return (
-          <button
-            onClick={() => onSelectSession(session.id)}
-            className={cn(
-              "w-full rounded-lg px-3 py-2.5 text-left transition-colors",
-              isActive ? "bg-zinc-100" : "hover:bg-zinc-50",
-            )}
-          >
-            <Text
-              variant="body"
-              className={cn(
-                "font-normal",
-                isActive ? "text-zinc-600" : "text-zinc-800",
-              )}
-            >
-              {getSessionTitle(session)}
-            </Text>
-          </button>
-        );
-      }}
-    />
-  );
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/components/SessionsList/useSessionsPagination.ts

@@ -1,92 +0,0 @@
-import { useGetV2ListSessions } from "@/app/api/__generated__/endpoints/chat/chat";
-import type { SessionSummaryResponse } from "@/app/api/__generated__/models/sessionSummaryResponse";
-import { okData } from "@/app/api/helpers";
-import { useEffect, useMemo, useState } from "react";
-
-const PAGE_SIZE = 50;
-
-export interface UseSessionsPaginationArgs {
-  enabled: boolean;
-}
-
-export function useSessionsPagination({ enabled }: UseSessionsPaginationArgs) {
-  const [offset, setOffset] = useState(0);
-  const [accumulatedSessions, setAccumulatedSessions] = useState<
-    SessionSummaryResponse[]
-  >([]);
-  const [totalCount, setTotalCount] = useState<number | null>(null);
-
-  const { data, isLoading, isFetching, isError } = useGetV2ListSessions(
-    { limit: PAGE_SIZE, offset },
-    {
-      query: {
-        enabled: enabled && offset >= 0,
-      },
-    },
-  );
-
-  useEffect(() => {
-    const responseData = okData(data);
-    if (responseData) {
-      const newSessions = responseData.sessions;
-      const total = responseData.total;
-      setTotalCount(total);
-
-      if (offset === 0) {
-        setAccumulatedSessions(newSessions);
-      } else {
-        setAccumulatedSessions((prev) => [...prev, ...newSessions]);
-      }
-    } else if (!enabled) {
-      setAccumulatedSessions([]);
-      setTotalCount(null);
-    }
-  }, [data, offset, enabled]);
-
-  const hasNextPage = useMemo(() => {
-    if (totalCount === null) return false;
-    return accumulatedSessions.length < totalCount;
-  }, [accumulatedSessions.length, totalCount]);
-
-  const areAllSessionsLoaded = useMemo(() => {
-    if (totalCount === null) return false;
-    return (
-      accumulatedSessions.length >= totalCount && !isFetching && !isLoading
-    );
-  }, [accumulatedSessions.length, totalCount, isFetching, isLoading]);
-
-  useEffect(() => {
-    if (
-      hasNextPage &&
-      !isFetching &&
-      !isLoading &&
-      !isError &&
-      totalCount !== null
-    ) {
-      setOffset((prev) => prev + PAGE_SIZE);
-    }
-  }, [hasNextPage, isFetching, isLoading, isError, totalCount]);
-
-  function fetchNextPage() {
-    if (hasNextPage && !isFetching) {
-      setOffset((prev) => prev + PAGE_SIZE);
-    }
-  }
-
-  function reset() {
-    setOffset(0);
-    setAccumulatedSessions([]);
-    setTotalCount(null);
-  }
-
-  return {
-    sessions: accumulatedSessions,
-    isLoading,
-    isFetching,
-    hasNextPage,
-    areAllSessionsLoaded,
-    totalCount,
-    fetchNextPage,
-    reset,
-  };
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/helpers.ts

@@ -1,165 +0,0 @@
-import type { SessionDetailResponse } from "@/app/api/__generated__/models/sessionDetailResponse";
-import type { SessionSummaryResponse } from "@/app/api/__generated__/models/sessionSummaryResponse";
-import { format, formatDistanceToNow, isToday } from "date-fns";
-
-export function convertSessionDetailToSummary(
-  session: SessionDetailResponse,
-): SessionSummaryResponse {
-  return {
-    id: session.id,
-    created_at: session.created_at,
-    updated_at: session.updated_at,
-    title: undefined,
-  };
-}
-
-export function filterVisibleSessions(
-  sessions: SessionSummaryResponse[],
-): SessionSummaryResponse[] {
-  return sessions.filter(
-    (session) => session.updated_at !== session.created_at,
-  );
-}
-
-export function getSessionTitle(session: SessionSummaryResponse): string {
-  if (session.title) return session.title;
-  const isNewSession = session.updated_at === session.created_at;
-  if (isNewSession) {
-    const createdDate = new Date(session.created_at);
-    if (isToday(createdDate)) {
-      return "Today";
-    }
-    return format(createdDate, "MMM d, yyyy");
-  }
-  return "Untitled Chat";
-}
-
-export function getSessionUpdatedLabel(
-  session: SessionSummaryResponse,
-): string {
-  if (!session.updated_at) return "";
-  return formatDistanceToNow(new Date(session.updated_at), { addSuffix: true });
-}
-
-export function mergeCurrentSessionIntoList(
-  accumulatedSessions: SessionSummaryResponse[],
-  currentSessionId: string | null,
-  currentSessionData: SessionDetailResponse | null | undefined,
-): SessionSummaryResponse[] {
-  const filteredSessions: SessionSummaryResponse[] = [];
-
-  if (accumulatedSessions.length > 0) {
-    const visibleSessions = filterVisibleSessions(accumulatedSessions);
-
-    if (currentSessionId) {
-      const currentInAll = accumulatedSessions.find(
-        (s) => s.id === currentSessionId,
-      );
-      if (currentInAll) {
-        const isInVisible = visibleSessions.some(
-          (s) => s.id === currentSessionId,
-        );
-        if (!isInVisible) {
-          filteredSessions.push(currentInAll);
-        }
-      }
-    }
-
-    filteredSessions.push(...visibleSessions);
-  }
-
-  if (currentSessionId && currentSessionData) {
-    const isCurrentInList = filteredSessions.some(
-      (s) => s.id === currentSessionId,
-    );
-    if (!isCurrentInList) {
-      const summarySession = convertSessionDetailToSummary(currentSessionData);
-      filteredSessions.unshift(summarySession);
-    }
-  }
-
-  return filteredSessions;
-}
-
-export function getCurrentSessionId(
-  searchParams: URLSearchParams,
-): string | null {
-  return searchParams.get("sessionId");
-}
-
-export function shouldAutoSelectSession(
-  areAllSessionsLoaded: boolean,
-  hasAutoSelectedSession: boolean,
-  paramSessionId: string | null,
-  visibleSessions: SessionSummaryResponse[],
-  accumulatedSessions: SessionSummaryResponse[],
-  isLoading: boolean,
-  totalCount: number | null,
-): {
-  shouldSelect: boolean;
-  sessionIdToSelect: string | null;
-  shouldCreate: boolean;
-} {
-  if (!areAllSessionsLoaded || hasAutoSelectedSession) {
-    return {
-      shouldSelect: false,
-      sessionIdToSelect: null,
-      shouldCreate: false,
-    };
-  }
-
-  if (paramSessionId) {
-    return {
-      shouldSelect: false,
-      sessionIdToSelect: null,
-      shouldCreate: false,
-    };
-  }
-
-  if (visibleSessions.length > 0) {
-    return {
-      shouldSelect: true,
-      sessionIdToSelect: visibleSessions[0].id,
-      shouldCreate: false,
-    };
-  }
-
-  if (accumulatedSessions.length === 0 && !isLoading && totalCount === 0) {
-    return { shouldSelect: false, sessionIdToSelect: null, shouldCreate: true };
-  }
-
-  if (totalCount === 0) {
-    return {
-      shouldSelect: false,
-      sessionIdToSelect: null,
-      shouldCreate: false,
-    };
-  }
-
-  return { shouldSelect: false, sessionIdToSelect: null, shouldCreate: false };
-}
-
-export function checkReadyToShowContent(
-  areAllSessionsLoaded: boolean,
-  paramSessionId: string | null,
-  accumulatedSessions: SessionSummaryResponse[],
-  isCurrentSessionLoading: boolean,
-  currentSessionData: SessionDetailResponse | null | undefined,
-  hasAutoSelectedSession: boolean,
-): boolean {
-  if (!areAllSessionsLoaded) return false;
-
-  if (paramSessionId) {
-    const sessionFound = accumulatedSessions.some(
-      (s) => s.id === paramSessionId,
-    );
-    return (
-      sessionFound ||
-      (!isCurrentSessionLoading &&
-        currentSessionData !== undefined &&
-        currentSessionData !== null)
-    );
-  }
-
-  return hasAutoSelectedSession;
-}

autogpt_platform/frontend/src/app/(platform)/copilot/components/CopilotShell/useCopilotShell.ts

@@ -1,170 +0,0 @@
-"use client";
-
-import {
-  getGetV2ListSessionsQueryKey,
-  useGetV2GetSession,
-} from "@/app/api/__generated__/endpoints/chat/chat";
-import { okData } from "@/app/api/helpers";
-import { useBreakpoint } from "@/lib/hooks/useBreakpoint";
-import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
-import { useQueryClient } from "@tanstack/react-query";
-import { usePathname, useRouter, useSearchParams } from "next/navigation";
-import { useEffect, useRef, useState } from "react";
-import { useMobileDrawer } from "./components/MobileDrawer/useMobileDrawer";
-import { useSessionsPagination } from "./components/SessionsList/useSessionsPagination";
-import {
-  checkReadyToShowContent,
-  filterVisibleSessions,
-  getCurrentSessionId,
-  mergeCurrentSessionIntoList,
-} from "./helpers";
-
-export function useCopilotShell() {
-  const router = useRouter();
-  const pathname = usePathname();
-  const searchParams = useSearchParams();
-  const queryClient = useQueryClient();
-  const breakpoint = useBreakpoint();
-  const { isLoggedIn } = useSupabase();
-  const isMobile =
-    breakpoint === "base" || breakpoint === "sm" || breakpoint === "md";
-
-  const isOnHomepage = pathname === "/copilot";
-  const paramSessionId = searchParams.get("sessionId");
-
-  const {
-    isDrawerOpen,
-    handleOpenDrawer,
-    handleCloseDrawer,
-    handleDrawerOpenChange,
-  } = useMobileDrawer();
-
-  const paginationEnabled = !isMobile || isDrawerOpen || !!paramSessionId;
-
-  const {
-    sessions: accumulatedSessions,
-    isLoading: isSessionsLoading,
-    isFetching: isSessionsFetching,
-    hasNextPage,
-    areAllSessionsLoaded,
-    fetchNextPage,
-    reset: resetPagination,
-  } = useSessionsPagination({
-    enabled: paginationEnabled,
-  });
-
-  const currentSessionId = getCurrentSessionId(searchParams);
-
-  const { data: currentSessionData, isLoading: isCurrentSessionLoading } =
-    useGetV2GetSession(currentSessionId || "", {
-      query: {
-        enabled: !!currentSessionId,
-        select: okData,
-      },
-    });
-
-  const [hasAutoSelectedSession, setHasAutoSelectedSession] = useState(false);
-  const hasAutoSelectedRef = useRef(false);
-
-  // Mark as auto-selected when sessionId is in URL
-  useEffect(() => {
-    if (paramSessionId && !hasAutoSelectedRef.current) {
-      hasAutoSelectedRef.current = true;
-      setHasAutoSelectedSession(true);
-    }
-  }, [paramSessionId]);
-
-  // On homepage without sessionId, mark as ready immediately
-  useEffect(() => {
-    if (isOnHomepage && !paramSessionId && !hasAutoSelectedRef.current) {
-      hasAutoSelectedRef.current = true;
-      setHasAutoSelectedSession(true);
-    }
-  }, [isOnHomepage, paramSessionId]);
-
-  // Invalidate sessions list when navigating to homepage (to show newly created sessions)
-  useEffect(() => {
-    if (isOnHomepage && !paramSessionId) {
-      queryClient.invalidateQueries({
-        queryKey: getGetV2ListSessionsQueryKey(),
-      });
-    }
-  }, [isOnHomepage, paramSessionId, queryClient]);
-
-  // Reset pagination when query becomes disabled
-  const prevPaginationEnabledRef = useRef(paginationEnabled);
-  useEffect(() => {
-    if (prevPaginationEnabledRef.current && !paginationEnabled) {
-      resetPagination();
-      resetAutoSelect();
-    }
-    prevPaginationEnabledRef.current = paginationEnabled;
-  }, [paginationEnabled, resetPagination]);
-
-  const sessions = mergeCurrentSessionIntoList(
-    accumulatedSessions,
-    currentSessionId,
-    currentSessionData,
-  );
-
-  const visibleSessions = filterVisibleSessions(sessions);
-
-  const sidebarSelectedSessionId =
-    isOnHomepage && !paramSessionId ? null : currentSessionId;
-
-  const isReadyToShowContent = isOnHomepage
-    ? true
-    : checkReadyToShowContent(
-        areAllSessionsLoaded,
-        paramSessionId,
-        accumulatedSessions,
-        isCurrentSessionLoading,
-        currentSessionData,
-        hasAutoSelectedSession,
-      );
-
-  function handleSelectSession(sessionId: string) {
-    // Navigate using replaceState to avoid full page reload
-    window.history.replaceState(null, "", `/copilot?sessionId=${sessionId}`);
-    // Force a re-render by updating the URL through router
-    router.replace(`/copilot?sessionId=${sessionId}`);
-    if (isMobile) handleCloseDrawer();
-  }
-
-  function handleNewChat() {
-    resetAutoSelect();
-    resetPagination();
-    // Invalidate and refetch sessions list to ensure newly created sessions appear
-    queryClient.invalidateQueries({
-      queryKey: getGetV2ListSessionsQueryKey(),
-    });
-    window.history.replaceState(null, "", "/copilot");
-    router.replace("/copilot");
-    if (isMobile) handleCloseDrawer();
-  }
-
-  function resetAutoSelect() {
-    hasAutoSelectedRef.current = false;
-    setHasAutoSelectedSession(false);
-  }
-
-  return {
-    isMobile,
-    isDrawerOpen,
-    isLoggedIn,
-    hasActiveSession:
-      Boolean(currentSessionId) && (!isOnHomepage || Boolean(paramSessionId)),
-    isLoading: isSessionsLoading || !areAllSessionsLoaded,
-    sessions: visibleSessions,
-    currentSessionId: sidebarSelectedSessionId,
-    handleSelectSession,
-    handleOpenDrawer,
-    handleCloseDrawer,
-    handleDrawerOpenChange,
-    handleNewChat,
-    hasNextPage,
-    isFetchingNextPage: isSessionsFetching,
-    fetchNextPage,
-    isReadyToShowContent,
-  };
-}

autogpt_platform/frontend/src/app/(platform)/copilot/helpers.ts

@@ -1,33 +0,0 @@
-import type { User } from "@supabase/supabase-js";
-
-export function getGreetingName(user?: User | null): string {
-  if (!user) return "there";
-  const metadata = user.user_metadata as Record<string, unknown> | undefined;
-  const fullName = metadata?.full_name;
-  const name = metadata?.name;
-  if (typeof fullName === "string" && fullName.trim()) {
-    return fullName.split(" ")[0];
-  }
-  if (typeof name === "string" && name.trim()) {
-    return name.split(" ")[0];
-  }
-  if (user.email) {
-    return user.email.split("@")[0];
-  }
-  return "there";
-}
-
-export function buildCopilotChatUrl(prompt: string): string {
-  const trimmed = prompt.trim();
-  if (!trimmed) return "/copilot/chat";
-  const encoded = encodeURIComponent(trimmed);
-  return `/copilot/chat?prompt=${encoded}`;
-}
-
-export function getQuickActions(): string[] {
-  return [
-    "Show me what I can automate",
-    "Design a custom workflow",
-    "Help me with content creation",
-  ];
-}

autogpt_platform/frontend/src/app/(platform)/copilot/layout.tsx

@@ -1,6 +0,0 @@
-import type { ReactNode } from "react";
-import { CopilotShell } from "./components/CopilotShell/CopilotShell";
-
-export default function CopilotLayout({ children }: { children: ReactNode }) {
-  return <CopilotShell>{children}</CopilotShell>;
-}

autogpt_platform/frontend/src/app/(platform)/copilot/page.tsx

@@ -1,228 +0,0 @@
-"use client";
-
-import { postV2CreateSession } from "@/app/api/__generated__/endpoints/chat/chat";
-import { Skeleton } from "@/components/__legacy__/ui/skeleton";
-import { Button } from "@/components/atoms/Button/Button";
-import { LoadingSpinner } from "@/components/atoms/LoadingSpinner/LoadingSpinner";
-import { Text } from "@/components/atoms/Text/Text";
-import { Chat } from "@/components/contextual/Chat/Chat";
-import { ChatInput } from "@/components/contextual/Chat/components/ChatInput/ChatInput";
-import { getHomepageRoute } from "@/lib/constants";
-import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
-import {
-  Flag,
-  type FlagValues,
-  useGetFlag,
-} from "@/services/feature-flags/use-get-flag";
-import { useFlags } from "launchdarkly-react-client-sdk";
-import { useRouter, useSearchParams } from "next/navigation";
-import { useEffect, useMemo, useRef, useState } from "react";
-import { getGreetingName, getQuickActions } from "./helpers";
-
-type PageState =
-  | { type: "welcome" }
-  | { type: "creating"; prompt: string }
-  | { type: "chat"; sessionId: string; initialPrompt?: string };
-
-export default function CopilotPage() {
-  const router = useRouter();
-  const searchParams = useSearchParams();
-  const { user, isLoggedIn, isUserLoading } = useSupabase();
-
-  const isChatEnabled = useGetFlag(Flag.CHAT);
-  const flags = useFlags<FlagValues>();
-  const homepageRoute = getHomepageRoute(isChatEnabled);
-  const envEnabled = process.env.NEXT_PUBLIC_LAUNCHDARKLY_ENABLED === "true";
-  const clientId = process.env.NEXT_PUBLIC_LAUNCHDARKLY_CLIENT_ID;
-  const isLaunchDarklyConfigured = envEnabled && Boolean(clientId);
-  const isFlagReady =
-    !isLaunchDarklyConfigured || flags[Flag.CHAT] !== undefined;
-
-  const [pageState, setPageState] = useState<PageState>({ type: "welcome" });
-  const initialPromptRef = useRef<Map<string, string>>(new Map());
-
-  const urlSessionId = searchParams.get("sessionId");
-
-  // Sync with URL sessionId (preserve initialPrompt from ref)
-  useEffect(
-    function syncSessionFromUrl() {
-      if (urlSessionId) {
-        // If we're already in chat state with this sessionId, don't overwrite
-        if (pageState.type === "chat" && pageState.sessionId === urlSessionId) {
-          return;
-        }
-        // Get initialPrompt from ref or current state
-        const storedInitialPrompt = initialPromptRef.current.get(urlSessionId);
-        const currentInitialPrompt =
-          storedInitialPrompt ||
-          (pageState.type === "creating"
-            ? pageState.prompt
-            : pageState.type === "chat"
-              ? pageState.initialPrompt
-              : undefined);
-        if (currentInitialPrompt) {
-          initialPromptRef.current.set(urlSessionId, currentInitialPrompt);
-        }
-        setPageState({
-          type: "chat",
-          sessionId: urlSessionId,
-          initialPrompt: currentInitialPrompt,
-        });
-      } else if (pageState.type === "chat") {
-        setPageState({ type: "welcome" });
-      }
-    },
-    [urlSessionId],
-  );
-
-  useEffect(
-    function ensureAccess() {
-      if (!isFlagReady) return;
-      if (isChatEnabled === false) {
-        router.replace(homepageRoute);
-      }
-    },
-    [homepageRoute, isChatEnabled, isFlagReady, router],
-  );
-
-  const greetingName = useMemo(
-    function getName() {
-      return getGreetingName(user);
-    },
-    [user],
-  );
-
-  const quickActions = useMemo(function getActions() {
-    return getQuickActions();
-  }, []);
-
-  async function startChatWithPrompt(prompt: string) {
-    if (!prompt?.trim()) return;
-    if (pageState.type === "creating") return;
-
-    const trimmedPrompt = prompt.trim();
-    setPageState({ type: "creating", prompt: trimmedPrompt });
-
-    try {
-      // Create session
-      const sessionResponse = await postV2CreateSession({
-        body: JSON.stringify({}),
-      });
-
-      if (sessionResponse.status !== 200 || !sessionResponse.data?.id) {
-        throw new Error("Failed to create session");
-      }
-
-      const sessionId = sessionResponse.data.id;
-
-      // Store initialPrompt in ref so it persists across re-renders
-      initialPromptRef.current.set(sessionId, trimmedPrompt);
-
-      // Update URL and show Chat with initial prompt
-      // Chat will handle sending the message and streaming
-      window.history.replaceState(null, "", `/copilot?sessionId=${sessionId}`);
-      setPageState({ type: "chat", sessionId, initialPrompt: trimmedPrompt });
-    } catch (error) {
-      console.error("[CopilotPage] Failed to start chat:", error);
-      setPageState({ type: "welcome" });
-    }
-  }
-
-  function handleQuickAction(action: string) {
-    startChatWithPrompt(action);
-  }
-
-  function handleSessionNotFound() {
-    router.replace("/copilot");
-  }
-
-  if (!isFlagReady || isChatEnabled === false || !isLoggedIn) {
-    return null;
-  }
-
-  // Show Chat when we have an active session
-  if (pageState.type === "chat") {
-    return (
-      <div className="flex h-full flex-col">
-        <Chat
-          key={pageState.sessionId ?? "welcome"}
-          className="flex-1"
-          urlSessionId={pageState.sessionId}
-          initialPrompt={pageState.initialPrompt}
-          onSessionNotFound={handleSessionNotFound}
-        />
-      </div>
-    );
-  }
-
-  // Show loading state while creating session and sending first message
-  if (pageState.type === "creating") {
-    return (
-      <div className="flex h-full flex-1 flex-col items-center justify-center bg-[#f8f8f9] px-6 py-10">
-        <LoadingSpinner size="large" />
-        <Text variant="body" className="mt-4 text-zinc-500">
-          Starting your chat...
-        </Text>
-      </div>
-    );
-  }
-
-  // Show Welcome screen
-  const isLoading = isUserLoading;
-
-  return (
-    <div className="flex h-full flex-1 items-center justify-center overflow-y-auto bg-[#f8f8f9] px-6 py-10">
-      <div className="w-full text-center">
-        {isLoading ? (
-          <div className="mx-auto max-w-2xl">
-            <Skeleton className="mx-auto mb-3 h-8 w-64" />
-            <Skeleton className="mx-auto mb-8 h-6 w-80" />
-            <div className="mb-8">
-              <Skeleton className="mx-auto h-14 w-full rounded-lg" />
-            </div>
-            <div className="flex flex-wrap items-center justify-center gap-3">
-              {Array.from({ length: 4 }).map((_, i) => (
-                <Skeleton key={i} className="h-9 w-48 rounded-md" />
-              ))}
-            </div>
-          </div>
-        ) : (
-          <>
-            <div className="mx-auto max-w-2xl">
-              <Text
-                variant="h3"
-                className="mb-3 !text-[1.375rem] text-zinc-700"
-              >
-                Hey, <span className="text-violet-600">{greetingName}</span>
-              </Text>
-              <Text variant="h3" className="mb-8 !font-normal">
-                What do you want to automate?
-              </Text>
-
-              <div className="mb-6">
-                <ChatInput
-                  onSend={startChatWithPrompt}
-                  placeholder='You can search or just ask - e.g. "create a blog post outline"'
-                />
-              </div>
-            </div>
-            <div className="flex flex-nowrap items-center justify-center gap-3 overflow-x-auto [-ms-overflow-style:none] [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
-              {quickActions.map((action) => (
-                <Button
-                  key={action}
-                  type="button"
-                  variant="outline"
-                  size="small"
-                  onClick={() => handleQuickAction(action)}
-                  className="h-auto shrink-0 border-zinc-600 !px-4 !py-2 text-[1rem] text-zinc-600"
-                >
-                  {action}
-                </Button>
-              ))}
-            </div>
-          </>
-        )}
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/app/(platform)/error/page.tsx

@@ -1,8 +1,6 @@
 "use client";
 
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
-import { getHomepageRoute } from "@/lib/constants";
-import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
 import { useSearchParams } from "next/navigation";
 import { Suspense } from "react";
 import { getErrorDetails } from "./helpers";
@@ -11,8 +9,6 @@ function ErrorPageContent() {
   const searchParams = useSearchParams();
   const errorMessage = searchParams.get("message");
   const errorDetails = getErrorDetails(errorMessage);
-  const isChatEnabled = useGetFlag(Flag.CHAT);
-  const homepageRoute = getHomepageRoute(isChatEnabled);
 
   function handleRetry() {
     // Auth-related errors should redirect to login
@@ -29,8 +25,8 @@ function ErrorPageContent() {
         window.location.reload();
       }, 2000);
     } else {
-      // For server/network errors, go to home
+      // For server/network errors, go to marketplace
-      window.location.href = homepageRoute;
+      window.location.href = "/marketplace";
     }
   }
 

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentModal/RunAgentModal.tsx

@@ -14,6 +14,10 @@ import {
 import { Dialog } from "@/components/molecules/Dialog/Dialog";
 import { useEffect, useRef, useState } from "react";
 import { ScheduleAgentModal } from "../ScheduleAgentModal/ScheduleAgentModal";
+import {
+  AIAgentSafetyPopup,
+  useAIAgentSafetyPopup,
+} from "./components/AIAgentSafetyPopup/AIAgentSafetyPopup";
 import { ModalHeader } from "./components/ModalHeader/ModalHeader";
 import { ModalRunSection } from "./components/ModalRunSection/ModalRunSection";
 import { RunActions } from "./components/RunActions/RunActions";
@@ -83,8 +87,17 @@ export function RunAgentModal({
 
   const [isScheduleModalOpen, setIsScheduleModalOpen] = useState(false);
   const [hasOverflow, setHasOverflow] = useState(false);
+  const [isSafetyPopupOpen, setIsSafetyPopupOpen] = useState(false);
+  const [pendingRunAction, setPendingRunAction] = useState<(() => void) | null>(
+    null,
+  );
   const contentRef = useRef<HTMLDivElement>(null);
 
+  const { shouldShowPopup, dismissPopup } = useAIAgentSafetyPopup(
+    agent.has_sensitive_action,
+    agent.has_human_in_the_loop,
+  );
+
   const hasAnySetupFields =
     Object.keys(agentInputFields || {}).length > 0 ||
     Object.keys(agentCredentialsInputFields || {}).length > 0;
@@ -165,6 +178,24 @@ export function RunAgentModal({
     onScheduleCreated?.(schedule);
   }
 
+  function handleRunWithSafetyCheck() {
+    if (shouldShowPopup) {
+      setPendingRunAction(() => handleRun);
+      setIsSafetyPopupOpen(true);
+    } else {
+      handleRun();
+    }
+  }
+
+  function handleSafetyPopupAcknowledge() {
+    setIsSafetyPopupOpen(false);
+    dismissPopup();
+    if (pendingRunAction) {
+      pendingRunAction();
+      setPendingRunAction(null);
+    }
+  }
+
   return (
     <>
       <Dialog
@@ -180,7 +211,7 @@ export function RunAgentModal({
 
               {/* Content */}
               {hasAnySetupFields ? (
-                <div className="mt-4 pb-10">
+                <div className="mt-10 pb-32">
                   <RunAgentModalContextProvider
                     value={{
                       agent,
@@ -248,7 +279,7 @@ export function RunAgentModal({
                 )}
                 <RunActions
                   defaultRunType={defaultRunType}
-                  onRun={handleRun}
+                  onRun={handleRunWithSafetyCheck}
                   isExecuting={isExecuting}
                   isSettingUpTrigger={isSettingUpTrigger}
                   isRunReady={allRequiredInputsAreSet}
@@ -266,6 +297,11 @@ export function RunAgentModal({
           </div>
         </Dialog.Content>
       </Dialog>
+
+      <AIAgentSafetyPopup
+        isOpen={isSafetyPopupOpen}
+        onAcknowledge={handleSafetyPopupAcknowledge}
+      />
     </>
   );
 }

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentModal/components/AIAgentSafetyPopup/AIAgentSafetyPopup.tsx

@@ -0,0 +1,95 @@
+"use client";
+
+import { Button } from "@/components/atoms/Button/Button";
+import { Text } from "@/components/atoms/Text/Text";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Key, storage } from "@/services/storage/local-storage";
+import { ShieldCheckIcon } from "@phosphor-icons/react";
+import { useCallback, useEffect, useState } from "react";
+
+interface Props {
+  onAcknowledge: () => void;
+  isOpen: boolean;
+}
+
+export function AIAgentSafetyPopup({ onAcknowledge, isOpen }: Props) {
+  function handleAcknowledge() {
+    // Mark popup as shown so it won't appear again
+    storage.set(Key.AI_AGENT_SAFETY_POPUP_SHOWN, "true");
+    onAcknowledge();
+  }
+
+  if (!isOpen) return null;
+
+  return (
+    <Dialog
+      controlled={{ isOpen, set: () => {} }}
+      styling={{ maxWidth: "480px" }}
+    >
+      <Dialog.Content>
+        <div className="flex flex-col items-center p-6 text-center">
+          <div className="mb-6 flex h-16 w-16 items-center justify-center rounded-full bg-blue-50">
+            <ShieldCheckIcon
+              weight="fill"
+              size={32}
+              className="text-blue-600"
+            />
+          </div>
+
+          <Text variant="h3" className="mb-4">
+            Safety Checks Enabled
+          </Text>
+
+          <Text variant="body" className="mb-2 text-zinc-700">
+            AI-generated agents may take actions that affect your data or
+            external systems.
+          </Text>
+
+          <Text variant="body" className="mb-8 text-zinc-700">
+            AutoGPT includes safety checks so you&apos;ll always have the
+            opportunity to review and approve sensitive actions before they
+            happen.
+          </Text>
+
+          <Button
+            variant="primary"
+            size="large"
+            className="w-full"
+            onClick={handleAcknowledge}
+          >
+            Got it
+          </Button>
+        </div>
+      </Dialog.Content>
+    </Dialog>
+  );
+}
+
+export function useAIAgentSafetyPopup(
+  hasSensitiveAction: boolean,
+  hasHumanInTheLoop: boolean,
+) {
+  const [shouldShowPopup, setShouldShowPopup] = useState(false);
+  const [hasChecked, setHasChecked] = useState(false);
+
+  useEffect(() => {
+    // Only check once after mount (to avoid SSR issues)
+    if (hasChecked) return;
+
+    const hasSeenPopup =
+      storage.get(Key.AI_AGENT_SAFETY_POPUP_SHOWN) === "true";
+    const isRelevantAgent = hasSensitiveAction || hasHumanInTheLoop;
+
+    setShouldShowPopup(!hasSeenPopup && isRelevantAgent);
+    setHasChecked(true);
+  }, [hasSensitiveAction, hasHumanInTheLoop, hasChecked]);
+
+  const dismissPopup = useCallback(() => {
+    setShouldShowPopup(false);
+  }, []);
+
+  return {
+    shouldShowPopup,
+    dismissPopup,
+  };
+}

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/modals/RunAgentModal/components/ModalHeader/ModalHeader.tsx

@@ -29,7 +29,7 @@ export function ModalHeader({ agent }: ModalHeaderProps) {
           <ShowMoreText
             previewLimit={400}
             variant="small"
-            className="mb-2 mt-4 !text-zinc-700"
+            className="mt-4 !text-zinc-700"
           >
             {agent.description}
           </ShowMoreText>
@@ -40,8 +40,6 @@ export function ModalHeader({ agent }: ModalHeaderProps) {
             <Text variant="lead-semibold" className="text-blue-600">
               Tip
             </Text>
-            <div className="h-px w-full bg-blue-100" />
-
             <Text variant="body">
               For best results, run this agent{" "}
               {humanizeCronExpression(
@@ -52,7 +50,7 @@ export function ModalHeader({ agent }: ModalHeaderProps) {
         ) : null}
 
         {agent.instructions ? (
-          <div className="mt-4 flex flex-col gap-4 rounded-medium border border-purple-100 bg-[#f1ebfe80] p-4">
+          <div className="flex flex-col gap-4 rounded-medium border border-purple-100 bg-[#F1EBFE/5] p-4">
             <Text variant="lead-semibold" className="text-purple-600">
               Instructions
             </Text>

autogpt_platform/frontend/src/app/(platform)/library/agents/[id]/components/NewAgentLibraryView/components/selected-views/SelectedRunView/components/SafeModeToggle.tsx

@@ -69,7 +69,6 @@ export function SafeModeToggle({ graph, className }: Props) {
   const {
     currentHITLSafeMode,
     showHITLToggle,
-    isHITLStateUndetermined,
     handleHITLToggle,
     currentSensitiveActionSafeMode,
     showSensitiveActionToggle,
@@ -78,20 +77,13 @@ export function SafeModeToggle({ graph, className }: Props) {
     shouldShowToggle,
   } = useAgentSafeMode(graph);
 
-  if (!shouldShowToggle || isHITLStateUndetermined) {
+  if (!shouldShowToggle) {
-    return null;
-  }
-
-  const showHITL = showHITLToggle && !isHITLStateUndetermined;
-  const showSensitive = showSensitiveActionToggle;
-
-  if (!showHITL && !showSensitive) {
     return null;
   }
 
   return (
     <div className={cn("flex gap-1", className)}>
-      {showHITL && (
+      {showHITLToggle && (
         <SafeModeIconButton
           isEnabled={currentHITLSafeMode}
           label="Human-in-the-loop"
@@ -101,7 +93,7 @@ export function SafeModeToggle({ graph, className }: Props) {
           isPending={isPending}
         />
       )}
-      {showSensitive && (
+      {showSensitiveActionToggle && (
         <SafeModeIconButton
           isEnabled={currentSensitiveActionSafeMode}
           label="Sensitive actions"

autogpt_platform/frontend/src/app/(platform)/library/components/LibraryAgentCard/useLibraryAgentCard.ts

@@ -8,8 +8,6 @@ import { useGetV2GetUserProfile } from "@/app/api/__generated__/endpoints/store/
 import { LibraryAgent } from "@/app/api/__generated__/models/libraryAgent";
 import { okData } from "@/app/api/helpers";
 import { useToast } from "@/components/molecules/Toast/use-toast";
-import { isLogoutInProgress } from "@/lib/autogpt-server-api/helpers";
-import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
 import { updateFavoriteInQueries } from "./helpers";
 
 interface Props {
@@ -25,14 +23,10 @@ export function useLibraryAgentCard({ agent }: Props) {
   const { toast } = useToast();
   const queryClient = getQueryClient();
   const { mutateAsync: updateLibraryAgent } = usePatchV2UpdateLibraryAgent();
-  const { user, isLoggedIn } = useSupabase();
-  const logoutInProgress = isLogoutInProgress();
 
   const { data: profile } = useGetV2GetUserProfile({
     query: {
       select: okData,
-      enabled: isLoggedIn && !!user && !logoutInProgress,
-      queryKey: ["/api/store/profile", user?.id],
     },
   });
 

autogpt_platform/frontend/src/app/(platform)/login/useLoginPage.ts

@@ -1,8 +1,6 @@
 import { useToast } from "@/components/molecules/Toast/use-toast";
-import { getHomepageRoute } from "@/lib/constants";
 import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
 import { environment } from "@/services/environment";
-import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
 import { loginFormSchema, LoginProvider } from "@/types/auth";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { useRouter, useSearchParams } from "next/navigation";
@@ -22,17 +20,15 @@ export function useLoginPage() {
   const [isGoogleLoading, setIsGoogleLoading] = useState(false);
   const [showNotAllowedModal, setShowNotAllowedModal] = useState(false);
   const isCloudEnv = environment.isCloud();
-  const isChatEnabled = useGetFlag(Flag.CHAT);
-  const homepageRoute = getHomepageRoute(isChatEnabled);
 
   // Get redirect destination from 'next' query parameter
   const nextUrl = searchParams.get("next");
 
   useEffect(() => {
     if (isLoggedIn && !isLoggingIn) {
-      router.push(nextUrl || homepageRoute);
+      router.push(nextUrl || "/marketplace");
     }
-  }, [homepageRoute, isLoggedIn, isLoggingIn, nextUrl, router]);
+  }, [isLoggedIn, isLoggingIn, nextUrl, router]);
 
   const form = useForm<z.infer<typeof loginFormSchema>>({
     resolver: zodResolver(loginFormSchema),
@@ -102,7 +98,7 @@ export function useLoginPage() {
       } else if (result.onboarding) {
         router.replace("/onboarding");
       } else {
-        router.replace(homepageRoute);
+        router.replace("/marketplace");
       }
     } catch (error) {
       toast({

autogpt_platform/frontend/src/app/(platform)/profile/(user)/page.tsx

@@ -3,14 +3,12 @@
 import { useGetV2GetUserProfile } from "@/app/api/__generated__/endpoints/store/store";
 import { ProfileInfoForm } from "@/components/__legacy__/ProfileInfoForm";
 import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
-import { isLogoutInProgress } from "@/lib/autogpt-server-api/helpers";
 import { ProfileDetails } from "@/lib/autogpt-server-api/types";
 import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
 import { ProfileLoading } from "./ProfileLoading";
 
 export default function UserProfilePage() {
   const { user } = useSupabase();
-  const logoutInProgress = isLogoutInProgress();
 
   const {
     data: profile,
@@ -20,7 +18,7 @@ export default function UserProfilePage() {
     refetch,
   } = useGetV2GetUserProfile<ProfileDetails | null>({
     query: {
-      enabled: !!user && !logoutInProgress,
+      enabled: !!user,
       select: (res) => {
         if (res.status === 200) {
           return {

autogpt_platform/frontend/src/app/(platform)/signup/actions.ts

@@ -1,6 +1,5 @@
 "use server";
 
-import { getHomepageRoute } from "@/lib/constants";
 import { getServerSupabase } from "@/lib/supabase/server/getServerSupabase";
 import { signupFormSchema } from "@/types/auth";
 import * as Sentry from "@sentry/nextjs";
@@ -12,7 +11,6 @@ export async function signup(
   password: string,
   confirmPassword: string,
   agreeToTerms: boolean,
-  isChatEnabled: boolean,
 ) {
   try {
     const parsed = signupFormSchema.safeParse({
@@ -60,9 +58,7 @@ export async function signup(
     }
 
     const isOnboardingEnabled = await shouldShowOnboarding();
-    const next = isOnboardingEnabled
+    const next = isOnboardingEnabled ? "/onboarding" : "/";
-      ? "/onboarding"
-      : getHomepageRoute(isChatEnabled);
 
     return { success: true, next };
   } catch (err) {

autogpt_platform/frontend/src/app/(platform)/signup/useSignupPage.ts

@@ -1,8 +1,6 @@
 import { useToast } from "@/components/molecules/Toast/use-toast";
-import { getHomepageRoute } from "@/lib/constants";
 import { useSupabase } from "@/lib/supabase/hooks/useSupabase";
 import { environment } from "@/services/environment";
-import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
 import { LoginProvider, signupFormSchema } from "@/types/auth";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { useRouter, useSearchParams } from "next/navigation";
@@ -22,17 +20,15 @@ export function useSignupPage() {
   const [isGoogleLoading, setIsGoogleLoading] = useState(false);
   const [showNotAllowedModal, setShowNotAllowedModal] = useState(false);
   const isCloudEnv = environment.isCloud();
-  const isChatEnabled = useGetFlag(Flag.CHAT);
-  const homepageRoute = getHomepageRoute(isChatEnabled);
 
   // Get redirect destination from 'next' query parameter
   const nextUrl = searchParams.get("next");
 
   useEffect(() => {
     if (isLoggedIn && !isSigningUp) {
-      router.push(nextUrl || homepageRoute);
+      router.push(nextUrl || "/marketplace");
     }
-  }, [homepageRoute, isLoggedIn, isSigningUp, nextUrl, router]);
+  }, [isLoggedIn, isSigningUp, nextUrl, router]);
 
   const form = useForm<z.infer<typeof signupFormSchema>>({
     resolver: zodResolver(signupFormSchema),
@@ -108,7 +104,6 @@ export function useSignupPage() {
         data.password,
         data.confirmPassword,
         data.agreeToTerms,
-        isChatEnabled === true,
       );
 
       setIsLoading(false);
@@ -134,7 +129,7 @@ export function useSignupPage() {
       }
 
       // Prefer the URL's next parameter, then result.next (for onboarding), then default
-      const redirectTo = nextUrl || result.next || homepageRoute;
+      const redirectTo = nextUrl || result.next || "/";
       router.replace(redirectTo);
     } catch (error) {
       setIsLoading(false);

autogpt_platform/frontend/src/app/api/mutators/custom-mutator.ts

@@ -4,12 +4,12 @@ import {
   getServerAuthToken,
 } from "@/lib/autogpt-server-api/helpers";
 
+import { transformDates } from "./date-transformer";
+import { environment } from "@/services/environment";
 import {
   IMPERSONATION_HEADER_NAME,
   IMPERSONATION_STORAGE_KEY,
 } from "@/lib/constants";
-import { environment } from "@/services/environment";
-import { transformDates } from "./date-transformer";
 
 const FRONTEND_BASE_URL =
   process.env.NEXT_PUBLIC_FRONTEND_BASE_URL || "http://localhost:3000";

autogpt_platform/frontend/src/app/api/openapi.json

@@ -1022,7 +1022,7 @@
       "get": {
         "tags": ["v2", "chat", "chat"],
         "summary": "Get Session",
-        "description": "Retrieve the details of a specific chat session.\n\nLooks up a chat session by ID for the given user (if authenticated) and returns all session data including messages.\n\nArgs:\n    session_id: The unique identifier for the desired chat session.\n    user_id: The optional authenticated user ID, or None for anonymous access.\n\nReturns:\n    SessionDetailResponse: Details for the requested session, or None if not found.",
+        "description": "Retrieve the details of a specific chat session.\n\nLooks up a chat session by ID for the given user (if authenticated) and returns all session data including messages.\n\nArgs:\n    session_id: The unique identifier for the desired chat session.\n    user_id: The optional authenticated user ID, or None for anonymous access.\n\nReturns:\n    SessionDetailResponse: Details for the requested session; raises NotFoundError if not found.",
         "operationId": "getV2GetSession",
         "security": [{ "HTTPBearerJWT": [] }],
         "parameters": [
@@ -9425,6 +9425,12 @@
             "type": "array",
             "title": "Reviews",
             "description": "All reviews with their approval status, data, and messages"
+          },
+          "auto_approve_future_actions": {
+            "type": "boolean",
+            "title": "Auto Approve Future Actions",
+            "description": "If true, future reviews from the same blocks (nodes) being approved will be automatically approved for the remainder of this execution. This only affects the current execution run.",
+            "default": false
           }
         },
         "type": "object",

autogpt_platform/frontend/src/app/globals.css

@@ -141,6 +141,52 @@
   }
 }
 
+@keyframes shimmer {
+  0% {
+    background-position: -200% 0;
+  }
+  100% {
+    background-position: 200% 0;
+  }
+}
+
+@keyframes l3 {
+  25% {
+    background-position:
+      0 0,
+      100% 100%,
+      100% calc(100% - 5px);
+  }
+  50% {
+    background-position:
+      0 100%,
+      100% 100%,
+      0 calc(100% - 5px);
+  }
+  75% {
+    background-position:
+      0 100%,
+      100% 0,
+      100% 5px;
+  }
+}
+
+.loader {
+  width: 80px;
+  height: 70px;
+  border: 5px solid rgb(241 245 249);
+  padding: 0 8px;
+  box-sizing: border-box;
+  background:
+    linear-gradient(rgb(15 23 42) 0 0) 0 0/8px 20px,
+    linear-gradient(rgb(15 23 42) 0 0) 100% 0/8px 20px,
+    radial-gradient(farthest-side, rgb(15 23 42) 90%, #0000) 0 5px/8px 8px
+      content-box,
+    transparent;
+  background-repeat: no-repeat;
+  animation: l3 2s infinite linear;
+}
+
 input[type="number"]::-webkit-outer-spin-button,
 input[type="number"]::-webkit-inner-spin-button {
   -webkit-appearance: none;

autogpt_platform/frontend/src/app/page.tsx

@@ -1,27 +1,5 @@
-"use client";
+import { redirect } from "next/navigation";
-
-import { getHomepageRoute } from "@/lib/constants";
-import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
-import { useRouter } from "next/navigation";
-import { useEffect } from "react";
 
 export default function Page() {
-  const isChatEnabled = useGetFlag(Flag.CHAT);
+  redirect("/marketplace");
-  const router = useRouter();
-  const homepageRoute = getHomepageRoute(isChatEnabled);
-  const envEnabled = process.env.NEXT_PUBLIC_LAUNCHDARKLY_ENABLED === "true";
-  const clientId = process.env.NEXT_PUBLIC_LAUNCHDARKLY_CLIENT_ID;
-  const isLaunchDarklyConfigured = envEnabled && Boolean(clientId);
-  const isFlagReady =
-    !isLaunchDarklyConfigured || typeof isChatEnabled === "boolean";
-
-  useEffect(
-    function redirectToHomepage() {
-      if (!isFlagReady) return;
-      router.replace(homepageRoute);
-    },
-    [homepageRoute, isFlagReady, router],
-  );
-
-  return null;
 }

autogpt_platform/frontend/src/components/contextual/Chat/Chat.tsx

@@ -1,81 +0,0 @@
-"use client";
-
-import { Text } from "@/components/atoms/Text/Text";
-import { cn } from "@/lib/utils";
-import { useEffect, useRef } from "react";
-import { ChatContainer } from "./components/ChatContainer/ChatContainer";
-import { ChatErrorState } from "./components/ChatErrorState/ChatErrorState";
-import { ChatLoader } from "./components/ChatLoader/ChatLoader";
-import { useChat } from "./useChat";
-
-export interface ChatProps {
-  className?: string;
-  urlSessionId?: string | null;
-  initialPrompt?: string;
-  onSessionNotFound?: () => void;
-}
-
-export function Chat({
-  className,
-  urlSessionId,
-  initialPrompt,
-  onSessionNotFound,
-}: ChatProps) {
-  const hasHandledNotFoundRef = useRef(false);
-  const {
-    messages,
-    isLoading,
-    isCreating,
-    error,
-    isSessionNotFound,
-    sessionId,
-    createSession,
-    showLoader,
-  } = useChat({ urlSessionId });
-
-  useEffect(
-    function handleMissingSession() {
-      if (!onSessionNotFound) return;
-      if (!urlSessionId) return;
-      if (!isSessionNotFound || isLoading || isCreating) return;
-      if (hasHandledNotFoundRef.current) return;
-      hasHandledNotFoundRef.current = true;
-      onSessionNotFound();
-    },
-    [onSessionNotFound, urlSessionId, isSessionNotFound, isLoading, isCreating],
-  );
-
-  return (
-    <div className={cn("flex h-full flex-col", className)}>
-      {/* Main Content */}
-      <main className="flex min-h-0 w-full flex-1 flex-col overflow-hidden bg-[#f8f8f9]">
-        {/* Loading State */}
-        {showLoader && (isLoading || isCreating) && (
-          <div className="flex flex-1 items-center justify-center">
-            <div className="flex flex-col items-center gap-4">
-              <ChatLoader />
-              <Text variant="body" className="text-zinc-500">
-                Loading your chats...
-              </Text>
-            </div>
-          </div>
-        )}
-
-        {/* Error State */}
-        {error && !isLoading && (
-          <ChatErrorState error={error} onRetry={createSession} />
-        )}
-
-        {/* Session Content */}
-        {sessionId && !isLoading && !error && (
-          <ChatContainer
-            sessionId={sessionId}
-            initialMessages={messages}
-            initialPrompt={initialPrompt}
-            className="flex-1"
-          />
-        )}
-      </main>
-    </div>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/AIChatBubble/AIChatBubble.tsx

@@ -1,15 +0,0 @@
-import { cn } from "@/lib/utils";
-import { ReactNode } from "react";
-
-export interface AIChatBubbleProps {
-  children: ReactNode;
-  className?: string;
-}
-
-export function AIChatBubble({ children, className }: AIChatBubbleProps) {
-  return (
-    <div className={cn("text-left text-[1rem] leading-relaxed", className)}>
-      {children}
-    </div>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/ChatContainer/ChatContainer.tsx

@@ -1,106 +0,0 @@
-import type { SessionDetailResponse } from "@/app/api/__generated__/models/sessionDetailResponse";
-import { Button } from "@/components/atoms/Button/Button";
-import { Text } from "@/components/atoms/Text/Text";
-import { Dialog } from "@/components/molecules/Dialog/Dialog";
-import { useBreakpoint } from "@/lib/hooks/useBreakpoint";
-import { cn } from "@/lib/utils";
-import { ChatInput } from "../ChatInput/ChatInput";
-import { MessageList } from "../MessageList/MessageList";
-import { useChatContainer } from "./useChatContainer";
-
-export interface ChatContainerProps {
-  sessionId: string | null;
-  initialMessages: SessionDetailResponse["messages"];
-  initialPrompt?: string;
-  className?: string;
-}
-
-export function ChatContainer({
-  sessionId,
-  initialMessages,
-  initialPrompt,
-  className,
-}: ChatContainerProps) {
-  const {
-    messages,
-    streamingChunks,
-    isStreaming,
-    stopStreaming,
-    isRegionBlockedModalOpen,
-    sendMessageWithContext,
-    handleRegionModalOpenChange,
-    handleRegionModalClose,
-  } = useChatContainer({
-    sessionId,
-    initialMessages,
-    initialPrompt,
-  });
-
-  const breakpoint = useBreakpoint();
-  const isMobile =
-    breakpoint === "base" || breakpoint === "sm" || breakpoint === "md";
-
-  return (
-    <div
-      className={cn(
-        "mx-auto flex h-full min-h-0 w-full max-w-3xl flex-col bg-[#f8f8f9]",
-        className,
-      )}
-    >
-      <Dialog
-        title="Service unavailable"
-        controlled={{
-          isOpen: isRegionBlockedModalOpen,
-          set: handleRegionModalOpenChange,
-        }}
-        onClose={handleRegionModalClose}
-      >
-        <Dialog.Content>
-          <div className="flex flex-col gap-4">
-            <Text variant="body">
-              This model is not available in your region. Please connect via VPN
-              and try again.
-            </Text>
-            <div className="flex justify-end">
-              <Button
-                type="button"
-                variant="primary"
-                onClick={handleRegionModalClose}
-              >
-                Got it
-              </Button>
-            </div>
-          </div>
-        </Dialog.Content>
-      </Dialog>
-      {/* Messages - Scrollable */}
-      <div className="relative flex min-h-0 flex-1 flex-col">
-        <div className="flex min-h-full flex-col justify-end">
-          <MessageList
-            messages={messages}
-            streamingChunks={streamingChunks}
-            isStreaming={isStreaming}
-            onSendMessage={sendMessageWithContext}
-            className="flex-1"
-          />
-        </div>
-      </div>
-
-      {/* Input - Fixed at bottom */}
-      <div className="relative px-3 pb-6 pt-2">
-        <div className="pointer-events-none absolute top-[-18px] z-10 h-6 w-full bg-gradient-to-b from-transparent to-[#f8f8f9]" />
-        <ChatInput
-          onSend={sendMessageWithContext}
-          disabled={isStreaming || !sessionId}
-          isStreaming={isStreaming}
-          onStop={stopStreaming}
-          placeholder={
-            isMobile
-              ? "You can search or just ask"
-              : 'You can search or just ask — e.g. "create a blog post outline"'
-          }
-        />
-      </div>
-    </div>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/ChatInput/ChatInput.tsx

@@ -1,103 +0,0 @@
-import { Button } from "@/components/atoms/Button/Button";
-import { cn } from "@/lib/utils";
-import { ArrowUpIcon, StopIcon } from "@phosphor-icons/react";
-import { useChatInput } from "./useChatInput";
-
-export interface Props {
-  onSend: (message: string) => void;
-  disabled?: boolean;
-  isStreaming?: boolean;
-  onStop?: () => void;
-  placeholder?: string;
-  className?: string;
-}
-
-export function ChatInput({
-  onSend,
-  disabled = false,
-  isStreaming = false,
-  onStop,
-  placeholder = "Type your message...",
-  className,
-}: Props) {
-  const inputId = "chat-input";
-  const { value, setValue, handleKeyDown, handleSend, hasMultipleLines } =
-    useChatInput({
-      onSend,
-      disabled: disabled || isStreaming,
-      maxRows: 4,
-      inputId,
-    });
-
-  function handleSubmit(e: React.FormEvent<HTMLFormElement>) {
-    e.preventDefault();
-    handleSend();
-  }
-
-  function handleChange(e: React.ChangeEvent<HTMLTextAreaElement>) {
-    setValue(e.target.value);
-  }
-
-  return (
-    <form onSubmit={handleSubmit} className={cn("relative flex-1", className)}>
-      <div className="relative">
-        <div
-          id={`${inputId}-wrapper`}
-          className={cn(
-            "relative overflow-hidden border border-neutral-200 bg-white shadow-sm",
-            "focus-within:border-zinc-400 focus-within:ring-1 focus-within:ring-zinc-400",
-            hasMultipleLines ? "rounded-xlarge" : "rounded-full",
-          )}
-        >
-          <textarea
-            id={inputId}
-            aria-label="Chat message input"
-            value={value}
-            onChange={handleChange}
-            onKeyDown={handleKeyDown}
-            placeholder={placeholder}
-            disabled={disabled || isStreaming}
-            rows={1}
-            className={cn(
-              "w-full resize-none overflow-y-auto border-0 bg-transparent text-[1rem] leading-6 text-black",
-              "placeholder:text-zinc-400",
-              "focus:outline-none focus:ring-0",
-              "disabled:text-zinc-500",
-              hasMultipleLines ? "pb-6 pl-4 pr-4 pt-2" : "pb-4 pl-4 pr-14 pt-4",
-            )}
-          />
-        </div>
-        <span id="chat-input-hint" className="sr-only">
-          Press Enter to send, Shift+Enter for new line
-        </span>
-
-        {isStreaming ? (
-          <Button
-            type="button"
-            variant="icon"
-            size="icon"
-            aria-label="Stop generating"
-            onClick={onStop}
-            className="absolute bottom-[7px] right-2 border-red-600 bg-red-600 text-white hover:border-red-800 hover:bg-red-800"
-          >
-            <StopIcon className="h-4 w-4" weight="bold" />
-          </Button>
-        ) : (
-          <Button
-            type="submit"
-            variant="icon"
-            size="icon"
-            aria-label="Send message"
-            className={cn(
-              "absolute bottom-[7px] right-2 border-zinc-800 bg-zinc-800 text-white hover:border-zinc-900 hover:bg-zinc-900",
-              (disabled || !value.trim()) && "opacity-20",
-            )}
-            disabled={disabled || !value.trim()}
-          >
-            <ArrowUpIcon className="h-4 w-4" weight="bold" />
-          </Button>
-        )}
-      </div>
-    </form>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/ChatInput/useChatInput.ts

@@ -1,115 +0,0 @@
-import { KeyboardEvent, useCallback, useEffect, useState } from "react";
-
-interface UseChatInputArgs {
-  onSend: (message: string) => void;
-  disabled?: boolean;
-  maxRows?: number;
-  inputId?: string;
-}
-
-export function useChatInput({
-  onSend,
-  disabled = false,
-  maxRows = 5,
-  inputId = "chat-input",
-}: UseChatInputArgs) {
-  const [value, setValue] = useState("");
-  const [hasMultipleLines, setHasMultipleLines] = useState(false);
-
-  useEffect(() => {
-    const textarea = document.getElementById(inputId) as HTMLTextAreaElement;
-    const wrapper = document.getElementById(
-      `${inputId}-wrapper`,
-    ) as HTMLDivElement;
-    if (!textarea || !wrapper) return;
-
-    const isEmpty = !value.trim();
-    const lines = value.split("\n").length;
-    const hasExplicitNewlines = lines > 1;
-
-    const computedStyle = window.getComputedStyle(textarea);
-    const lineHeight = parseInt(computedStyle.lineHeight, 10);
-    const paddingTop = parseInt(computedStyle.paddingTop, 10);
-    const paddingBottom = parseInt(computedStyle.paddingBottom, 10);
-
-    const singleLinePadding = paddingTop + paddingBottom;
-
-    textarea.style.height = "auto";
-    const scrollHeight = textarea.scrollHeight;
-
-    const singleLineHeight = lineHeight + singleLinePadding;
-    const isMultiLine =
-      hasExplicitNewlines || scrollHeight > singleLineHeight + 2;
-    setHasMultipleLines(isMultiLine);
-
-    if (isEmpty) {
-      wrapper.style.height = `${singleLineHeight}px`;
-      wrapper.style.maxHeight = "";
-      textarea.style.height = `${singleLineHeight}px`;
-      textarea.style.maxHeight = "";
-      textarea.style.overflowY = "hidden";
-      return;
-    }
-
-    if (isMultiLine) {
-      const wrapperMaxHeight = 196;
-      const currentMultilinePadding = paddingTop + paddingBottom;
-      const contentMaxHeight = wrapperMaxHeight - currentMultilinePadding;
-      const minMultiLineHeight = lineHeight * 2 + currentMultilinePadding;
-      const contentHeight = scrollHeight;
-      const targetWrapperHeight = Math.min(
-        Math.max(contentHeight + currentMultilinePadding, minMultiLineHeight),
-        wrapperMaxHeight,
-      );
-
-      wrapper.style.height = `${targetWrapperHeight}px`;
-      wrapper.style.maxHeight = `${wrapperMaxHeight}px`;
-      textarea.style.height = `${contentHeight}px`;
-      textarea.style.maxHeight = `${contentMaxHeight}px`;
-      textarea.style.overflowY =
-        contentHeight > contentMaxHeight ? "auto" : "hidden";
-    } else {
-      wrapper.style.height = `${singleLineHeight}px`;
-      wrapper.style.maxHeight = "";
-      textarea.style.height = `${singleLineHeight}px`;
-      textarea.style.maxHeight = "";
-      textarea.style.overflowY = "hidden";
-    }
-  }, [value, maxRows, inputId]);
-
-  const handleSend = useCallback(() => {
-    if (disabled || !value.trim()) return;
-    onSend(value.trim());
-    setValue("");
-    setHasMultipleLines(false);
-    const textarea = document.getElementById(inputId) as HTMLTextAreaElement;
-    const wrapper = document.getElementById(
-      `${inputId}-wrapper`,
-    ) as HTMLDivElement;
-    if (textarea) {
-      textarea.style.height = "auto";
-    }
-    if (wrapper) {
-      wrapper.style.height = "";
-      wrapper.style.maxHeight = "";
-    }
-  }, [value, onSend, disabled, inputId]);
-
-  const handleKeyDown = useCallback(
-    (event: KeyboardEvent<HTMLTextAreaElement>) => {
-      if (event.key === "Enter" && !event.shiftKey) {
-        event.preventDefault();
-        handleSend();
-      }
-    },
-    [handleSend],
-  );
-
-  return {
-    value,
-    setValue,
-    handleKeyDown,
-    handleSend,
-    hasMultipleLines,
-  };
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/ChatLoader/ChatLoader.tsx

@@ -1,12 +0,0 @@
-import { Text } from "@/components/atoms/Text/Text";
-
-export function ChatLoader() {
-  return (
-    <Text
-      variant="small"
-      className="bg-gradient-to-r from-neutral-600 via-neutral-500 to-neutral-600 bg-[length:200%_100%] bg-clip-text text-xs text-transparent [animation:shimmer_2s_ease-in-out_infinite]"
-    >
-      Taking a bit more time...
-    </Text>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/MessageList/MessageList.tsx

@@ -1,119 +0,0 @@
-"use client";
-
-import { cn } from "@/lib/utils";
-import type { ChatMessageData } from "../ChatMessage/useChatMessage";
-import { StreamingMessage } from "../StreamingMessage/StreamingMessage";
-import { ThinkingMessage } from "../ThinkingMessage/ThinkingMessage";
-import { LastToolResponse } from "./components/LastToolResponse/LastToolResponse";
-import { MessageItem } from "./components/MessageItem/MessageItem";
-import { findLastMessageIndex, shouldSkipAgentOutput } from "./helpers";
-import { useMessageList } from "./useMessageList";
-
-export interface MessageListProps {
-  messages: ChatMessageData[];
-  streamingChunks?: string[];
-  isStreaming?: boolean;
-  className?: string;
-  onStreamComplete?: () => void;
-  onSendMessage?: (content: string) => void;
-}
-
-export function MessageList({
-  messages,
-  streamingChunks = [],
-  isStreaming = false,
-  className,
-  onStreamComplete,
-  onSendMessage,
-}: MessageListProps) {
-  const { messagesEndRef, messagesContainerRef } = useMessageList({
-    messageCount: messages.length,
-    isStreaming,
-  });
-
-  /**
-   * Keeps this for debugging purposes 💆🏽
-   */
-  console.log(messages);
-
-  return (
-    <div className="relative flex min-h-0 flex-1 flex-col">
-      {/* Top fade shadow */}
-      <div className="pointer-events-none absolute top-0 z-10 h-8 w-full bg-gradient-to-b from-[#f8f8f9] to-transparent" />
-
-      <div
-        ref={messagesContainerRef}
-        className={cn(
-          "flex-1 overflow-y-auto overflow-x-hidden",
-          "scrollbar-thin scrollbar-track-transparent scrollbar-thumb-zinc-300",
-          className,
-        )}
-      >
-        <div className="mx-auto flex min-w-0 flex-col hyphens-auto break-words py-4">
-          {/* Render all persisted messages */}
-          {(() => {
-            const lastAssistantMessageIndex = findLastMessageIndex(
-              messages,
-              (msg) => msg.type === "message" && msg.role === "assistant",
-            );
-
-            const lastToolResponseIndex = findLastMessageIndex(
-              messages,
-              (msg) => msg.type === "tool_response",
-            );
-
-            return messages.map((message, index) => {
-              // Skip agent_output tool_responses that should be rendered inside assistant messages
-              if (shouldSkipAgentOutput(message, messages[index - 1])) {
-                return null;
-              }
-
-              // Render last tool_response as AIChatBubble
-              if (
-                message.type === "tool_response" &&
-                index === lastToolResponseIndex
-              ) {
-                return (
-                  <LastToolResponse
-                    key={index}
-                    message={message}
-                    prevMessage={messages[index - 1]}
-                  />
-                );
-              }
-
-              return (
-                <MessageItem
-                  key={index}
-                  message={message}
-                  messages={messages}
-                  index={index}
-                  lastAssistantMessageIndex={lastAssistantMessageIndex}
-                  isStreaming={isStreaming}
-                  onSendMessage={onSendMessage}
-                />
-              );
-            });
-          })()}
-
-          {/* Render thinking message when streaming but no chunks yet */}
-          {isStreaming && streamingChunks.length === 0 && <ThinkingMessage />}
-
-          {/* Render streaming message if active */}
-          {isStreaming && streamingChunks.length > 0 && (
-            <StreamingMessage
-              chunks={streamingChunks}
-              onComplete={onStreamComplete}
-            />
-          )}
-
-          {/* Invisible div to scroll to */}
-          <div ref={messagesEndRef} />
-        </div>
-      </div>
-
-      {/* Bottom fade shadow */}
-      <div className="pointer-events-none absolute bottom-0 z-10 h-8 w-full bg-gradient-to-t from-[#f8f8f9] to-transparent" />
-    </div>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/MessageList/components/LastToolResponse/LastToolResponse.tsx

@@ -1,30 +0,0 @@
-import { AIChatBubble } from "../../../AIChatBubble/AIChatBubble";
-import type { ChatMessageData } from "../../../ChatMessage/useChatMessage";
-import { MarkdownContent } from "../../../MarkdownContent/MarkdownContent";
-import { formatToolResponse } from "../../../ToolResponseMessage/helpers";
-import { shouldSkipAgentOutput } from "../../helpers";
-
-export interface LastToolResponseProps {
-  message: ChatMessageData;
-  prevMessage: ChatMessageData | undefined;
-}
-
-export function LastToolResponse({
-  message,
-  prevMessage,
-}: LastToolResponseProps) {
-  if (message.type !== "tool_response") return null;
-
-  // Skip if this is an agent_output that should be rendered inside assistant message
-  if (shouldSkipAgentOutput(message, prevMessage)) return null;
-
-  const formattedText = formatToolResponse(message.result, message.toolName);
-
-  return (
-    <div className="min-w-0 overflow-x-hidden hyphens-auto break-words px-4 py-2">
-      <AIChatBubble>
-        <MarkdownContent content={formattedText} />
-      </AIChatBubble>
-    </div>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/MessageList/components/MessageItem/MessageItem.tsx

@@ -1,40 +0,0 @@
-import { ChatMessage } from "../../../ChatMessage/ChatMessage";
-import type { ChatMessageData } from "../../../ChatMessage/useChatMessage";
-import { useMessageItem } from "./useMessageItem";
-
-export interface MessageItemProps {
-  message: ChatMessageData;
-  messages: ChatMessageData[];
-  index: number;
-  lastAssistantMessageIndex: number;
-  isStreaming?: boolean;
-  onSendMessage?: (content: string) => void;
-}
-
-export function MessageItem({
-  message,
-  messages,
-  index,
-  lastAssistantMessageIndex,
-  isStreaming = false,
-  onSendMessage,
-}: MessageItemProps) {
-  const { messageToRender, agentOutput, isFinalMessage } = useMessageItem({
-    message,
-    messages,
-    index,
-    lastAssistantMessageIndex,
-  });
-
-  return (
-    <ChatMessage
-      message={messageToRender}
-      messages={messages}
-      index={index}
-      isStreaming={isStreaming}
-      onSendMessage={onSendMessage}
-      agentOutput={agentOutput}
-      isFinalMessage={isFinalMessage}
-    />
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/MessageList/components/MessageItem/useMessageItem.ts

@@ -1,62 +0,0 @@
-import type { ChatMessageData } from "../../../ChatMessage/useChatMessage";
-import { isAgentOutputResult, isToolOutputPattern } from "../../helpers";
-
-export interface UseMessageItemArgs {
-  message: ChatMessageData;
-  messages: ChatMessageData[];
-  index: number;
-  lastAssistantMessageIndex: number;
-}
-
-export function useMessageItem({
-  message,
-  messages,
-  index,
-  lastAssistantMessageIndex,
-}: UseMessageItemArgs) {
-  let agentOutput: ChatMessageData | undefined;
-  let messageToRender: ChatMessageData = message;
-
-  // Check if assistant message follows a tool_call and looks like a tool output
-  if (message.type === "message" && message.role === "assistant") {
-    const prevMessage = messages[index - 1];
-
-    // Check if next message is an agent_output tool_response to include in current assistant message
-    const nextMessage = messages[index + 1];
-    if (
-      nextMessage &&
-      nextMessage.type === "tool_response" &&
-      nextMessage.result
-    ) {
-      if (isAgentOutputResult(nextMessage.result)) {
-        agentOutput = nextMessage;
-      }
-    }
-
-    // Only convert to tool_response if it follows a tool_call AND looks like a tool output
-    if (prevMessage && prevMessage.type === "tool_call") {
-      if (isToolOutputPattern(message.content)) {
-        // Convert this message to a tool_response format for rendering
-        messageToRender = {
-          type: "tool_response",
-          toolId: prevMessage.toolId,
-          toolName: prevMessage.toolName,
-          result: message.content,
-          success: true,
-          timestamp: message.timestamp,
-        } as ChatMessageData;
-      }
-    }
-  }
-
-  const isFinalMessage =
-    messageToRender.type !== "message" ||
-    messageToRender.role !== "assistant" ||
-    index === lastAssistantMessageIndex;
-
-  return {
-    messageToRender,
-    agentOutput,
-    isFinalMessage,
-  };
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/MessageList/helpers.ts

@@ -1,68 +0,0 @@
-import type { ChatMessageData } from "../ChatMessage/useChatMessage";
-
-export function parseToolResult(
-  result: unknown,
-): Record<string, unknown> | null {
-  try {
-    return typeof result === "string"
-      ? JSON.parse(result)
-      : (result as Record<string, unknown>);
-  } catch {
-    return null;
-  }
-}
-
-export function isAgentOutputResult(result: unknown): boolean {
-  const parsed = parseToolResult(result);
-  return parsed?.type === "agent_output";
-}
-
-export function isToolOutputPattern(content: string): boolean {
-  const normalizedContent = content.toLowerCase().trim();
-
-  return (
-    normalizedContent.startsWith("no agents found") ||
-    normalizedContent.startsWith("no results found") ||
-    normalizedContent.includes("no agents found matching") ||
-    !!normalizedContent.match(/^no \w+ found/i) ||
-    (content.length < 150 && normalizedContent.includes("try different")) ||
-    (content.length < 200 &&
-      !normalizedContent.includes("i'll") &&
-      !normalizedContent.includes("let me") &&
-      !normalizedContent.includes("i can") &&
-      !normalizedContent.includes("i will"))
-  );
-}
-
-export function formatToolResultValue(result: unknown): string {
-  return typeof result === "string"
-    ? result
-    : result
-      ? JSON.stringify(result, null, 2)
-      : "";
-}
-
-export function findLastMessageIndex(
-  messages: ChatMessageData[],
-  predicate: (msg: ChatMessageData) => boolean,
-): number {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (predicate(messages[i])) return i;
-  }
-  return -1;
-}
-
-export function shouldSkipAgentOutput(
-  message: ChatMessageData,
-  prevMessage: ChatMessageData | undefined,
-): boolean {
-  if (message.type !== "tool_response" || !message.result) return false;
-
-  const isAgentOutput = isAgentOutputResult(message.result);
-  return (
-    isAgentOutput &&
-    !!prevMessage &&
-    prevMessage.type === "message" &&
-    prevMessage.role === "assistant"
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/ToolCallMessage/ToolCallMessage.tsx

@@ -1,55 +0,0 @@
-import { Text } from "@/components/atoms/Text/Text";
-import { cn } from "@/lib/utils";
-import type { ToolArguments } from "@/types/chat";
-import { AIChatBubble } from "../AIChatBubble/AIChatBubble";
-import {
-  formatToolArguments,
-  getToolActionPhrase,
-  getToolIcon,
-} from "./helpers";
-
-export interface ToolCallMessageProps {
-  toolId?: string;
-  toolName: string;
-  arguments?: ToolArguments;
-  isStreaming?: boolean;
-  className?: string;
-}
-
-export function ToolCallMessage({
-  toolName,
-  arguments: toolArguments,
-  isStreaming = false,
-  className,
-}: ToolCallMessageProps) {
-  const actionPhrase = getToolActionPhrase(toolName);
-  const argumentsText = formatToolArguments(toolName, toolArguments);
-  const displayText = `${actionPhrase}${argumentsText}`;
-  const IconComponent = getToolIcon(toolName);
-
-  return (
-    <AIChatBubble className={className}>
-      <div className="flex items-center gap-2">
-        <IconComponent
-          size={14}
-          weight={isStreaming ? "regular" : "regular"}
-          className={cn(
-            "shrink-0",
-            isStreaming ? "text-neutral-500" : "text-neutral-400",
-          )}
-        />
-        <Text
-          variant="small"
-          className={cn(
-            "text-xs",
-            isStreaming
-              ? "bg-gradient-to-r from-neutral-600 via-neutral-500 to-neutral-600 bg-[length:200%_100%] bg-clip-text text-transparent [animation:shimmer_2s_ease-in-out_infinite]"
-              : "text-neutral-500",
-          )}
-        >
-          {displayText}
-        </Text>
-      </div>
-    </AIChatBubble>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/ToolCallMessage/helpers.ts

@@ -1,184 +0,0 @@
-import type { ToolArguments } from "@/types/chat";
-import {
-  BrainIcon,
-  EyeIcon,
-  FileMagnifyingGlassIcon,
-  FileTextIcon,
-  MagnifyingGlassIcon,
-  PackageIcon,
-  PencilLineIcon,
-  PlayIcon,
-  PlusIcon,
-  SquaresFourIcon,
-  type Icon,
-} from "@phosphor-icons/react";
-
-/**
- * Maps internal tool names to human-friendly action phrases (present continuous).
- * Used for tool call messages to indicate what action is currently happening.
- *
- * @param toolName - The internal tool name from the backend
- * @returns A human-friendly action phrase in present continuous tense
- */
-export function getToolActionPhrase(toolName: string): string {
-  const normalizedName = toolName.trim();
-  if (!normalizedName) return "Executing";
-  if (normalizedName.toLowerCase().startsWith("executing")) {
-    return normalizedName;
-  }
-  if (normalizedName.toLowerCase() === "unknown") return "Executing";
-  const toolActionPhrases: Record<string, string> = {
-    add_understanding: "Updating your business information",
-    create_agent: "Creating a new agent",
-    edit_agent: "Editing the agent",
-    find_agent: "Looking for agents in the marketplace",
-    find_block: "Searching for blocks",
-    find_library_agent: "Looking for library agents",
-    run_agent: "Running the agent",
-    run_block: "Running the block",
-    view_agent_output: "Retrieving agent output",
-    search_docs: "Searching documentation",
-    get_doc_page: "Loading documentation page",
-    agent_carousel: "Looking for agents in the marketplace",
-    execution_started: "Running the agent",
-    get_required_setup_info: "Getting setup requirements",
-    schedule_agent: "Scheduling the agent to run",
-  };
-
-  // Return mapped phrase or generate human-friendly fallback
-  return (
-    toolActionPhrases[toolName] ||
-    toolName
-      .replace(/_/g, " ")
-      .replace(/\b\w/g, (l) => l.toUpperCase())
-      .replace(/^/, "Executing ")
-  );
-}
-
-/**
- * Formats tool call arguments into user-friendly text.
- * Handles different tool types and formats their arguments nicely.
- *
- * @param toolName - The tool name
- * @param args - The tool arguments
- * @returns Formatted user-friendly text to append to action phrase
- */
-export function formatToolArguments(
-  toolName: string,
-  args: ToolArguments | undefined,
-): string {
-  if (!args || Object.keys(args).length === 0) {
-    return "";
-  }
-
-  switch (toolName) {
-    case "find_agent":
-    case "find_library_agent":
-    case "agent_carousel":
-      if (args.query) {
-        return ` matching "${args.query as string}"`;
-      }
-      break;
-
-    case "find_block":
-      if (args.query) {
-        return ` matching "${args.query as string}"`;
-      }
-      break;
-
-    case "search_docs":
-      if (args.query) {
-        return ` for "${args.query as string}"`;
-      }
-      break;
-
-    case "get_doc_page":
-      if (args.path) {
-        return ` "${args.path as string}"`;
-      }
-      break;
-
-    case "run_agent":
-      if (args.username_agent_slug) {
-        return ` "${args.username_agent_slug as string}"`;
-      }
-      if (args.library_agent_id) {
-        return ` (library agent)`;
-      }
-      break;
-
-    case "run_block":
-      if (args.block_id) {
-        return ` "${args.block_id as string}"`;
-      }
-      break;
-
-    case "view_agent_output":
-      if (args.library_agent_id) {
-        return ` (library agent)`;
-      }
-      if (args.username_agent_slug) {
-        return ` "${args.username_agent_slug as string}"`;
-      }
-      break;
-
-    case "create_agent":
-    case "edit_agent":
-      if (args.name) {
-        return ` "${args.name as string}"`;
-      }
-      break;
-
-    case "add_understanding":
-      const understandingFields = Object.entries(args)
-        .filter(
-          ([_, value]) => value !== null && value !== undefined && value !== "",
-        )
-        .map(([key, value]) => {
-          if (key === "user_name" && typeof value === "string") {
-            return `for ${value}`;
-          }
-          if (typeof value === "string") {
-            return `${key}: ${value}`;
-          }
-          if (Array.isArray(value) && value.length > 0) {
-            return `${key}: ${value.slice(0, 2).join(", ")}${value.length > 2 ? ` (+${value.length - 2} more)` : ""}`;
-          }
-          return key;
-        });
-      if (understandingFields.length > 0) {
-        return ` ${understandingFields[0]}`;
-      }
-      break;
-  }
-
-  return "";
-}
-
-/**
- * Maps tool names to their corresponding Phosphor icon components.
- *
- * @param toolName - The tool name from the backend
- * @returns The Icon component for the tool
- */
-export function getToolIcon(toolName: string): Icon {
-  const iconMap: Record<string, Icon> = {
-    add_understanding: BrainIcon,
-    create_agent: PlusIcon,
-    edit_agent: PencilLineIcon,
-    find_agent: SquaresFourIcon,
-    find_library_agent: MagnifyingGlassIcon,
-    find_block: PackageIcon,
-    run_agent: PlayIcon,
-    run_block: PlayIcon,
-    view_agent_output: EyeIcon,
-    search_docs: FileMagnifyingGlassIcon,
-    get_doc_page: FileTextIcon,
-    agent_carousel: MagnifyingGlassIcon,
-    execution_started: PlayIcon,
-    get_required_setup_info: SquaresFourIcon,
-    schedule_agent: PlayIcon,
-  };
-
-  return iconMap[toolName] || SquaresFourIcon;
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/ToolResponseMessage/ToolResponseMessage.tsx

@@ -1,28 +0,0 @@
-import type { ToolResult } from "@/types/chat";
-import { AIChatBubble } from "../AIChatBubble/AIChatBubble";
-import { MarkdownContent } from "../MarkdownContent/MarkdownContent";
-import { formatToolResponse } from "./helpers";
-
-export interface ToolResponseMessageProps {
-  toolId?: string;
-  toolName: string;
-  result?: ToolResult;
-  success?: boolean;
-  className?: string;
-}
-
-export function ToolResponseMessage({
-  toolId: _toolId,
-  toolName,
-  result,
-  success: _success,
-  className,
-}: ToolResponseMessageProps) {
-  const formattedText = formatToolResponse(result, toolName);
-
-  return (
-    <AIChatBubble className={className}>
-      <MarkdownContent content={formattedText} />
-    </AIChatBubble>
-  );
-}

autogpt_platform/frontend/src/components/contextual/Chat/components/ToolResponseMessage/helpers.ts

@@ -1,256 +0,0 @@
-function getToolCompletionPhrase(toolName: string): string {
-  const toolCompletionPhrases: Record<string, string> = {
-    add_understanding: "Updated your business information",
-    create_agent: "Created the agent",
-    edit_agent: "Updated the agent",
-    find_agent: "Found agents in the marketplace",
-    find_block: "Found blocks",
-    find_library_agent: "Found library agents",
-    run_agent: "Started agent execution",
-    run_block: "Executed the block",
-    view_agent_output: "Retrieved agent output",
-    search_docs: "Found documentation",
-    get_doc_page: "Loaded documentation page",
-  };
-
-  // Return mapped phrase or generate human-friendly fallback
-  return (
-    toolCompletionPhrases[toolName] ||
-    `Completed ${toolName.replace(/_/g, " ").replace("...", "")}`
-  );
-}
-
-export function formatToolResponse(result: unknown, toolName: string): string {
-  if (typeof result === "string") {
-    const trimmed = result.trim();
-    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-      try {
-        const parsed = JSON.parse(trimmed);
-        return formatToolResponse(parsed, toolName);
-      } catch {
-        return trimmed;
-      }
-    }
-    return result;
-  }
-
-  if (typeof result !== "object" || result === null) {
-    return String(result);
-  }
-
-  const response = result as Record<string, unknown>;
-
-  // Handle different response types
-  const responseType = response.type as string | undefined;
-
-  if (!responseType) {
-    if (response.message) {
-      return String(response.message);
-    }
-    return getToolCompletionPhrase(toolName);
-  }
-
-  switch (responseType) {
-    case "agents_found":
-      const agents = (response.agents as Array<{ name: string }>) || [];
-      const count =
-        typeof response.count === "number" && !isNaN(response.count)
-          ? response.count
-          : agents.length;
-      if (count === 0) {
-        return "No agents found matching your search.";
-      }
-      return `Found ${count} agent${count === 1 ? "" : "s"}: ${agents
-        .slice(0, 3)
-        .map((a) => a.name)
-        .join(", ")}${count > 3 ? ` and ${count - 3} more` : ""}`;
-
-    case "agent_details":
-      const agent = response.agent as { name: string; description?: string };
-      if (agent) {
-        return `Agent: ${agent.name}${agent.description ? `\n\n${agent.description}` : ""}`;
-      }
-      break;
-
-    case "block_list":
-      const blocks = (response.blocks as Array<{ name: string }>) || [];
-      const blockCount =
-        typeof response.count === "number" && !isNaN(response.count)
-          ? response.count
-          : blocks.length;
-      if (blockCount === 0) {
-        return "No blocks found matching your search.";
-      }
-      return `Found ${blockCount} block${blockCount === 1 ? "" : "s"}: ${blocks
-        .slice(0, 3)
-        .map((b) => b.name)
-        .join(", ")}${blockCount > 3 ? ` and ${blockCount - 3} more` : ""}`;
-
-    case "block_output":
-      const blockName = (response.block_name as string) || "Block";
-      const outputs = response.outputs as Record<string, unknown> | undefined;
-      if (outputs && Object.keys(outputs).length > 0) {
-        const outputKeys = Object.keys(outputs);
-        return `${blockName} executed successfully. Outputs: ${outputKeys.join(", ")}`;
-      }
-      return `${blockName} executed successfully.`;
-
-    case "doc_search_results":
-      const docResults = (response.results as Array<{ title: string }>) || [];
-      const docCount =
-        typeof response.count === "number" && !isNaN(response.count)
-          ? response.count
-          : docResults.length;
-      if (docCount === 0) {
-        return "No documentation found matching your search.";
-      }
-      return `Found ${docCount} documentation result${docCount === 1 ? "" : "s"}: ${docResults
-        .slice(0, 3)
-        .map((r) => r.title)
-        .join(", ")}${docCount > 3 ? ` and ${docCount - 3} more` : ""}`;
-
-    case "doc_page":
-      const title = (response.title as string) || "Documentation";
-      const content = (response.content as string) || "";
-      if (content) {
-        const preview = content.substring(0, 200).trim();
-        return `${title}\n\n${preview}${content.length > 200 ? "..." : ""}`;
-      }
-      return title;
-
-    case "understanding_updated":
-      const currentUnderstanding = response.current_understanding as
-        | Record<string, unknown>
-        | undefined;
-      const fields = (response.updated_fields as string[]) || [];
-
-      if (response.message && typeof response.message === "string") {
-        let message = response.message;
-        if (currentUnderstanding) {
-          for (const [key, value] of Object.entries(currentUnderstanding)) {
-            if (value !== null && value !== undefined && value !== "") {
-              const placeholder = key;
-              const actualValue = String(value);
-              message = message.replace(
-                new RegExp(`\\b${placeholder}\\b`, "g"),
-                actualValue,
-              );
-            }
-          }
-        }
-        return message;
-      }
-
-      if (
-        currentUnderstanding &&
-        Object.keys(currentUnderstanding).length > 0
-      ) {
-        const understandingEntries = Object.entries(currentUnderstanding)
-          .filter(
-            ([_, value]) =>
-              value !== null && value !== undefined && value !== "",
-          )
-          .map(([key, value]) => {
-            if (key === "user_name" && typeof value === "string") {
-              return `Updated information for ${value}`;
-            }
-            return `${key}: ${String(value)}`;
-          });
-        if (understandingEntries.length > 0) {
-          return understandingEntries[0];
-        }
-      }
-      if (fields.length > 0) {
-        return `Updated business information: ${fields.join(", ")}`;
-      }
-      return "Updated your business information.";
-
-    case "agent_saved":
-      const agentName = (response.agent_name as string) || "Agent";
-      return `Successfully saved "${agentName}" to your library.`;
-
-    case "agent_preview":
-      const previewAgentName = (response.agent_name as string) || "Agent";
-      const nodeCount = (response.node_count as number) || 0;
-      const linkCount = (response.link_count as number) || 0;
-      const description = (response.description as string) || "";
-      let previewText = `Preview: "${previewAgentName}"`;
-      if (description) {
-        previewText += `\n\n${description}`;
-      }
-      previewText += `\n\n${nodeCount} node${nodeCount === 1 ? "" : "s"}, ${linkCount} link${linkCount === 1 ? "" : "s"}`;
-      return previewText;
-
-    case "clarification_needed":
-      const questions =
-        (response.questions as Array<{ question: string }>) || [];
-      if (questions.length === 0) {
-        return response.message
-          ? String(response.message)
-          : "I need more information to proceed.";
-      }
-      if (questions.length === 1) {
-        return questions[0].question;
-      }
-      return `I need clarification on ${questions.length} points:\n\n${questions
-        .map((q, i) => `${i + 1}. ${q.question}`)
-        .join("\n")}`;
-
-    case "agent_output":
-      if (response.message) {
-        return String(response.message);
-      }
-      const outputAgentName = (response.agent_name as string) || "Agent";
-      const execution = response.execution as
-        | {
-            status?: string;
-            outputs?: Record<string, unknown>;
-          }
-        | undefined;
-      if (execution) {
-        const status = execution.status || "completed";
-        const outputs = execution.outputs || {};
-        const outputKeys = Object.keys(outputs);
-        if (outputKeys.length > 0) {
-          return `${outputAgentName} execution ${status}. Outputs: ${outputKeys.join(", ")}`;
-        }
-        return `${outputAgentName} execution ${status}.`;
-      }
-      return `${outputAgentName} output retrieved.`;
-
-    case "execution_started":
-      const execAgentName = (response.graph_name as string) || "Agent";
-      if (response.message) {
-        return String(response.message);
-      }
-      return `Started execution of "${execAgentName}".`;
-
-    case "error":
-      const errorMsg =
-        (response.error as string) || response.message || "An error occurred";
-      return `Error: ${errorMsg}`;
-
-    case "no_results":
-      const suggestions = (response.suggestions as string[]) || [];
-      let noResultsText = (response.message as string) || "No results found.";
-      if (suggestions.length > 0) {
-        noResultsText += `\n\nSuggestions: ${suggestions.join(", ")}`;
-      }
-      return noResultsText;
-
-    default:
-      // Try to extract a message field
-      if (response.message) {
-        return String(response.message);
-      }
-      // Fallback: try to stringify nicely
-      if (Object.keys(response).length === 0) {
-        return getToolCompletionPhrase(toolName);
-      }
-      // If we have a response object but no recognized type, try to format it nicely
-      // Don't return raw JSON - return a completion phrase instead
-      return getToolCompletionPhrase(toolName);
-  }
-
-  return getToolCompletionPhrase(toolName);
-}