Skip to content

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

fix(platform): restore pending expert onboarding in new chats (#15038)

Ubbe94f685bfb0b1
diff --git a/autogpt_platform/backend/backend/api/features/experts/onboarding.py b/autogpt_platform/backend/backend/api/features/experts/onboarding.py
new file mode 100644
index 0000000000..ce7809321e
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/experts/onboarding.py
@@ -0,0 +1,94 @@
+import autogpt_libs.auth as auth
+from fastapi import APIRouter, HTTPException, Security
+from pydantic import BaseModel, ValidationError
+
+from backend.api.features.experts import experts_db
+from backend.copilot.tools.models import ExpertOnboardingResponse, ResponseType
+from backend.data.db import query_raw_with_schema
+
+router = APIRouter()
+
+SKIP_MESSAGE = "Let's skip the setup questions for now."
+
+
+class OnboardingMessage(BaseModel):
+ role: str
+ content: str
+
+
[email protected]("/{expert_id}/onboarding", operation_id="get_expert_onboarding")
+async def get_expert_onboarding(
+ expert_id: str,
+ user_id: str = Security(auth.get_user_id),
+) -> ExpertOnboardingResponse | None:
+ expert = await experts_db.get_expert(user_id, expert_id)
+ if expert is None or expert.is_archived:
+ raise HTTPException(status_code=404, detail="Expert not found")
+ messages = await query_raw_with_schema(
+ """
+ SELECT m.role, m.content
+ FROM {schema_prefix}"ChatMessage" m
+ JOIN {schema_prefix}"ChatSession" s ON s.id = m."sessionId"
+ WHERE s."userId" = $1 AND s."expertId" = $2
+ AND (
+ (m.role = 'tool' AND m.content LIKE '%"expert_onboarding"%')
+ OR (m.role = 'user' AND (
+ m.content = $3 OR m.content LIKE '**Here are my answers:**%'
+ ))
+ )
+ ORDER BY m."createdAt", m.sequence
+ """,
+ user_id,
+ expert_id,
+ SKIP_MESSAGE,
+ model=OnboardingMessage,
+ )
+ return pending_onboarding(messages, expert_id)
+
+
+def pending_onboarding(
+ messages: list[OnboardingMessage], expert_id: str
+) -> ExpertOnboardingResponse | None:
+ cards: list[ExpertOnboardingResponse] = []
+ for message in messages:
+ if message.role == "tool":
+ try:
+ card = ExpertOnboardingResponse.model_validate_json(message.content)
+ except ValidationError:
+ continue
+ if (
+ card.type == ResponseType.EXPERT_ONBOARDING
+ and card.expert_id == expert_id
+ and card.steps
+ ):
+ cards.append(card)
+ elif message.role == "user" and cards:
+ if message.content == SKIP_MESSAGE or any(
+ _answers_card(message.content, card) for card in cards
+ ):
+ return None
+ return cards[-1] if cards else None
+
+
+def _answers_card(content: str, card: ExpertOnboardingResponse) -> bool:
+ if not content.startswith("**Here are my answers:**\n\n"):
+ return False
+ if not content.endswith("\n\nPlease proceed."):
+ return False
+ remaining = content.removeprefix("**Here are my answers:**\n\n").removesuffix(
+ "\n\nPlease proceed."
+ )
+ for index, step in enumerate(card.steps):
+ question = f"> {step.question}\n\n"
+ if not remaining.startswith(question):
+ return False
+ remaining = remaining.removeprefix(question)
+ if index + 1 < len(card.steps):
+ next_question = f"\n\n> {card.steps[index + 1].question}\n\n"
+ answer, separator, remaining = remaining.partition(next_question)
+ if not separator or not answer.strip():
+ return False
+ remaining = next_question.removeprefix("\n\n") + remaining
+ elif not remaining.strip():
+ return False
+ return True
diff --git a/autogpt_platform/backend/backend/api/features/experts/onboarding_test.py b/autogpt_platform/backend/backend/api/features/experts/onboarding_test.py
new file mode 100644
index 0000000000..1cae50d4c7
--- /dev/null
+++ b/autogpt_platform/backend/backend/api/features/experts/onboarding_test.py
@@ -0,0 +1,128 @@
+import json
+from unittest.mock import AsyncMock
+
+import pytest
+from fastapi import FastAPI, HTTPException
+from fastapi.testclient import TestClient
+
+from backend.api.features.experts import onboarding
+
+EXPERT_ID = "expert-kepler"
+
+
+def test_route_requires_authentication():
+ app = FastAPI()
+ app.include_router(onboarding.router)
+ response = TestClient(app).get(f"/{EXPERT_ID}/onboarding")
+ assert response.status_code in (401, 403)
+
+
+def test_route_returns_saved_questions_for_authenticated_owner(mocker):
+ app = FastAPI()
+ app.include_router(onboarding.router)
+ app.dependency_overrides[onboarding.auth.get_user_id] = lambda: "user-1"
+ expert = mocker.patch.object(
+ onboarding.experts_db, "get_expert", return_value=mocker.Mock(is_archived=False)
+ )
+ mocker.patch.object(
+ onboarding, "query_raw_with_schema", new=AsyncMock(return_value=[card()])
+ )
+ response = TestClient(app).get(f"/{EXPERT_ID}/onboarding")
+ assert response.status_code == 200
+ assert response.json()["steps"][0]["question"] == "What topic?"
+ expert.assert_awaited_once_with("user-1", EXPERT_ID)
+
+
+def card(**overrides) -> onboarding.OnboardingMessage:
+ return onboarding.OnboardingMessage(
+ role="tool",
+ content=json.dumps(
+ {
+ "type": "expert_onboarding",
+ "message": "Setup",
+ "expert_id": EXPERT_ID,
+ "greeting": "I'm Kepler.",
+ "steps": [
+ {"keyword": "topic", "question": "What topic?", "options": []},
+ {"keyword": "format", "question": "What format?", "options": []},
+ ],
+ **overrides,
+ }
+ ),
+ )
+
+
+ "reply, pending",
+ [
+ ("", True),
+ ("Research this company", True),
+ (onboarding.SKIP_MESSAGE, False),
+ (
+ "**Here are my answers:**\n\n> What topic?\n\nAI\n\n"
+ "> What format?\n\nReport\n\nPlease proceed.",
+ False,
+ ),
+ ("**Here are my answers:**\n\n> What topic?\n\nAI\n\nPlease proceed.", True),
+ (
+ "**Here are my answers:**\n\n> Another question?\n\nAI\n\nPlease proceed.",
+ True,
+ ),
+ (
+ "**Here are my answers:**\n\n> What topic?\n\n\n\n> What format?\n\nReport\n\nPlease proceed.",
+ True,
+ ),
+ ],
+)
+def test_only_complete_answers_or_skip_settle_setup(reply, pending):
+ messages = [card(), onboarding.OnboardingMessage(role="user", content=reply)]
+ assert (onboarding.pending_onboarding(messages, EXPERT_ID) is not None) == pending
+
+
+def test_completion_applies_across_chats_and_later_cards():
+ messages = [
+ card(),
+ onboarding.OnboardingMessage(role="user", content=onboarding.SKIP_MESSAGE),
+ card(),
+ ]
+ assert onboarding.pending_onboarding(messages, EXPERT_ID) is None
+
+
+def test_ignores_invalid_cards_and_other_experts():
+ messages = [
+ onboarding.OnboardingMessage(role="tool", content="invalid json"),
+ card(expert_id="another-expert"),
+ card(steps=[]),
+ card(type="error"),
+ ]
+ assert onboarding.pending_onboarding(messages, EXPERT_ID) is None
+
+
+async def test_history_query_scopes_user_and_expert(mocker):
+ mocker.patch.object(
+ onboarding.experts_db, "get_expert", return_value=mocker.Mock(is_archived=False)
+ )
+ query = mocker.patch.object(
+ onboarding, "query_raw_with_schema", new=AsyncMock(return_value=[card()])
+ )
+ result = await onboarding.get_expert_onboarding(EXPERT_ID, "user-1")
+ assert result is not None
+ assert query.call_args.args[1:] == ("user-1", EXPERT_ID, onboarding.SKIP_MESSAGE)
+ assert query.call_args.kwargs["model"] is onboarding.OnboardingMessage
+ assert 's."userId" = $1 AND s."expertId" = $2' in query.call_args.args[0]
+
+
[email protected]("archived", [False, True])
+async def test_unavailable_experts_do_not_read_history(mocker, archived):
+ mocker.patch.object(
+ onboarding.experts_db,
+ "get_expert",
+ return_value=mocker.Mock(is_archived=True) if archived else None,
+ )
+ query = mocker.patch.object(onboarding, "query_raw_with_schema", new=AsyncMock())
+ with pytest.raises(HTTPException) as error:
+ await onboarding.get_expert_onboarding(EXPERT_ID, "user-1")
+ assert error.value.status_code == 404
+ query.assert_not_called()
diff --git a/autogpt_platform/backend/backend/api/features/experts/routes.py b/autogpt_platform/backend/backend/api/features/experts/routes.py
index 97268d5e9e..5a56907583 100644
--- a/autogpt_platform/backend/backend/api/features/experts/routes.py
+++ b/autogpt_platform/backend/backend/api/features/experts/routes.py
@@ -7,7 +7,7 @@ from pydantic import BaseModel, Field, field_validator, model_validator
from backend.api.features.experts import avatar_routes
from backend.api.features.experts import credentials as expert_credentials
-from backend.api.features.experts import experts_db, scheduling
+from backend.api.features.experts import experts_db, onboarding, scheduling
from backend.api.features.experts import setup as expert_setup
from backend.api.features.experts.errors import ExpertScheduleCleanupError
from backend.api.features.experts.models import (
@@ -56,6 +56,7 @@ router = APIRouter(
)
router.include_router(avatar_routes.router)
+router.include_router(onboarding.router)
# Templates are marketplace content: the expert page shows them to signed-out
# visitors, so they live on a router without the session requirement. It must
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatContainer/ChatContainer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatContainer/ChatContainer.tsx
index 8fdc170a85..1ec82e9f52 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatContainer/ChatContainer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatContainer/ChatContainer.tsx
@@ -14,6 +14,7 @@ import type { WorkspaceAttachment } from "../../helpers/workspaceAttachments";
import type { PendingUploadSend } from "../../copilotStreamStore";
import { ChatMessagesContainer } from "../ChatMessagesContainer/ChatMessagesContainer";
import { CopilotChatActionsProvider } from "../CopilotChatActionsProvider/CopilotChatActionsProvider";
+import { NewChatOnboarding } from "../ExpertOnboardingCard/NewChatOnboarding";
import { EmptySession } from "../EmptySession/EmptySession";
import { PendingAnswerContexts } from "./components/PendingAnswerContexts";
import { UsageLimitReachedCard } from "../UsageLimits/UsageLimitReachedCard/UsageLimitReachedCard";
@@ -333,29 +334,40 @@ export const ChatContainer = ({
}
/>
</div>
- <ChatMessagesContainer
- messages={messages}
- status={status}
- error={error}
- isLoading={isLoadingSession}
- isRestoringActiveSession={isRestoringActiveSession}
- restoreStatusMessage={restoreStatusMessage}
- activeStreamStartedAt={activeStreamStartedAt}
- sessionID={sessionId}
- sessionChatStatus={sessionChatStatus}
- sessionSentFrom={sessionSentFrom}
- hasMoreMessages={hasMoreMessages}
- isLoadingMore={isLoadingMore}
- onLoadMore={onLoadMore}
- onRetry={handleRetry}
- turnStats={turnStats}
- queuedMessages={queuedMessages}
- pendingSend={pendingSend}
- bottomContentPadding={usageCardHeight}
- expertIdentity={expertIdentity}
- isResolvingExpertIdentity={isResolvingExpertIdentity}
- hasFloatingControls={hasFloatingControls}
- />
+ <NewChatOnboarding
+ expertId={expertIdentity?.id ?? null}
+ enabled={
+ messages.length === 0 &&
+ !isInputDisabled &&
+ !isStreaming &&
+ !isCreatingSession &&
+ !isExpertArchived
+ }
+ >
+ <ChatMessagesContainer
+ messages={messages}
+ status={status}
+ error={error}
+ isLoading={isLoadingSession}
+ isRestoringActiveSession={isRestoringActiveSession}
+ restoreStatusMessage={restoreStatusMessage}
+ activeStreamStartedAt={activeStreamStartedAt}
+ sessionID={sessionId}
+ sessionChatStatus={sessionChatStatus}
+ sessionSentFrom={sessionSentFrom}
+ hasMoreMessages={hasMoreMessages}
+ isLoadingMore={isLoadingMore}
+ onLoadMore={onLoadMore}
+ onRetry={handleRetry}
+ turnStats={turnStats}
+ queuedMessages={queuedMessages}
+ pendingSend={pendingSend}
+ bottomContentPadding={usageCardHeight}
+ expertIdentity={expertIdentity}
+ isResolvingExpertIdentity={isResolvingExpertIdentity}
+ hasFloatingControls={hasFloatingControls}
+ />
+ </NewChatOnboarding>
{archivedExpertIdentity ? (
<ArchivedExpertNotice
expertName={archivedExpertIdentity.name}
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatContainer/__tests__/new-chat-onboarding.test.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatContainer/__tests__/new-chat-onboarding.test.tsx
new file mode 100644
index 0000000000..a22bd74ee0
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatContainer/__tests__/new-chat-onboarding.test.tsx
@@ -0,0 +1,143 @@
+import { server } from "@/mocks/mock-server";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import {
+ fireEvent,
+ act,
+ render,
+ screen,
+ waitFor,
+} from "@/tests/integrations/test-utils";
+import { http, HttpResponse } from "msw";
+import { describe, expect, test, vi } from "vitest";
+import { ChatContainer, type ChatContainerProps } from "../ChatContainer";
+
+vi.mock("@/services/feature-flags/use-get-flag", async (importOriginal) => {
+ const actual =
+ await importOriginal<
+ typeof import("@/services/feature-flags/use-get-flag")
+ >();
+ return { ...actual, useGetFlag: () => false };
+});
+
+const props: ChatContainerProps = {
+ messages: [],
+ status: "ready",
+ error: undefined,
+ sessionId: null,
+ isLoadingSession: false,
+ isCreatingSession: false,
+ onCreateSession: vi.fn(),
+ onStop: vi.fn(),
+ onSend: vi.fn(),
+ expertIdentity: {
+ id: "expert-kepler",
+ name: "Kepler",
+ role: "researcher",
+ avatarUrl: null,
+ isArchived: false,
+ readOnlyReason: null,
+ },
+};
+
+function mockOnboarding(completed = false) {
+ const request = vi.fn(() =>
+ HttpResponse.json(
+ completed
+ ? null
+ : {
+ type: "expert_onboarding",
+ expert_id: "expert-kepler",
+ greeting: "I'm Kepler.",
+ message: "What topic?",
+ steps: [
+ {
+ question: "What topic?",
+ keyword: "topic",
+ options: ["AI", "Energy"],
+ },
+ ],
+ },
+ ),
+ );
+ server.use(http.get("/api/proxy/api/experts/:expertId/onboarding", request));
+ return request;
+}
+
+describe("new full-page expert chats", () => {
+ test("keeps draft answers when onboarding status refetches", async () => {
+ mockOnboarding();
+ const queryClient = new QueryClient();
+ render(
+ <QueryClientProvider client={queryClient}>
+ <ChatContainer {...props} />
+ </QueryClientProvider>,
+ );
+ fireEvent.click(await screen.findByRole("radio", { name: "AI" }));
+ await act(async () => {
+ await queryClient.invalidateQueries({
+ queryKey: ["/api/experts/expert-kepler/onboarding"],
+ });
+ });
+ expect(
+ screen.getByRole("radio", { name: "AI" }).getAttribute("aria-checked"),
+ ).toBe("true");
+ });
+
+ test.each([null, "empty-session"])(
+ "shows pending onboarding in chat %s",
+ async (sessionId) => {
+ mockOnboarding();
+ const onSend = vi.fn();
+ render(
+ <ChatContainer {...props} sessionId={sessionId} onSend={onSend} />,
+ );
+ expect(await screen.findByText("What topic?")).toBeDefined();
+ fireEvent.click(screen.getByRole("button", { name: "Skip" }));
+ await waitFor(() =>
+ expect(onSend).toHaveBeenCalledWith(
+ "Let's skip the setup questions for now.",
+ ),
+ );
+ },
+ );
+
+ test("sends completed answers through the new chat's send handler", async () => {
+ mockOnboarding();
+ const onSend = vi.fn();
+ render(<ChatContainer {...props} onSend={onSend} />);
+ fireEvent.click(await screen.findByRole("radio", { name: "AI" }));
+ fireEvent.click(screen.getByRole("button", { name: /Send answers/i }));
+ await waitFor(() =>
+ expect(onSend).toHaveBeenCalledWith(
+ "**Here are my answers:**\n\n> What topic?\n\nAI\n\nPlease proceed.",
+ ),
+ );
+ });
+
+ test("does not show completed or skipped onboarding", async () => {
+ const request = mockOnboarding(true);
+ render(<ChatContainer {...props} />);
+ await waitFor(() => expect(request).toHaveBeenCalled());
+ expect(screen.queryByText("What topic?")).toBeNull();
+ });
+
+ test("does not request onboarding after the user sends a prompt", async () => {
+ const request = mockOnboarding();
+ render(
+ <ChatContainer
+ {...props}
+ sessionId="existing-session"
+ messages={[
+ {
+ id: "user-1",
+ role: "user",
+ parts: [{ type: "text", text: "Research this company" }],
+ },
+ ]}
+ />,
+ );
+ expect(await screen.findByText("Research this company")).toBeDefined();
+ expect(request).not.toHaveBeenCalled();
+ expect(screen.queryByText("What topic?")).toBeNull();
+ });
+});
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/EmptySession/EmptySession.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/EmptySession/EmptySession.tsx
index 08eae681b3..91c18d9cb3 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/EmptySession/EmptySession.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/EmptySession/EmptySession.tsx
@@ -28,6 +28,7 @@ import { CopilotHome } from "../CopilotHome/CopilotHome";
import { RecipientChip } from "../ChatInput/components/RecipientChip";
import { ConnectionPicker } from "../ChatInput/components/ConnectionPicker/ConnectionPicker";
import { useRecipientPicker } from "./useRecipientPicker";
+import { NewChatOnboarding } from "../ExpertOnboardingCard/NewChatOnboarding";
interface Props {
isCreatingSession: boolean;
@@ -170,7 +171,12 @@ export function EmptySession({
// moves it there rather than replacing it.
<GreetingLoader />
) : (
- <EmptyHero name={greetingName} intro={introLine} />
+ <NewChatOnboarding
+ expertId={expertId}
+ enabled={!isInteractionLocked}
+ >
+ <EmptyHero name={greetingName} intro={introLine} />
+ </NewChatOnboarding>
)}
{/* Held back while the greeting is on its way — it enters with
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ExpertOnboardingCard/NewChatOnboarding.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ExpertOnboardingCard/NewChatOnboarding.tsx
new file mode 100644
index 0000000000..f060d62cf9
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ExpertOnboardingCard/NewChatOnboarding.tsx
@@ -0,0 +1,54 @@
+"use client";
+
+import { useGetExpertOnboarding } from "@/app/api/__generated__/endpoints/experts/experts";
+import type { ReactNode } from "react";
+import { ExpertOnboardingCard } from "./ExpertOnboardingCard";
+import { PendingOnboardingContext } from "./PendingOnboardingContext";
+
+interface Props {
+ expertId: string | null;
+ enabled?: boolean;
+ children?: ReactNode;
+}
+
+export function NewChatOnboarding({
+ expertId,
+ enabled = true,
+ children,
+}: Props) {
+ const query = useGetExpertOnboarding(expertId ?? "", {
+ query: {
+ enabled: enabled && !!expertId,
+ staleTime: 0,
+ refetchOnMount: "always",
+ },
+ });
+ const onboarding = query.data?.status === 200 ? query.data.data : null;
+ if (
+ !enabled ||
+ !expertId ||
+ !query.isFetchedAfterMount ||
+ query.isError ||
+ !onboarding
+ ) {
+ return children;
+ }
+ const callId = `pending-onboarding-${expertId}`;
+
+ return (
+ <div className="mx-auto min-h-0 w-full max-w-3xl flex-1 overflow-y-auto px-3 py-6 text-left">
+ <PendingOnboardingContext.Provider value={callId}>
+ <ExpertOnboardingCard
+ key={callId}
+ part={{
+ type: "tool-expert_onboarding",
+ toolCallId: callId,
+ state: "output-available",
+ input: {},
+ output: onboarding,
+ }}
+ />
+ </PendingOnboardingContext.Provider>
+ </div>
+ );
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/ExpertChatDrawer.tsx b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/ExpertChatDrawer.tsx
index 1aa6da9d84..abe0c9d37f 100644
--- a/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/ExpertChatDrawer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/ExpertChatDrawer.tsx
@@ -3,6 +3,7 @@
import { getExpertRoleLabel } from "@/services/experts/expert-role-label";
import { ChatInput } from "@/app/(platform)/copilot/components/ChatInput/ChatInput";
+import { NewChatOnboarding } from "@/app/(platform)/copilot/components/ExpertOnboardingCard/NewChatOnboarding";
import { PendingAnswerContexts } from "@/app/(platform)/copilot/components/ChatContainer/components/PendingAnswerContexts";
import { ChatMessagesContainer } from "@/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer";
import { CopilotChatActionsProvider } from "@/app/(platform)/copilot/components/CopilotChatActionsProvider/CopilotChatActionsProvider";
@@ -89,7 +90,12 @@ export function ExpertChatDrawer({
onClose={onClose}
>
{identity && target ? (
- <ChatPanelBody target={target} identity={identity} chat={chat} />
+ <ChatPanelBody
+ key={threadKey}
+ target={target}
+ identity={identity}
+ chat={chat}
+ />
) : null}
</ExpertSidePanel>
);
@@ -109,15 +115,18 @@ function ChatPanelBody({ target, identity, chat }: BodyProps) {
error,
stop,
onSend,
+ onActionSend,
queuedMessages,
isResolvingSession,
+ isLoadingSession,
isCreating,
+ suppressOnboarding,
} = chat;
const isStreaming = status === "streaming" || status === "submitted";
return (
- <CopilotChatActionsProvider onSend={onSend}>
+ <CopilotChatActionsProvider onSend={onActionSend}>
<div className="flex min-h-0 flex-1 flex-col">
{isResolvingSession ? (
<div className="flex flex-1 items-center justify-center px-4 py-6">
@@ -128,34 +137,49 @@ function ChatPanelBody({ target, identity, chat }: BodyProps) {
) : sessionId ? (
<div className="flex min-h-0 flex-1 flex-col">
<PendingAnswerContexts messages={messages}>
- <ChatMessagesContainer
- messages={messages}
- status={status}
- error={error}
- isLoading={false}
- sessionID={sessionId}
- queuedMessages={queuedMessages}
- variant="compact"
- showThreadHeader={false}
- />
+ <NewChatOnboarding
+ expertId={target.expertId}
+ enabled={
+ messages.length === 0 &&
+ !isLoadingSession &&
+ !suppressOnboarding &&
+ !isStreaming
+ }
+ >
+ <ChatMessagesContainer
+ messages={messages}
+ status={status}
+ error={error}
+ isLoading={false}
+ sessionID={sessionId}
+ queuedMessages={queuedMessages}
+ variant="compact"
+ showThreadHeader={false}
+ />
+ </NewChatOnboarding>
</PendingAnswerContexts>
</div>
) : (
- <div className="flex flex-1 flex-col items-center justify-center gap-3 px-6 py-6 text-center">
- <IdentityAvatar
- identity={identity}
- className="h-24 w-24"
- imageSize={192}
- />
- <div className="space-y-0.5">
- <Text variant="body-medium" tone="primary">
- What can I do for you?
- </Text>
- <Text variant="small" tone="muted">
- {target.name} · {getExpertRoleLabel(target.role)}
- </Text>
+ <NewChatOnboarding
+ expertId={target.expertId}
+ enabled={!suppressOnboarding}
+ >
+ <div className="flex flex-1 flex-col items-center justify-center gap-3 px-6 py-6 text-center">
+ <IdentityAvatar
+ identity={identity}
+ className="h-24 w-24"
+ imageSize={192}
+ />
+ <div className="space-y-0.5">
+ <Text variant="body-medium" tone="primary">
+ What can I do for you?
+ </Text>
+ <Text variant="small" tone="muted">
+ {target.name} · {getExpertRoleLabel(target.role)}
+ </Text>
+ </div>
</div>
- </div>
+ </NewChatOnboarding>
)}
<div className="shrink-0 px-3 pb-5 pt-2">
<ChatInput
diff --git a/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/ExpertChatDrawer.test.tsx b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/ExpertChatDrawer.test.tsx
index e6176f45b4..396309bebf 100644
--- a/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/ExpertChatDrawer.test.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/ExpertChatDrawer.test.tsx
@@ -2,16 +2,131 @@ import {
getGetV2GetSessionMockHandler200,
getGetV2ListSessionsMockHandler200,
} from "@/app/api/__generated__/endpoints/chat/chat.msw";
-import type { SessionDetailResponseMessagesItem } from "@/app/api/__generated__/models/sessionDetailResponseMessagesItem";
import { server } from "@/mocks/mock-server";
-import { render, screen } from "@/tests/integrations/test-utils";
-import { describe, expect, test } from "vitest";
+import {
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from "@/tests/integrations/test-utils";
+import { describe, expect, test, vi } from "vitest";
+import { http, HttpResponse } from "msw";
+import { onboardingCard, onboardingTurn } from "./onboardingFixtures";
import { ExpertChatDrawer } from "../ExpertChatDrawer";
const EXPERT_ID = "expert-zara";
const SESSION_ID = "session-zara";
describe("ExpertChatDrawer", () => {
+ test("keeps answers if creating the new chat fails", async () => {
+ const createSession = vi.fn(() =>
+ HttpResponse.json({ detail: "Unavailable" }, { status: 503 }),
+ );
+ server.use(
+ http.get("/api/proxy/api/experts/:expertId/onboarding", () =>
+ HttpResponse.json(onboardingCard()),
+ ),
+ http.post("/api/proxy/api/chat/sessions", createSession),
+ );
+ render(
+ <ExpertChatDrawer
+ target={{
+ expertId: EXPERT_ID,
+ name: "Zara",
+ role: "GTM Strategist",
+ avatarUrl: null,
+ }}
+ resumeLatest={false}
+ onClose={() => {}}
+ />,
+ );
+ fireEvent.click(await screen.findByRole("radio", { name: "Pricing" }));
+ fireEvent.click(screen.getByRole("button", { name: "Send answers" }));
+ await waitFor(() => expect(createSession).toHaveBeenCalled());
+ await waitFor(() =>
+ expect(
+ (
+ screen.getByRole("button", {
+ name: "Send answers",
+ }) as HTMLButtonElement
+ ).disabled,
+ ).toBe(false),
+ );
+ expect(
+ screen
+ .getByRole("radio", { name: "Pricing" })
+ .getAttribute("aria-checked"),
+ ).toBe("true");
+ });
+
+ test("keeps settled setup out of new chats", async () => {
+ const request = vi.fn(() => HttpResponse.json(null));
+ server.use(
+ http.get("/api/proxy/api/experts/:expertId/onboarding", request),
+ );
+ render(
+ <ExpertChatDrawer
+ target={{
+ expertId: EXPERT_ID,
+ name: "Zara",
+ role: "GTM Strategist",
+ avatarUrl: null,
+ }}
+ resumeLatest={false}
+ onClose={() => {}}
+ />,
+ );
+ await waitFor(() => expect(request).toHaveBeenCalled());
+ expect(screen.getByText("What can I do for you?")).toBeDefined();
+ expect(screen.queryByRole("button", { name: "Skip" })).toBeNull();
+ });
+
+ test("does not request setup when the new chat has a prompt", async () => {
+ const request = vi.fn(() => HttpResponse.json(onboardingCard()));
+ server.use(
+ http.get("/api/proxy/api/experts/:expertId/onboarding", request),
+ );
+ render(
+ <ExpertChatDrawer
+ target={{
+ expertId: EXPERT_ID,
+ name: "Zara",
+ role: "GTM Strategist",
+ avatarUrl: null,
+ }}
+ resumeLatest={false}
+ seedPrompt="Research this company"
+ onClose={() => {}}
+ />,
+ );
+ expect(await screen.findByText("What can I do for you?")).toBeDefined();
+ expect(request).not.toHaveBeenCalled();
+ });
+
+ test("shows unanswered setup questions in a new chat", async () => {
+ server.use(
+ http.get("/api/proxy/api/experts/:expertId/onboarding", () =>
+ HttpResponse.json(onboardingCard()),
+ ),
+ );
+ render(
+ <ExpertChatDrawer
+ target={{
+ expertId: EXPERT_ID,
+ name: "Zara",
+ role: "GTM Strategist",
+ avatarUrl: null,
+ }}
+ resumeLatest={false}
+ onClose={() => {}}
+ />,
+ );
+ expect(
+ await screen.findByText("Which outcome should I start with?"),
+ ).toBeDefined();
+ expect(screen.getByRole("button", { name: "Skip" })).toBeDefined();
+ });
+
test("a hire's onboarding card is a live form, not a settled row", async () => {
server.use(
getGetV2ListSessionsMockHandler200({
@@ -55,67 +170,3 @@ describe("ExpertChatDrawer", () => {
expect(screen.queryByText(/Setup questions from/)).toBeNull();
});
});
-
-function onboardingTurn(): SessionDetailResponseMessagesItem[] {
- const row = {
- tool_call_id: null,
- tool_calls: null,
- duration_ms: null,
- metadata: null,
- };
- return [
- {
- ...row,
- id: "db-1",
- role: "user",
- content: "Hey!",
- sequence: 1,
- created_at: "2026-09-27T18:00:00Z",
- },
- {
- ...row,
- id: "db-2",
- role: "assistant",
- content: "",
- tool_calls: [
- {
- id: "call-onboarding",
- type: "function",
- function: { name: "expert_onboarding", arguments: "{}" },
- },
- ],
- sequence: 2,
- created_at: "2026-09-27T18:00:10Z",
- },
- {
- ...row,
- id: "db-3",
- role: "tool",
- tool_call_id: "call-onboarding",
- content: JSON.stringify({
- type: "expert_onboarding",
- message: "Which outcome should I start with?",
- session_id: SESSION_ID,
- expert_id: EXPERT_ID,
- greeting: "Hi, I'm Zara.",
- steps: [
- {
- question: "Which outcome should I start with?",
- keyword: "outcome",
- options: ["Positioning", "Pricing"],
- },
- ],
- }),
- sequence: 3,
- created_at: "2026-09-27T18:00:11Z",
- },
- {
- ...row,
- id: "db-4",
- role: "assistant",
- content: "Onboarding card's up — pick your answers above.",
- sequence: 4,
- created_at: "2026-09-27T18:00:12Z",
- },
- ];
-}
diff --git a/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/onboarding-thread-reset.test.tsx b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/onboarding-thread-reset.test.tsx
new file mode 100644
index 0000000000..dd3812ea9e
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/onboarding-thread-reset.test.tsx
@@ -0,0 +1,65 @@
+import { server } from "@/mocks/mock-server";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import {
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from "@/tests/integrations/test-utils";
+import { http, HttpResponse } from "msw";
+import { expect, test, vi } from "vitest";
+import { ExpertChatDrawer } from "../ExpertChatDrawer";
+import { onboardingCard } from "./onboardingFixtures";
+
+test("an old chat creation cannot settle setup in a new thread", async () => {
+ let finishCreate = () => {};
+ const pendingCreate = new Promise<void>((resolve) => {
+ finishCreate = resolve;
+ });
+ const createSession = vi.fn(async () => {
+ await pendingCreate;
+ return HttpResponse.json({
+ id: "old-session",
+ created_at: "2026-09-29T10:00:00Z",
+ user_id: "user-1",
+ expert_id: "expert-zara",
+ });
+ });
+ server.use(
+ http.get("/api/proxy/api/experts/:expertId/onboarding", () =>
+ HttpResponse.json(onboardingCard()),
+ ),
+ http.post("/api/proxy/api/chat/sessions", createSession),
+ );
+ const props = {
+ target: {
+ expertId: "expert-zara",
+ name: "Zara",
+ role: "GTM Strategist",
+ avatarUrl: null,
+ },
+ resumeLatest: false,
+ onClose: () => {},
+ };
+ const queryClient = new QueryClient();
+ function drawer(threadKey: number) {
+ return (
+ <QueryClientProvider client={queryClient}>
+ <ExpertChatDrawer {...props} threadKey={threadKey} />
+ </QueryClientProvider>
+ );
+ }
+ const { rerender } = render(drawer(0));
+ fireEvent.click(await screen.findByRole("radio", { name: "Pricing" }));
+ fireEvent.click(screen.getByRole("button", { name: "Send answers" }));
+ await waitFor(() => expect(createSession).toHaveBeenCalledOnce());
+ rerender(drawer(1));
+ finishCreate();
+ await waitFor(() => {
+ expect(
+ (screen.getByRole("button", { name: "Skip" }) as HTMLButtonElement)
+ .disabled,
+ ).toBe(false);
+ });
+ expect(screen.getByText("Which outcome should I start with?")).toBeDefined();
+});
diff --git a/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/onboardingFixtures.ts b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/onboardingFixtures.ts
new file mode 100644
index 0000000000..055dd9e663
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/__tests__/onboardingFixtures.ts
@@ -0,0 +1,71 @@
+import type { SessionDetailResponseMessagesItem } from "@/app/api/__generated__/models/sessionDetailResponseMessagesItem";
+const EXPERT_ID = "expert-zara";
+const SESSION_ID = "session-zara";
+
+export function onboardingTurn(): SessionDetailResponseMessagesItem[] {
+ const row = {
+ tool_call_id: null,
+ tool_calls: null,
+ duration_ms: null,
+ metadata: null,
+ };
+ return [
+ {
+ ...row,
+ id: "db-1",
+ role: "user",
+ content: "Hey!",
+ sequence: 1,
+ created_at: "2026-09-27T18:00:00Z",
+ },
+ {
+ ...row,
+ id: "db-2",
+ role: "assistant",
+ content: "",
+ tool_calls: [
+ {
+ id: "call-onboarding",
+ type: "function",
+ function: { name: "expert_onboarding", arguments: "{}" },
+ },
+ ],
+ sequence: 2,
+ created_at: "2026-09-27T18:00:10Z",
+ },
+ {
+ ...row,
+ id: "db-3",
+ role: "tool",
+ tool_call_id: "call-onboarding",
+ content: JSON.stringify(onboardingCard()),
+ sequence: 3,
+ created_at: "2026-09-27T18:00:11Z",
+ },
+ {
+ ...row,
+ id: "db-4",
+ role: "assistant",
+ content: "Onboarding card's up — pick your answers above.",
+ sequence: 4,
+ created_at: "2026-09-27T18:00:12Z",
+ },
+ ];
+}
+
+export function onboardingCard() {
+ return {
+ type: "expert_onboarding",
+ message: "Which outcome should I start with?",
+ session_id: SESSION_ID,
+ expert_id: EXPERT_ID,
+ greeting: "Hi, I'm Zara.",
+ steps: [
+ {
+ question: "Which outcome should I start with?",
+ keyword: "outcome",
+ options: ["Positioning", "Pricing"],
+ },
+ ],
+ };
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/useExpertChatDrawer.ts b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/useExpertChatDrawer.ts
index 3f14444aa4..1acac4eaf2 100644
--- a/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/useExpertChatDrawer.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/team/components/ExpertChatDrawer/useExpertChatDrawer.ts
@@ -16,6 +16,16 @@ import type { ChatTarget } from "./helpers";
type UiMessages = UIMessage<unknown, UIDataTypes, UITools>[];
+class SessionStartingError extends Error {}
+
+function notifyStartFailed() {
+ toast({
+ variant: "destructive",
+ title: "Could not start the chat",
+ description: "Please try sending your message again.",
+ });
+}
+
interface Args {
target: ChatTarget | null;
isOpen: boolean;
@@ -39,6 +49,7 @@ export function useExpertChatDrawer({
const [sessionId, setSessionId] = useState<string | null>(null);
const [isCreating, setIsCreating] = useState(false);
const [skipLatest, setSkipLatest] = useState(false);
+ const [suppressOnboarding, setSuppressOnboarding] = useState(!!seedPrompt);
const pendingPromptRef = useRef<string | null>(null);
// Every thread reset bumps the generation; a session create that resolves
// for an older generation is ignored so its prompt never lands in the new
@@ -114,6 +125,7 @@ export function useExpertChatDrawer({
setMessages([]);
pendingPromptRef.current = null;
setSeedToSend(seedPrompt);
+ setSuppressOnboarding(!!seedPrompt);
}, [threadKey, seedPrompt, setMessages]);
const startSessionRef = useRef(startSession);
@@ -121,7 +133,7 @@ export function useExpertChatDrawer({
useEffect(() => {
if (!seedToSend) return;
setSeedToSend(null);
- void startSessionRef.current(seedToSend);
+ void startSessionRef.current(seedToSend).catch(notifyStartFailed);
}, [seedToSend]);
useEffect(() => {
@@ -132,6 +144,7 @@ export function useExpertChatDrawer({
}, [sessionId, sendMessage]);
function startNewThread() {
+ setSuppressOnboarding(false);
generationRef.current += 1;
creatingGenerationRef.current = null;
setIsCreating(false);
@@ -143,7 +156,12 @@ export function useExpertChatDrawer({
async function startSession(firstMessage: string) {
const generation = generationRef.current;
- if (creatingGenerationRef.current === generation || !target) return;
+ if (!target) return;
+ // A card answered while a typed prompt is still creating the session must
+ // not settle on a message that never went out, so the second send rejects.
+ if (creatingGenerationRef.current === generation) {
+ throw new SessionStartingError();
+ }
creatingGenerationRef.current = generation;
setIsCreating(true);
try {
@@ -155,15 +173,13 @@ export function useExpertChatDrawer({
throw new Error("Failed to create expert chat session");
}
pendingPromptRef.current = firstMessage;
+ setSuppressOnboarding(true);
setSessionId(response.data.id);
} catch (err) {
if (generation !== generationRef.current) return;
Sentry.captureException(err);
- toast({
- variant: "destructive",
- title: "Could not start the chat",
- description: "Please try sending your message again.",
- });
+ setSuppressOnboarding(false);
+ throw err;
} finally {
if (creatingGenerationRef.current === generation) {
creatingGenerationRef.current = null;
@@ -204,6 +220,17 @@ export function useExpertChatDrawer({
sendMessage({ text: trimmed });
}
+ // Cards fail quietly and keep their form, so this path owns the toast; the
+ // composer shows its own and restores the draft.
+ async function onActionSend(message: string) {
+ try {
+ await onSend(message);
+ } catch (err) {
+ if (!(err instanceof SessionStartingError)) notifyStartFailed();
+ throw err;
+ }
+ }
+
const isResolvingSession = !sessionId && wantsLatest && latestQuery.isLoading;
return {
@@ -214,8 +241,11 @@ export function useExpertChatDrawer({
error,
stop,
onSend,
+ onActionSend,
queuedMessages,
isResolvingSession,
+ isLoadingSession: !!sessionId && sessionQuery.isLoading,
isCreating,
+ suppressOnboarding,
};
}
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 94301c118c..fcd45af890 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -7451,6 +7451,49 @@
}
}
},
+ "/api/experts/{expert_id}/onboarding": {
+ "get": {
+ "tags": ["v2", "experts", "experts", "private"],
+ "summary": "Get Expert Onboarding",
+ "operationId": "get_expert_onboarding",
+ "security": [{ "HTTPBearerJWT": [] }],
+ "parameters": [
+ {
+ "name": "expert_id",
+ "in": "path",
+ "required": true,
+ "schema": { "type": "string", "title": "Expert Id" }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "anyOf": [
+ { "$ref": "#/components/schemas/ExpertOnboardingResponse" },
+ { "type": "null" }
+ ],
+ "title": "Response Get Expert Onboarding"
+ }
+ }
+ }
+ },
+ "401": {
+ "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+ }
+ }
+ }
+ }
+ }
+ },
"/api/experts/{expert_id}/pod": {
"patch": {
"tags": ["v2", "experts", "experts", "private"],