π OpenHands: AI-Driven Development
feat: support LLM profiles on cloud backends (#1532)
Vasco Schiavo9e787557fda0
diff --git a/__tests__/api/agent-server-conversation-service.test.ts b/__tests__/api/agent-server-conversation-service.test.tsindex 5cfa169c72..8df624ac6b 100644--- a/__tests__/api/agent-server-conversation-service.test.ts+++ b/__tests__/api/agent-server-conversation-service.test.ts@@ -818,7 +818,7 @@ describe("AgentServerConversationService", () => {expect(mockSwitchLLM).not.toHaveBeenCalled();});- it("rejects profile switching on cloud backends before any network call", async () => {+ it("routes a cloud conversation switch through the app-server switch_profile endpoint", async () => {const cloudBackend: Backend = {id: "prod",name: "Production",@@ -828,15 +828,20 @@ describe("AgentServerConversationService", () => {};setRegisteredBackends([cloudBackend]);setActiveSelection({ backendId: cloudBackend.id });+ vi.mocked(axios.request).mockReset();+ vi.mocked(axios.request).mockResolvedValue({ data: { success: true } });- await expect(- AgentServerConversationService.switchProfile("conv-1", "haiku"),- ).rejects.toThrow(- "LLM profile switching is only supported for local agent-server backends.",- );- expect(mockActivateProfile).not.toHaveBeenCalled();+ await AgentServerConversationService.switchProfile("conv-1", "haiku");++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({+ method: "POST",+ url: "https://app.all-hands.dev/api/v1/app-conversations/conv-1/switch_profile",+ data: { profile_name: "haiku" },+ });+ // Cloud resolves the swap server-side: no client-side encrypted profile+ // fetch and no direct switch_llm call.expect(mockGetProfile).not.toHaveBeenCalled();- expect(mockSwitchProfile).not.toHaveBeenCalled();expect(mockSwitchLLM).not.toHaveBeenCalled();});});diff --git a/__tests__/api/cloud/organization-me.test.ts b/__tests__/api/cloud/organization-me.test.tsindex ed785ef084..d5f47d2e8e 100644--- a/__tests__/api/cloud/organization-me.test.ts+++ b/__tests__/api/cloud/organization-me.test.ts@@ -40,6 +40,7 @@ describe("cloud organization /me", () => {user_id: orgId,email: "[email protected]",role: "owner",+ permissions: ["view_org_settings", "edit_org_settings"],},});@@ -51,6 +52,33 @@ describe("cloud organization /me", () => {method: "GET",headers: { Authorization: "Bearer bearer-token" },});- expect(result).toEqual({ orgId, userId: orgId });+ expect(result).toEqual({+ orgId,+ userId: orgId,+ role: "owner",+ permissions: ["view_org_settings", "edit_org_settings"],+ });+ });++ it("returns null permissions when the app-server omits them (older version)", async () => {+ const orgId = "0b93b5f2-5396-49f2-8d98-61f906184270";+ vi.mocked(axios.request).mockResolvedValue({+ data: {+ org_id: orgId,+ user_id: orgId,+ email: "[email protected]",+ role: "member",+ },+ });++ const result = await getCloudOrganizationMe(orgId);++ // Absent `permissions` β null, so callers fall back to the role check.+ expect(result).toEqual({+ orgId,+ userId: orgId,+ role: "member",+ permissions: null,+ });});});diff --git a/__tests__/api/cloud/profiles-service.test.ts b/__tests__/api/cloud/profiles-service.test.tsnew file mode 100644index 0000000000..8a2158b2ef--- /dev/null+++ b/__tests__/api/cloud/profiles-service.test.ts@@ -0,0 +1,200 @@+import axios from "axios";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import {+ __resetActiveStoreForTests,+ setActiveSelection,+ setRegisteredBackends,+} from "#/api/backend-registry/active-store";+import type { Backend } from "#/api/backend-registry/types";+import ProfilesService, {+ type SaveProfileRequest,+} from "#/api/profiles-service/profiles-service.api";++vi.mock("axios");++const cloudBackend: Backend = {+ id: "prod",+ name: "Production",+ host: "https://app.all-hands.dev",+ apiKey: "bearer-token",+ kind: "cloud",+};++const ORG_ID = "org-1";+const ORG_BASE = `https://app.all-hands.dev/api/organizations/${ORG_ID}/profiles`;+const SETTINGS_BASE = "https://app.all-hands.dev/api/v1/settings/profiles";++beforeEach(() => {+ window.localStorage.clear();+ __resetActiveStoreForTests();+ setRegisteredBackends([cloudBackend]);+ vi.mocked(axios.request).mockReset();+});++afterEach(() => {+ window.localStorage.clear();+ __resetActiveStoreForTests();+});++// With an org bound, profile CRUD goes through the org-gated routes so the+// server enforces EDIT_ORG_SETTINGS (a member's mutation 403s, not just hidden).+describe("ProfilesService against a cloud org (gated org routes)", () => {+ beforeEach(() => {+ setActiveSelection({ backendId: cloudBackend.id, orgId: ORG_ID });+ });++ it("lists profiles via GET /api/organizations/{orgId}/profiles", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: {+ profiles: [+ { name: "gpt", model: "gpt-4o", base_url: null, api_key_set: true },+ ],+ active_profile: "gpt",+ },+ });++ const res = await ProfilesService.listProfiles();++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({+ method: "GET",+ url: ORG_BASE,+ headers: { Authorization: "Bearer bearer-token" },+ });+ expect(res.active_profile).toBe("gpt");+ });++ it("fetches a profile and maps the org `llm` onto `config`", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: { name: "my profile", llm: { model: "gpt-4o", api_key: null } },+ });++ const res = await ProfilesService.getProfile("my profile");++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({+ method: "GET",+ url: `${ORG_BASE}/my%20profile`,+ });+ expect(res).toEqual({+ name: "my profile",+ config: { model: "gpt-4o", api_key: null },+ api_key_set: false,+ });+ });++ it("saves a profile via POST .../{name} forwarding the request body", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: { name: "gpt", message: "Profile 'gpt' saved" },+ });++ await ProfilesService.saveProfile("gpt", {+ llm: { model: "gpt-4o" } as SaveProfileRequest["llm"],+ include_secrets: true,+ });++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({+ method: "POST",+ url: `${ORG_BASE}/gpt`,+ data: { llm: { model: "gpt-4o" }, include_secrets: true },+ });+ });++ it("deletes a profile via DELETE .../{name}", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: { name: "gpt", message: "Profile 'gpt' deleted" },+ });++ await ProfilesService.deleteProfile("gpt");++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({ method: "DELETE", url: `${ORG_BASE}/gpt` });+ });++ it("renames a profile via POST .../{name}/rename with new_name", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: { name: "new", message: "renamed" },+ });++ await ProfilesService.renameProfile("old", "new");++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({+ method: "POST",+ url: `${ORG_BASE}/old/rename`,+ data: { new_name: "new" },+ });+ });++ it("activates a profile and maps the org `llm` onto `llm_applied`", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: {+ name: "gpt",+ message: "Switched to profile 'gpt'",+ llm: { model: "gpt-4o" },+ },+ });++ const res = await ProfilesService.activateProfile("gpt");++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({+ method: "POST",+ url: `${ORG_BASE}/gpt/activate`,+ });+ expect(res).toEqual({+ name: "gpt",+ message: "Switched to profile 'gpt'",+ llm_applied: true,+ });+ });+});++// Legacy API keys have no org bound; CRUD falls back to the per-user settings+// route (ungated β there is no org role to enforce against).+describe("ProfilesService on a cloud backend with no org (fallback)", () => {+ beforeEach(() => {+ setActiveSelection({ backendId: cloudBackend.id });+ });++ it("lists via the per-user settings route", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: { profiles: [], active_profile: null },+ });++ await ProfilesService.listProfiles();++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({ method: "GET", url: SETTINGS_BASE });+ });++ it("saves via the per-user settings route", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: { name: "gpt", message: "saved" },+ });++ await ProfilesService.saveProfile("gpt", {+ llm: { model: "gpt-4o" } as SaveProfileRequest["llm"],+ include_secrets: true,+ });++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({ method: "POST", url: `${SETTINGS_BASE}/gpt` });+ });++ it("activates via the per-user settings route and maps `model`", async () => {+ vi.mocked(axios.request).mockResolvedValueOnce({+ data: { name: "gpt", message: "ok", model: "gpt-4o" },+ });++ const res = await ProfilesService.activateProfile("gpt");++ const [cfg] = vi.mocked(axios.request).mock.calls[0]!;+ expect(cfg).toMatchObject({+ method: "POST",+ url: `${SETTINGS_BASE}/gpt/activate`,+ });+ expect(res.llm_applied).toBe(true);+ });+});diff --git a/__tests__/components/backends/backend-selector.test.tsx b/__tests__/components/backends/backend-selector.test.tsxindex e0dff14d72..784cd01c46 100644--- a/__tests__/components/backends/backend-selector.test.tsx+++ b/__tests__/components/backends/backend-selector.test.tsx@@ -111,6 +111,7 @@ beforeEach(() => {vi.mocked(getCloudOrganizationMe).mockResolvedValue({orgId: "",userId: "",+ role: null,});// Default to the legacy-key fallback so existing assertions about// multiple orgs being visible still hold. Tests that exercise@@ -310,6 +311,7 @@ describe("BackendSelector", () => {vi.mocked(getCloudOrganizationMe).mockImplementation(async (orgId) => ({orgId,userId: orgId === personalOrgId ? personalOrgId : "some-user",+ role: null,}));renderWithProviders(@@ -351,6 +353,7 @@ describe("BackendSelector", () => {vi.mocked(getCloudOrganizationMe).mockResolvedValue({orgId: personalOrgId,userId: personalOrgId,+ role: null,});let cloudId = "";diff --git a/__tests__/components/backends/manage-backends-modal.test.tsx b/__tests__/components/backends/manage-backends-modal.test.tsxindex f8e25e8cca..a4c214f2bf 100644--- a/__tests__/components/backends/manage-backends-modal.test.tsx+++ b/__tests__/components/backends/manage-backends-modal.test.tsx@@ -102,6 +102,7 @@ beforeEach(() => {vi.mocked(getCloudOrganizationMe).mockResolvedValue({orgId: "",userId: "",+ role: null,});vi.mocked(getCurrentCloudApiKey).mockReset();vi.mocked(getCurrentCloudApiKey).mockResolvedValue({@@ -433,6 +434,7 @@ describe("ManageBackendsModal", () => {vi.mocked(getCloudOrganizationMe).mockResolvedValue({orgId: personalOrgId,userId: personalOrgId,+ role: null,});renderWithProviders(diff --git a/__tests__/components/features/chat/components/chat-input-actions.test.tsx b/__tests__/components/features/chat/components/chat-input-actions.test.tsxindex 050121ca86..7c137c7756 100644--- a/__tests__/components/features/chat/components/chat-input-actions.test.tsx+++ b/__tests__/components/features/chat/components/chat-input-actions.test.tsx@@ -100,7 +100,7 @@ describe("ChatInputActions", () => {).not.toBeInTheDocument();});- it("renders the active conversation model on a cloud backend", () => {+ it("renders the SwitchProfileButton on a cloud backend", () => {setRegisteredBackends([cloudBackend]);setActiveSelection({ backendId: cloudBackend.id });useActiveConversationMock.mockReturnValue({@@ -113,15 +113,17 @@ describe("ChatInputActions", () => {</ActiveBackendProvider>,);- expect(screen.getByTestId("chat-input-llm-model")).toHaveTextContent(- "gpt-4o",- );+ // Cloud now manages the LLM through profiles, so the composer shows the+ // profile switcher (same as local), not the static cloud model label.expect(- screen.queryByTestId("switch-profile-button-stub"),+ screen.getByTestId("switch-profile-button-stub"),+ ).toBeInTheDocument();+ expect(+ screen.queryByTestId("chat-input-llm-model"),).not.toBeInTheDocument();});- it("omits the model label on cloud when the active conversation has no llm_model", () => {+ it("renders the SwitchProfileButton on cloud even when the conversation has no llm_model", () => {setRegisteredBackends([cloudBackend]);setActiveSelection({ backendId: cloudBackend.id });useActiveConversationMock.mockReturnValue({@@ -134,11 +136,42 @@ describe("ChatInputActions", () => {</ActiveBackendProvider>,);+ expect(+ screen.getByTestId("switch-profile-button-stub"),+ ).toBeInTheDocument();expect(screen.queryByTestId("chat-input-llm-model"),).not.toBeInTheDocument();});+ it("renders the static model label for cloud ACP conversations", () => {+ setRegisteredBackends([cloudBackend]);+ setActiveSelection({ backendId: cloudBackend.id });+ useActiveConversationMock.mockReturnValue({+ data: {+ conversation_id: "test-conversation-id",+ agent_kind: "acp",+ llm_model: "claude-sonnet-4-6",+ },+ });++ renderWithProviders(+ <ActiveBackendProvider>+ <ChatInputActions disabled={false} />+ </ActiveBackendProvider>,+ );++ // ACP conversations keep the static model label on cloud too β the switch+ // gate is now driven solely by isAcpContext, not the backend kind.+ expect(screen.getByTestId("chat-input-llm-model")).toHaveAttribute(+ "title",+ "claude-sonnet-4-6",+ );+ expect(+ screen.queryByTestId("switch-profile-button-stub"),+ ).not.toBeInTheDocument();+ });+it("hides the Change Agent button on a local backend", () => {renderWithProviders(<ChatInputActions disabled={false} />);@@ -171,8 +204,6 @@ describe("ChatInputActions", () => {{ navigation: { conversationId: null } },);- expect(- screen.getByTestId("change-agent-button-stub"),- ).toBeInTheDocument();+ expect(screen.getByTestId("change-agent-button-stub")).toBeInTheDocument();});});diff --git a/__tests__/components/settings/llm-profiles/profile-row.test.tsx b/__tests__/components/settings/llm-profiles/profile-row.test.tsxindex ec0b8a107b..f8d68292fc 100644--- a/__tests__/components/settings/llm-profiles/profile-row.test.tsx+++ b/__tests__/components/settings/llm-profiles/profile-row.test.tsx@@ -8,12 +8,12 @@ vi.mock("react-i18next", () => ({useTranslation: () => ({t: (key: string) => {const translations: Record<string, string> = {- "SETTINGS$PROFILE_ACTIVE": "Active",- "SETTINGS$PROFILE_MENU": "Profile menu",- "SETTINGS$PROFILE_EDIT": "Edit",- "BUTTON$RENAME": "Rename",- "SETTINGS$PROFILE_SET_ACTIVE": "Set as active",- "BUTTON$DELETE": "Delete",+ SETTINGS$PROFILE_ACTIVE: "Active",+ SETTINGS$PROFILE_MENU: "Profile menu",+ SETTINGS$PROFILE_EDIT: "Edit",+ BUTTON$RENAME: "Rename",+ SETTINGS$PROFILE_SET_ACTIVE: "Set as active",+ BUTTON$DELETE: "Delete",};return translations[key] || key;},@@ -30,6 +30,7 @@ const mockProfile: ProfileInfo = {const defaultProps = {profile: mockProfile,isActive: false,+ canManage: true,onActivate: vi.fn(),onEdit: vi.fn(),onRename: vi.fn(),@@ -72,7 +73,19 @@ describe("ProfileRow", () => {it("does not show Active badge when isActive is false", () => {render(<ProfileRow {...defaultProps} isActive={false} />);- expect(screen.queryByTestId("profile-active-badge")).not.toBeInTheDocument();+ expect(+ screen.queryByTestId("profile-active-badge"),+ ).not.toBeInTheDocument();+ });++ it("hides the actions menu when canManage is false (view-only members)", () => {+ render(<ProfileRow {...defaultProps} canManage={false} />);++ // The row still shows the profile, but offers no mutate actions.+ expect(screen.getByText("gpt-4-profile")).toBeInTheDocument();+ expect(+ screen.queryByTestId("profile-menu-trigger"),+ ).not.toBeInTheDocument();});it("opens menu when trigger button is clicked", async () => {@@ -95,10 +108,10 @@ describe("ProfileRow", () => {render(<ProfileRow {...defaultProps} />);const menuTrigger = screen.getByTestId("profile-menu-trigger");-+// Menu should be closed initiallyexpect(screen.queryByText("Edit")).not.toBeInTheDocument();-+// First click opens the menuawait user.click(menuTrigger);expect(screen.getByText("Edit")).toBeInTheDocument();diff --git a/__tests__/components/settings/llm-profiles/profiles-body.test.tsx b/__tests__/components/settings/llm-profiles/profiles-body.test.tsxindex 1aa41673c3..e05edbdad5 100644--- a/__tests__/components/settings/llm-profiles/profiles-body.test.tsx+++ b/__tests__/components/settings/llm-profiles/profiles-body.test.tsx@@ -7,14 +7,14 @@ vi.mock("react-i18next", () => ({useTranslation: () => ({t: (key: string) => {const translations: Record<string, string> = {- "SETTINGS$PROFILES_LOAD_ERROR": "Failed to load profiles",- "SETTINGS$PROFILES_EMPTY": "No profiles saved yet",- "SETTINGS$PROFILE_ACTIVE": "Active",- "SETTINGS$PROFILE_MENU": "Profile menu",- "SETTINGS$PROFILE_EDIT": "Edit",- "BUTTON$RENAME": "Rename",- "SETTINGS$PROFILE_SET_ACTIVE": "Set as active",- "BUTTON$DELETE": "Delete",+ SETTINGS$PROFILES_LOAD_ERROR: "Failed to load profiles",+ SETTINGS$PROFILES_EMPTY: "No profiles saved yet",+ SETTINGS$PROFILE_ACTIVE: "Active",+ SETTINGS$PROFILE_MENU: "Profile menu",+ SETTINGS$PROFILE_EDIT: "Edit",+ BUTTON$RENAME: "Rename",+ SETTINGS$PROFILE_SET_ACTIVE: "Set as active",+ BUTTON$DELETE: "Delete",};return translations[key] || key;},@@ -41,6 +41,7 @@ const defaultProps = {loadError: null,profiles: mockProfiles,active: "gpt-4-profile",+ canManage: true,onActivate: vi.fn(),onEdit: vi.fn(),onRename: vi.fn(),@@ -109,7 +110,9 @@ describe("ProfilesBody", () => {);expect(screen.getByTestId("loading-spinner")).toBeInTheDocument();- expect(screen.queryByText("Failed to load profiles")).not.toBeInTheDocument();+ expect(+ screen.queryByText("Failed to load profiles"),+ ).not.toBeInTheDocument();});it("error state takes priority over empty state", () => {diff --git a/__tests__/hooks/chat/use-model-interceptor.test.tsx b/__tests__/hooks/chat/use-model-interceptor.test.tsxindex 5ce8a6a5f3..b0292c4397 100644--- a/__tests__/hooks/chat/use-model-interceptor.test.tsx+++ b/__tests__/hooks/chat/use-model-interceptor.test.tsx@@ -151,7 +151,7 @@ describe("useModelInterceptor", () => {expect(mockSwitchAndLog).not.toHaveBeenCalled();});- it("falls through on cloud backends", () => {+ it("intercepts on cloud backends (cloud also manages the LLM via profiles)", () => {setRegisteredBackends([cloudBackend]);setActiveSelection({ backendId: cloudBackend.id });const onSubmit = vi.fn();@@ -163,8 +163,8 @@ describe("useModelInterceptor", () => {act(() => result.current("/model haiku"));- expect(onSubmit).toHaveBeenCalledWith("/model haiku");- expect(mockSwitchAndLog).not.toHaveBeenCalled();+ expect(mockSwitchAndLog).toHaveBeenCalledWith(CONVERSATION_ID, "haiku");+ expect(onSubmit).not.toHaveBeenCalled();});it("activates the named profile globally even when no conversation is set", () => {diff --git a/__tests__/hooks/use-can-manage-llm-profiles.test.tsx b/__tests__/hooks/use-can-manage-llm-profiles.test.tsxnew file mode 100644index 0000000000..dbf48d4c92--- /dev/null+++ b/__tests__/hooks/use-can-manage-llm-profiles.test.tsx@@ -0,0 +1,111 @@+import React from "react";+import { renderHook, waitFor } from "@testing-library/react";+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import { beforeEach, describe, expect, it, vi } from "vitest";+import { useCanManageLlmProfiles } from "#/hooks/use-can-manage-llm-profiles";+import * as orgService from "#/api/cloud/organization-service.api";+import * as activeBackendContext from "#/contexts/active-backend-context";+import type { Backend } from "#/api/backend-registry/types";++vi.mock("#/api/cloud/organization-service.api");++const localBackend: Backend = {+ id: "local",+ name: "Local",+ host: "http://localhost:8000",+ apiKey: "",+ kind: "local",+};++const cloudBackend: Backend = {+ id: "prod",+ name: "Production",+ host: "https://app.all-hands.dev",+ apiKey: "bearer-token",+ kind: "cloud",+};++function wrapper({ children }: { children: React.ReactNode }) {+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false } },+ });+ return (+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>+ );+}++function mockBackend(backend: Backend, orgId: string | null) {+ vi.spyOn(activeBackendContext, "useActiveBackend").mockReturnValue({+ backend,+ orgId,+ });+}++describe("useCanManageLlmProfiles", () => {+ beforeEach(() => {+ vi.restoreAllMocks();+ });++ it("is always true on local backends (no /me call)", () => {+ mockBackend(localBackend, null);+ const { result } = renderHook(() => useCanManageLlmProfiles(), { wrapper });+ expect(result.current).toBe(true);+ expect(orgService.getCloudOrganizationMe).not.toHaveBeenCalled();+ });++ it("uses the server permission and ignores the role (permission grants)", async () => {+ mockBackend(cloudBackend, "org-1");+ // Role says member, but the permission set grants edit β permission wins.+ vi.mocked(orgService.getCloudOrganizationMe).mockResolvedValue({+ orgId: "org-1",+ userId: "u",+ role: "member",+ permissions: ["view_org_settings", "edit_org_settings"],+ });+ const { result } = renderHook(() => useCanManageLlmProfiles(), { wrapper });+ await waitFor(() => expect(result.current).toBe(true));+ });++ it("uses the server permission and ignores the role (permission denies)", async () => {+ mockBackend(cloudBackend, "org-1");+ // Role says owner, but the permission set lacks edit β permission wins.+ vi.mocked(orgService.getCloudOrganizationMe).mockResolvedValue({+ orgId: "org-1",+ userId: "u",+ role: "owner",+ permissions: ["view_org_settings"],+ });+ const { result } = renderHook(() => useCanManageLlmProfiles(), { wrapper });+ await waitFor(() =>+ expect(orgService.getCloudOrganizationMe).toHaveBeenCalled(),+ );+ expect(result.current).toBe(false);+ });++ it("falls back to the role when the app-server omits permissions", async () => {+ mockBackend(cloudBackend, "org-1");+ vi.mocked(orgService.getCloudOrganizationMe).mockResolvedValue({+ orgId: "org-1",+ userId: "u",+ role: "admin",+ permissions: null,+ });+ const { result } = renderHook(() => useCanManageLlmProfiles(), { wrapper });+ await waitFor(() => expect(result.current).toBe(true));+ });++ it("falls back to deny for a member when permissions are absent", async () => {+ mockBackend(cloudBackend, "org-1");+ vi.mocked(orgService.getCloudOrganizationMe).mockResolvedValue({+ orgId: "org-1",+ userId: "u",+ role: "member",+ permissions: null,+ });+ const { result } = renderHook(() => useCanManageLlmProfiles(), { wrapper });+ await waitFor(() =>+ expect(orgService.getCloudOrganizationMe).toHaveBeenCalled(),+ );+ expect(result.current).toBe(false);+ });+});diff --git a/__tests__/routes/llm-settings.test.tsx b/__tests__/routes/llm-settings.test.tsxindex a725a37291..2b4aff98bd 100644--- a/__tests__/routes/llm-settings.test.tsx+++ b/__tests__/routes/llm-settings.test.tsx@@ -14,6 +14,11 @@ import * as useLlmProfilesHook from "#/hooks/query/use-llm-profiles";import LLMSubscriptionService from "#/api/llm-subscription-service";vi.mock("#/hooks/query/use-llm-profiles");+// The profile manager gates mutate controls on this hook; default to a user+// who can manage so the manager renders its full (editable) surface.+vi.mock("#/hooks/use-can-manage-llm-profiles", () => ({+ useCanManageLlmProfiles: () => true,+}));function buildSettings(overrides: Partial<Settings> = {}): Settings {return {@@ -171,9 +176,8 @@ describe("LlmSettingsScreen", () => {await waitFor(() => expect(saveSettingsSpy).toHaveBeenCalled());const payload = saveSettingsSpy.mock.calls[0][0] as Record<string, unknown>;- const llmPayload = (- payload.agent_settings_diff as Record<string, unknown>- ).llm as Record<string, unknown>;+ const llmPayload = (payload.agent_settings_diff as Record<string, unknown>)+ .llm as Record<string, unknown>;expect(llmPayload.api_key).toBe("test-api-key");expect(llmPayload).not.toHaveProperty("base_url");});@@ -363,7 +367,7 @@ describe("LlmSettingsRoute - backend mode rendering", () => {expect(screen.getByTestId("add-llm-profile")).toBeInTheDocument();});- it("renders standard LlmSettingsScreen (no profiles) for cloud backends", async () => {+ it("renders LlmSettingsLocalView (profile manager) for cloud backends", async () => {vi.spyOn(activeBackendContext, "useActiveBackend").mockReturnValue({backend: mockCloudBackend,orgId: "org-123",@@ -386,11 +390,10 @@ describe("LlmSettingsRoute - backend mode rendering", () => {renderLlmSettingsRoute();- // Cloud mode shows the standard LLM settings form (not profile manager)- await screen.findByTestId("llm-settings-screen");- expect(screen.getByTestId("llm-settings-screen")).toBeInTheDocument();-- // Should NOT show the "Add LLM Profile" button- expect(screen.queryByTestId("add-llm-profile")).not.toBeInTheDocument();+ // Cloud now manages the LLM through profiles too (app-server+ // /api/v1/settings/profiles), so the route renders the profile manager+ // β same view as local β rather than the plain settings form.+ await screen.findByTestId("add-llm-profile");+ expect(screen.getByTestId("add-llm-profile")).toBeInTheDocument();});});diff --git a/src/api/cloud/organization-service.api.ts b/src/api/cloud/organization-service.api.tsindex 64329e8bdf..9d4fa54033 100644--- a/src/api/cloud/organization-service.api.ts+++ b/src/api/cloud/organization-service.api.ts@@ -88,13 +88,29 @@ export async function getCurrentCloudApiKey(* whether `orgId` is the user's personal workspace β that's the cloud* contract (the auto-generated personal-workspace org has the same id as* the user).+ *+ * `role` is the caller's role in the org (`owner` | `admin` | `member`, or+ * `null` if the upstream omits it). `permissions` is the server-defined+ * permission set for that role (e.g. `edit_org_settings`); it is `null` on+ * older app-servers that don't return it, so callers fall back to the role.+ * See `useCanManageLlmProfiles`.*/export async function getCloudOrganizationMe(orgId: string,backend?: Backend,-): Promise<{ orgId: string; userId: string }> {+): Promise<{+ orgId: string;+ userId: string;+ role: string | null;+ permissions?: string[] | null;+}> {const target = resolveBackend(backend);- const data = await callCloudProxy<{ org_id: string; user_id: string }>({+ const data = await callCloudProxy<{+ org_id: string;+ user_id: string;+ role?: string;+ permissions?: string[];+ }>({backend: target,method: "GET",path: `/api/organizations/${encodeURIComponent(orgId)}/me`,@@ -102,5 +118,9 @@ export async function getCloudOrganizationMe(return {orgId: data?.org_id ?? orgId,userId: data?.user_id ?? "",+ role: data?.role ?? null,+ // `null` when the field is absent (older app-server) so callers can fall+ // back to a role check; a present array is the server's source of truth.+ permissions: Array.isArray(data?.permissions) ? data.permissions : null,};}diff --git a/src/api/cloud/profiles-service.api.ts b/src/api/cloud/profiles-service.api.tsnew file mode 100644index 0000000000..73758b918f--- /dev/null+++ b/src/api/cloud/profiles-service.api.ts@@ -0,0 +1,140 @@+import type {+ ActivateProfileResponse,+ ProfileDetailResponse,+ ProfileListResponse,+ ProfileMutationResponse,+ SaveProfileRequest,+} from "@openhands/typescript-client";+import { getActiveBackend } from "../backend-registry/active-store";+import type { Backend } from "../backend-registry/types";+import { callCloudProxy } from "./proxy";++/**+ * Cloud LLM-profile service.+ *+ * Profile CRUD is routed to the org-scoped endpoints+ * `/api/organizations/{orgId}/profiles`, which enforce `EDIT_ORG_SETTINGS`+ * server-side β so a member's mutation is rejected with 403 even on a direct+ * API call, not just hidden in the UI. When the active cloud backend has no org+ * bound (legacy API keys), we fall back to the ungated per-user settings route+ * `/api/v1/settings/profiles`, where there is no org role to enforce against.+ *+ * The two routes share shapes except `get` (org returns `llm`, settings returns+ * `config`) and `activate` (org returns `llm`, settings returns `model`); both+ * are normalized to the SDK profile types below. Neither route exposes secrets.+ */++const SETTINGS_PROFILES_PATH = "/api/v1/settings/profiles";++/**+ * Resolve the backend + base path for the active cloud backend's profiles:+ * the org-gated route when an org is bound, else the per-user settings route.+ */+function cloudProfilesTarget(): { backend: Backend; base: string } {+ const { backend, orgId } = getActiveBackend();+ if (backend.kind !== "cloud") {+ throw new Error("Cloud profiles call requires a cloud backend.");+ }+ return {+ backend,+ base: orgId+ ? `/api/organizations/${encodeURIComponent(orgId)}/profiles`+ : SETTINGS_PROFILES_PATH,+ };+}++export async function fetchCloudProfiles(): Promise<ProfileListResponse> {+ const { backend, base } = cloudProfilesTarget();+ return callCloudProxy<ProfileListResponse>({+ backend,+ method: "GET",+ path: base,+ });+}++export async function fetchCloudProfile(+ name: string,+): Promise<ProfileDetailResponse> {+ const { backend, base } = cloudProfilesTarget();+ // Org returns `{ name, llm }`; settings returns `{ name, config, api_key_set }`.+ // Normalize to the SDK detail shape. Neither route exposes the key, and the+ // GUI never reads the detail's `api_key_set` (only list-item `api_key_set`).+ const result = await callCloudProxy<{+ name: string;+ config?: Record<string, unknown>;+ llm?: Record<string, unknown>;+ api_key_set?: boolean;+ }>({+ backend,+ method: "GET",+ path: `${base}/${encodeURIComponent(name)}`,+ });+ return {+ name: result.name,+ config: result.config ?? result.llm ?? {},+ api_key_set: result.api_key_set ?? false,+ };+}++export async function saveCloudProfile(+ name: string,+ request: SaveProfileRequest,+): Promise<ProfileMutationResponse> {+ const { backend, base } = cloudProfilesTarget();+ return callCloudProxy<ProfileMutationResponse>({+ backend,+ method: "POST",+ path: `${base}/${encodeURIComponent(name)}`,+ body: request,+ });+}++export async function deleteCloudProfile(+ name: string,+): Promise<ProfileMutationResponse> {+ const { backend, base } = cloudProfilesTarget();+ return callCloudProxy<ProfileMutationResponse>({+ backend,+ method: "DELETE",+ path: `${base}/${encodeURIComponent(name)}`,+ });+}++export async function renameCloudProfile(+ name: string,+ newName: string,+): Promise<ProfileMutationResponse> {+ const { backend, base } = cloudProfilesTarget();+ return callCloudProxy<ProfileMutationResponse>({+ backend,+ method: "POST",+ path: `${base}/${encodeURIComponent(name)}/rename`,+ body: { new_name: newName },+ });+}++export async function activateCloudProfile(+ name: string,+): Promise<ActivateProfileResponse> {+ const { backend, base } = cloudProfilesTarget();+ // Org returns `{ name, message, llm }`; settings returns `{ name, message,+ // model }`. The SDK type carries `llm_applied`; derive it from whichever the+ // route provided (consumers only read name/message β the hook just+ // invalidates caches).+ const result = await callCloudProxy<{+ name: string;+ message: string;+ model?: string | null;+ llm?: Record<string, unknown> | null;+ }>({+ backend,+ method: "POST",+ path: `${base}/${encodeURIComponent(name)}/activate`,+ body: {},+ });+ return {+ name: result.name,+ message: result.message,+ llm_applied: result.model != null || result.llm != null,+ };+}diff --git a/src/api/conversation-service/agent-server-conversation-service.api.ts b/src/api/conversation-service/agent-server-conversation-service.api.tsindex 8ee737d268..fdd8ce71c7 100644--- a/src/api/conversation-service/agent-server-conversation-service.api.ts+++ b/src/api/conversation-service/agent-server-conversation-service.api.ts@@ -22,6 +22,7 @@ import {getEffectiveLocalBackend,} from "../backend-registry/active-store";import { callCloudProxy } from "../cloud/proxy";+import ProfilesService from "../profiles-service/profiles-service.api";import {batchGetCloudConversations,createCloudAppConversation,@@ -684,15 +685,34 @@ class AgentServerConversationService {* The per-conversation endpoint accepts only the profile name, so the UI does* not need to fetch or forward profile secrets. That keeps switching working* even when the agent server has no OH_SECRET_KEY for encrypted secret export.+ *+ * Cloud backends route to the app-server's per-conversation+ * `/switch_profile`, which owns the profiles and resolves the swap+ * server-side (base_url/api_key fixups, usage_id derivation, then the+ * agent-server's switch_llm) β so the client only forwards the profile name,+ * mirroring {@link switchAcpModel}.*/static async switchProfile(conversationId: string | null,profileName: string,): Promise<void> {- if (getActiveBackend().backend.kind === "cloud") {- throw new Error(- "LLM profile switching is only supported for local agent-server backends.",- );+ const { backend } = getActiveBackend();++ if (backend.kind === "cloud") {+ // No conversation (home page): activate globally so the next+ // conversation starts with it. ProfilesService routes to the cloud+ // activate endpoint.+ if (!conversationId) {+ await ProfilesService.activateProfile(profileName);+ return;+ }+ await callCloudProxy({+ backend,+ method: "POST",+ path: `/api/v1/app-conversations/${conversationId}/switch_profile`,+ body: { profile_name: profileName },+ });+ return;}if (!conversationId) {diff --git a/src/api/profiles-service/profiles-service.api.ts b/src/api/profiles-service/profiles-service.api.tsindex 788f2b0ba4..7253242063 100644--- a/src/api/profiles-service/profiles-service.api.ts+++ b/src/api/profiles-service/profiles-service.api.ts@@ -1,6 +1,12 @@/**- * ProfilesService provides a thin wrapper around the SDK's ProfilesClient,- * creating a client per-call to pick up current backend configuration.+ * ProfilesService is the single entry point for LLM-profile CRUD, routing per+ * active backend so callers (hooks, the settings manager) stay backend-agnostic:+ * - local agent-server: the SDK's ProfilesClient (`/api/profiles`), created+ * per-call to pick up current backend configuration;+ * - cloud app-server: `src/api/cloud/profiles-service.api.ts` (the org-gated+ * `/api/organizations/{orgId}/profiles` routes, or the per-user settings+ * route as a fallback) via the org-scoped cloud proxy.+ * This mirrors how SettingsService branches to fetchCloudSettings().** Uses ProfilesClient from @openhands/typescript-client v0.2.0+.* All types are re-exported from the SDK for consumer convenience.@@ -24,6 +30,15 @@ import type {ExposeSecretsMode,} from "@openhands/typescript-client";import { getAgentServerClientOptions } from "../agent-server-client-options";+import { getActiveBackend } from "../backend-registry/active-store";+import {+ activateCloudProfile,+ deleteCloudProfile,+ fetchCloudProfile,+ fetchCloudProfiles,+ renameCloudProfile,+ saveCloudProfile,+} from "../cloud/profiles-service.api";// Re-export SDK types for consumersexport type {@@ -36,8 +51,13 @@ export type {ExposeSecretsMode,};+function isCloudBackend(): boolean {+ return getActiveBackend().backend.kind === "cloud";+}+class ProfilesService {static async listProfiles(): Promise<ProfileListResponse> {+ if (isCloudBackend()) return fetchCloudProfiles();return new ProfilesClient(getAgentServerClientOptions()).listProfiles();}@@ -45,6 +65,9 @@ class ProfilesService {name: string,exposeSecrets?: ExposeSecretsMode,): Promise<ProfileDetailResponse> {+ // Cloud never exposes profile secrets (api_key is always nulled with an+ // api_key_set flag), so `exposeSecrets` is local-only.+ if (isCloudBackend()) return fetchCloudProfile(name);const options: GetProfileOptions = exposeSecrets ? { exposeSecrets } : {};return new ProfilesClient(getAgentServerClientOptions()).getProfile(name,@@ -56,6 +79,7 @@ class ProfilesService {name: string,request: SaveProfileRequest,): Promise<ProfileMutationResponse> {+ if (isCloudBackend()) return saveCloudProfile(name, request);return new ProfilesClient(getAgentServerClientOptions()).saveProfile(name,request,@@ -63,6 +87,7 @@ class ProfilesService {}static async deleteProfile(name: string): Promise<ProfileMutationResponse> {+ if (isCloudBackend()) return deleteCloudProfile(name);return new ProfilesClient(getAgentServerClientOptions()).deleteProfile(name,);@@ -72,6 +97,7 @@ class ProfilesService {name: string,newName: string,): Promise<ProfileMutationResponse> {+ if (isCloudBackend()) return renameCloudProfile(name, newName);return new ProfilesClient(getAgentServerClientOptions()).renameProfile(name,newName,@@ -79,6 +105,7 @@ class ProfilesService {}static async activateProfile(name: string): Promise<ActivateProfileResponse> {+ if (isCloudBackend()) return activateCloudProfile(name);return new ProfilesClient(getAgentServerClientOptions()).activateProfile(name,);diff --git a/src/components/features/chat/components/chat-input-actions.tsx b/src/components/features/chat/components/chat-input-actions.tsxindex 4ba20ea290..78f0f774e9 100644--- a/src/components/features/chat/components/chat-input-actions.tsx+++ b/src/components/features/chat/components/chat-input-actions.tsx@@ -406,7 +406,7 @@ export function ChatInputActions({</div>)}<div ref={modelRef} className={cn(!showModelInline && "hidden")}>- {isCloud || modelState.isAcpContext ? (+ {modelState.isAcpContext ? (<ChatInputModel />) : (<SwitchProfileButton />diff --git a/src/components/features/settings/llm-profiles/llm-profiles-manager.tsx b/src/components/features/settings/llm-profiles/llm-profiles-manager.tsxindex 5a0a9e545a..f04f3e6862 100644--- a/src/components/features/settings/llm-profiles/llm-profiles-manager.tsx+++ b/src/components/features/settings/llm-profiles/llm-profiles-manager.tsx@@ -11,6 +11,7 @@ import ProfilesService, {import { useLlmProfiles } from "#/hooks/query/use-llm-profiles";import { useActivateLlmProfile } from "#/hooks/mutation/use-activate-llm-profile";import { useSaveLlmProfile } from "#/hooks/mutation/use-save-llm-profile";+import { useCanManageLlmProfiles } from "#/hooks/use-can-manage-llm-profiles";import {displayErrorToast,displaySuccessToast,@@ -30,6 +31,9 @@ export function LlmProfilesManager({const { data, isLoading, error } = useLlmProfiles();const activateProfile = useActivateLlmProfile();const saveProfile = useSaveLlmProfile();+ // Cloud members are view-only; only owners/admins (and all local users) may+ // add, edit, rename, duplicate, delete, or activate profiles.+ const canManage = useCanManageLlmProfiles();const [profileToRename, setProfileToRename] = useState<ProfileInfo | null>(null,);@@ -96,7 +100,7 @@ export function LlmProfilesManager({<h2 className="text-base font-medium text-white">{t(I18nKey.SETTINGS$AVAILABLE_PROFILES)}</h2>- {onAddProfile ? (+ {onAddProfile && canManage ? (<BrandButtontestId="add-llm-profile"type="button"@@ -114,6 +118,7 @@ export function LlmProfilesManager({loadError={error ?? null}profiles={profiles}active={active}+ canManage={canManage}onActivate={handleActivate}onEdit={handleEdit}onRename={setProfileToRename}diff --git a/src/components/features/settings/llm-profiles/profile-row.tsx b/src/components/features/settings/llm-profiles/profile-row.tsxindex 9efa971f8f..d3b29d5974 100644--- a/src/components/features/settings/llm-profiles/profile-row.tsx+++ b/src/components/features/settings/llm-profiles/profile-row.tsx@@ -14,6 +14,8 @@ import {interface ProfileRowProps {profile: ProfileInfo;isActive: boolean;+ /** When false, the row is read-only and the actions menu is hidden. */+ canManage: boolean;onActivate: (name: string) => void;onEdit: (profile: ProfileInfo) => void;onRename: (profile: ProfileInfo) => void;@@ -25,6 +27,7 @@ interface ProfileRowProps {export function ProfileRow({profile,isActive,+ canManage,onActivate,onEdit,onRename,@@ -65,28 +68,30 @@ export function ProfileRow({</BrandBadge>)}</div>- <div className="relative shrink-0">- <EllipsisButton- ref={triggerRef}- onClick={() => setMenuOpen((open) => !open)}- ariaLabel={t(I18nKey.SETTINGS$PROFILE_MENU)}- testId="profile-menu-trigger"- className={settingsListIconActionButtonClassName}- />- {menuOpen && (- <ProfileActionsMenu- anchorRef={triggerRef}- onEdit={() => onEdit(profile)}- onRename={() => onRename(profile)}- onDuplicate={() => onDuplicate(profile)}- onSetActive={() => onActivate(profile.name)}- onDelete={() => onDelete(profile)}- isActive={isActive}- isActivating={isActivating}- onClose={() => setMenuOpen(false)}+ {canManage && (+ <div className="relative shrink-0">+ <EllipsisButton+ ref={triggerRef}+ onClick={() => setMenuOpen((open) => !open)}+ ariaLabel={t(I18nKey.SETTINGS$PROFILE_MENU)}+ testId="profile-menu-trigger"+ className={settingsListIconActionButtonClassName}/>- )}- </div>+ {menuOpen && (+ <ProfileActionsMenu+ anchorRef={triggerRef}+ onEdit={() => onEdit(profile)}+ onRename={() => onRename(profile)}+ onDuplicate={() => onDuplicate(profile)}+ onSetActive={() => onActivate(profile.name)}+ onDelete={() => onDelete(profile)}+ isActive={isActive}+ isActivating={isActivating}+ onClose={() => setMenuOpen(false)}+ />+ )}+ </div>+ )}</div>);}diff --git a/src/components/features/settings/llm-profiles/profiles-body.tsx b/src/components/features/settings/llm-profiles/profiles-body.tsxindex ea7e3b7941..46c78d769a 100644--- a/src/components/features/settings/llm-profiles/profiles-body.tsx+++ b/src/components/features/settings/llm-profiles/profiles-body.tsx@@ -15,6 +15,8 @@ interface ProfilesBodyProps {loadError: Error | null;profiles: ProfileInfo[];active: string | null;+ /** When false, rows render read-only (no actions menu) β cloud members. */+ canManage: boolean;onActivate: (name: string) => void;onEdit: (profile: ProfileInfo) => void;onRename: (profile: ProfileInfo) => void;@@ -28,6 +30,7 @@ export function ProfilesBody({loadError,profiles,active,+ canManage,onActivate,onEdit,onRename,@@ -83,6 +86,7 @@ export function ProfilesBody({key={profile.name}profile={profile}isActive={profile.name === active}+ canManage={canManage}onActivate={onActivate}onEdit={onEdit}onRename={onRename}diff --git a/src/hooks/chat/use-model-interceptor.ts b/src/hooks/chat/use-model-interceptor.tsindex 2b1b94d592..6c42a648b6 100644--- a/src/hooks/chat/use-model-interceptor.ts+++ b/src/hooks/chat/use-model-interceptor.ts@@ -14,11 +14,11 @@ import { MODEL_COMMAND } from "#/utils/constants";const MODEL_PREFIX = `${MODEL_COMMAND} `;/**- * Intercepts "/model" submissions:+ * Intercepts "/model" submissions (both local and cloud backends manage the+ * LLM through saved profiles):* - "/model" β render an inline list of saved profiles in the chat* - "/model <name>" β switch the running conversation's LLM profile- * Anything else (or when on a cloud backend, which doesn't support profiles)- * falls through to `onSubmit`.+ * Anything that isn't a "/model" command falls through to `onSubmit`.*/export const useModelInterceptor = (conversationId: string | null | undefined,@@ -28,7 +28,6 @@ export const useModelInterceptor = (const queryClient = useQueryClient();const { switchAndLog } = useSwitchLlmProfileAndLog();const { backend, orgId } = useActiveBackend();- const isLocal = backend.kind === "local";const { t } = useTranslation();return useCallback(@@ -36,7 +35,7 @@ export const useModelInterceptor = (const trimmed = message.trim();const isModel =trimmed === MODEL_COMMAND || trimmed.startsWith(MODEL_PREFIX);- if (!isModel || !isLocal) {+ if (!isModel) {onSubmit(message);return;}@@ -81,7 +80,6 @@ export const useModelInterceptor = (},[conversationId,- isLocal,onSubmit,showProfiles,queryClient,diff --git a/src/hooks/chat/use-slash-command.ts b/src/hooks/chat/use-slash-command.tsindex a787b6d87a..5fc2283f2b 100644--- a/src/hooks/chat/use-slash-command.ts+++ b/src/hooks/chat/use-slash-command.ts@@ -39,9 +39,7 @@ export const useSlashCommand = (// slash menu lists the same project skills that were loaded into it.const { data: skills, isLoading: isSkillsLoading } = useConversationSkills();const isCloud = useActiveBackend().backend.kind === "cloud";- const { data: profilesData, isLoading: isProfilesLoading } = useLlmProfiles({- enabled: !isCloud,- });+ const { data: profilesData, isLoading: isProfilesLoading } = useLlmProfiles();const [isMenuOpen, setIsMenuOpen] = useState(false);const [filterText, setFilterText] = useState("");const [completionKind, setCompletionKind] =@@ -51,13 +49,12 @@ export const useSlashCommand = (// Build slash command items from built-in commands + skills:// - Built-in commands (like /new) are included for V1 conversations// - /new is cloud-only β local backends don't surface it- // - /model is local-only β cloud backends don't have profiles+ // - /model lists/switches LLM profiles; both local and cloud support them// - Skills with explicit "/" triggers use those triggers// - AgentSkills without "/" triggers get a derived "/<name>" commandconst slashItems = useMemo(() => {const items: SlashCommandItem[] = BUILT_IN_COMMANDS.filter((cmd) => {if (cmd.command === "/new") return isCloud;- if (cmd.command === MODEL_COMMAND) return !isCloud;return true;});@@ -83,8 +80,6 @@ export const useSlashCommand = (}, [skills, isSkillsLoading, isCloud]);const modelProfileItems = useMemo<SlashCommandItem[]>(() => {- if (isCloud) return [];-return (profilesData?.profiles ?? []).map((profile) => {const command = `${MODEL_COMMAND} ${profile.name}`;return {@@ -99,7 +94,7 @@ export const useSlashCommand = (},};});- }, [profilesData?.profiles, isCloud]);+ }, [profilesData?.profiles]);// Filter items based on user input after "/"const filteredItems = useMemo(() => {diff --git a/src/hooks/use-can-manage-llm-profiles.ts b/src/hooks/use-can-manage-llm-profiles.tsnew file mode 100644index 0000000000..6cc62cf9cc--- /dev/null+++ b/src/hooks/use-can-manage-llm-profiles.ts@@ -0,0 +1,53 @@+import { useQuery } from "@tanstack/react-query";+import { getCloudOrganizationMe } from "#/api/cloud/organization-service.api";+import { useActiveBackend } from "#/contexts/active-backend-context";++/**+ * Server-defined permission (mirrors the app-server's+ * `authorization.Permission.EDIT_ORG_SETTINGS`) that gates LLM-profile+ * mutations for an org.+ */+const EDIT_ORG_SETTINGS = "edit_org_settings";++/**+ * Whether the current user may MUTATE LLM profiles on the active backend β+ * create, edit, rename, delete, duplicate, or activate/switch.+ *+ * - Local agent-server (OSS): always `true`; the user owns their own profiles.+ * - Cloud: profiles are org-scoped. The app-server grants every mutating+ * profile action (save/delete/rename/activate) only to the `owner`/`admin`+ * roles via the `edit_org_settings` permission; a `member` is view-only. We+ * read the caller's server-defined permissions from+ * `GET /api/organizations/{orgId}/me` β the same call `useCloudCurrentUserId`+ * makes, reusing its query key so no extra request is issued β and fall back+ * to a role check when an older app-server doesn't return `permissions`.+ *+ * Returns `false` while the role/permissions are still loading or unknown on+ * cloud, so mutating controls never flash for a member before they resolve.+ */+export function useCanManageLlmProfiles(): boolean {+ const { backend, orgId } = useActiveBackend();+ const isCloud = backend.kind === "cloud";++ // `backend` is identified by `backend.id`, which is already in the key; we+ // keep the key byte-identical to useCloudCurrentUserId so React Query shares+ // the cached /me result instead of firing a second request.+ // eslint-disable-next-line @tanstack/query/exhaustive-deps+ const { data } = useQuery({+ queryKey: ["cloud-current-user", backend.id, orgId],+ queryFn: () => getCloudOrganizationMe(orgId!, backend),+ enabled: isCloud && !!orgId,+ staleTime: 1000 * 60 * 5,+ retry: false,+ meta: { disableToast: true },+ });++ if (!isCloud) return true;+ // Prefer the server-defined permission set; fall back to a role check for+ // older app-servers whose /me doesn't return `permissions` yet, so this+ // keeps working against either backend version.+ if (data?.permissions) {+ return data.permissions.includes(EDIT_ORG_SETTINGS);+ }+ return data?.role === "owner" || data?.role === "admin";+}diff --git a/src/routes/llm-settings.tsx b/src/routes/llm-settings.tsxindex 8b9bf3fb96..abc0638fbf 100644--- a/src/routes/llm-settings.tsx+++ b/src/routes/llm-settings.tsx@@ -17,7 +17,6 @@ import { LlmSettingsLocalView } from "#/components/features/settings/llm-profileimport { I18nKey } from "#/i18n/declaration";import { Settings, SettingsSchema, SettingsScope } from "#/types/settings";import { extractModelAndProvider } from "#/utils/extract-model-and-provider";-import { useActiveBackend } from "#/contexts/active-backend-context";import {inferInitialView,type SettingsFormValues,@@ -506,26 +505,19 @@ export function LlmSettingsScreen({}/**- * Default export for the route renders different views based on backend type:- * - Local backends: LlmSettingsLocalView with profile management- * - Cloud backends: Standard LlmSettingsScreen (profiles are not supported)+ * Default export for the route renders the LLM-profile management view for both+ * backend types. Both manage the LLM through named profiles β local via the+ * agent-server (`/api/profiles`), cloud via the app-server+ * (`/api/v1/settings/profiles`) β and the view is backend-agnostic because it+ * goes through ProfilesService, which routes per active backend.** The LlmSettingsScreen component is also exported for embedded use cases- * (e.g., onboarding, profile editing forms).+ * (e.g., onboarding, the profile create/edit form).** Note: This is a route file, only the router should import the default export.* Other consumers should use the named export `LlmSettingsScreen` for embedded* use cases.*/export default function LlmSettingsRoute() {- const { backend } = useActiveBackend();- const isCloud = backend.kind === "cloud";-- // Cloud backends use the standard LLM settings form (no profiles support)- if (isCloud) {- return <LlmSettingsScreen />;- }-- // Local backends use the profile management viewreturn <LlmSettingsLocalView />;}