diff --git a/frontend/e2e/_targets.ts b/frontend/e2e/_targets.ts
new file mode 100644
index 0000000000..c596d8e130
--- /dev/null
+++ b/frontend/e2e/_targets.ts
@@ -0,0 +1,45 @@
+// Shared helpers for building target-instance mock payloads in e2e tests.
+//
+// Mirrors the frontend `makeTarget` fixture (src/test-utils/targetFixtures.ts):
+// folds flat identity scalars into the embedded `identifier` so route mocks
+// match the current nested `TargetInstance` wire model. Without this, the
+// target table crashes reading `target.identifier.class_name` and no rows
+// (and no "Set Active" button) render.
+
+export interface FlatTarget {
+  target_registry_name: string;
+  target_type?: string;
+  endpoint?: string | null;
+  model_name?: string | null;
+  capabilities?: unknown;
+  target_specific_params?: unknown;
+  inner_targets?: FlatTarget[] | null;
+}
+
+interface TargetInstanceMock {
+  target_registry_name: string;
+  identifier: {
+    class_name: string;
+    hash: string;
+    endpoint: string | null;
+    model_name: string | null;
+  };
+  capabilities: unknown;
+  target_specific_params: unknown;
+  inner_targets: TargetInstanceMock[] | null;
+}
+
+export function makeTarget(flat: FlatTarget): TargetInstanceMock {
+  return {
+    target_registry_name: flat.target_registry_name,
+    identifier: {
+      class_name: flat.target_type ?? "TextTarget",
+      hash: `${flat.target_registry_name}-hash`,
+      endpoint: flat.endpoint ?? null,
+      model_name: flat.model_name ?? null,
+    },
+    capabilities: flat.capabilities ?? null,
+    target_specific_params: flat.target_specific_params ?? null,
+    inner_targets: flat.inner_targets ? flat.inner_targets.map(makeTarget) : null,
+  };
+}
diff --git a/frontend/e2e/accessibility.spec.ts b/frontend/e2e/accessibility.spec.ts
index d6b5ce576d..20dfb864c7 100644
--- a/frontend/e2e/accessibility.spec.ts
+++ b/frontend/e2e/accessibility.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect } from "@playwright/test";
+import { makeTarget } from "./_targets";
 
 test.describe("Accessibility", () => {
   test.beforeEach(async ({ page }) => {
@@ -13,12 +14,12 @@ test.describe("Accessibility", () => {
         contentType: "application/json",
         body: JSON.stringify({
           items: [
-            {
+            makeTarget({
               target_registry_name: "a11y-form-target",
               target_type: "OpenAIChatTarget",
               endpoint: "https://test.com",
               model_name: "gpt-4o",
-            },
+            }),
           ],
           pagination: { limit: 200, has_more: false, next_cursor: null, prev_cursor: null },
         }),
@@ -84,12 +85,12 @@ test.describe("Accessibility", () => {
         contentType: "application/json",
         body: JSON.stringify({
           items: [
-            {
+            makeTarget({
               target_registry_name: "a11y-focus-target",
               target_type: "OpenAIChatTarget",
               endpoint: "https://test.com",
               model_name: "gpt-4o",
-            },
+            }),
           ],
           pagination: { limit: 200, has_more: false, next_cursor: null, prev_cursor: null },
         }),
@@ -124,12 +125,12 @@ test.describe("Accessibility", () => {
         contentType: "application/json",
         body: JSON.stringify({
           items: [
-            {
+            makeTarget({
               target_registry_name: "a11y-test-target",
               target_type: "OpenAIChatTarget",
               endpoint: "https://test.com",
               model_name: "gpt-4o",
-            },
+            }),
           ],
           pagination: { limit: 200, has_more: false, next_cursor: null, prev_cursor: null },
         }),
diff --git a/frontend/e2e/chat.spec.ts b/frontend/e2e/chat.spec.ts
index 197be11045..05f75a44b8 100644
--- a/frontend/e2e/chat.spec.ts
+++ b/frontend/e2e/chat.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect, type Page } from "@playwright/test";
+import { makeTarget } from "./_targets";
 
 // ---------------------------------------------------------------------------
 // Helpers – mock backend API responses so tests don't require an OpenAI key
@@ -19,12 +20,12 @@ async function mockBackendAPIs(page: Page) {
         contentType: "application/json",
         body: JSON.stringify({
           items: [
-            {
+            makeTarget({
               target_registry_name: "mock-openai-chat",
               target_type: "OpenAIChatTarget",
               endpoint: "https://mock.openai.com",
               model_name: "gpt-4o-mock",
-            },
+            }),
           ],
         }),
       });
@@ -327,12 +328,12 @@ function buildModalityMock(
           contentType: "application/json",
           body: JSON.stringify({
             items: [
-              {
+              makeTarget({
                 target_registry_name: "mock-target",
                 target_type: "OpenAIChatTarget",
                 endpoint: "https://mock.endpoint.com",
                 model_name: "test-model",
-              },
+              }),
             ],
           }),
         });
@@ -677,7 +678,7 @@ test.describe("Target type scenarios", () => {
       endpoint: "https://api.openai.com",
       model_name: "tts-1-hd",
     },
-  ];
+  ].map(makeTarget);
 
   test("should list multiple target types on config page", async ({ page }) => {
     await page.route(/\/api\/targets/, async (route) => {
diff --git a/frontend/e2e/config.spec.ts b/frontend/e2e/config.spec.ts
index 0e9956b8a9..5c2e4d8828 100644
--- a/frontend/e2e/config.spec.ts
+++ b/frontend/e2e/config.spec.ts
@@ -1,16 +1,17 @@
 import { test, expect, type Page } from "@playwright/test";
+import { makeTarget, type FlatTarget } from "./_targets";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
 /** Return a mock targets list response. */
-function mockTargetsList(items: Record<string, unknown>[] = []) {
+function mockTargetsList(items: FlatTarget[] = []) {
   return {
     status: 200,
     contentType: "application/json",
     body: JSON.stringify({
-      items,
+      items: items.map(makeTarget),
       pagination: { limit: 200, has_more: false, next_cursor: null, prev_cursor: null },
     }),
   };
@@ -138,7 +139,7 @@ test.describe("Target Configuration Page", () => {
 
 test.describe("Create Target Dialog", () => {
   test("should create a target through the dialog", async ({ page }) => {
-    let createdTarget: Record<string, unknown> | null = null;
+    let createdTarget: FlatTarget | null = null;
 
     await page.route(/\/api\/targets/, async (route) => {
       if (route.request().method() === "POST") {
diff --git a/frontend/e2e/converters.spec.ts b/frontend/e2e/converters.spec.ts
index 74dfb91148..b64ced7e7e 100644
--- a/frontend/e2e/converters.spec.ts
+++ b/frontend/e2e/converters.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect, type Page } from "@playwright/test";
+import { makeTarget } from "./_targets";
 
 // ---------------------------------------------------------------------------
 // Mock data
@@ -186,7 +187,7 @@ async function mockBackendAPIs(page: Page) {
         contentType: "application/json",
         body: JSON.stringify({
           items: [
-            {
+            makeTarget({
               target_registry_name: "mock-openai-chat",
               target_type: "OpenAIChatTarget",
               endpoint: "https://mock.openai.com",
@@ -201,7 +202,7 @@ async function mockBackendAPIs(page: Page) {
                 supported_input_data_types: ["text"],
                 supported_output_data_types: ["text"],
               },
-            },
+            }),
           ],
           pagination: { limit: 50, has_more: false },
         }),
diff --git a/frontend/e2e/errors.spec.ts b/frontend/e2e/errors.spec.ts
index 73560c3d6e..84afa9953c 100644
--- a/frontend/e2e/errors.spec.ts
+++ b/frontend/e2e/errors.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect, type Page, type Route } from "@playwright/test";
+import { makeTarget } from "./_targets";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -67,12 +68,12 @@ async function mockAllAPIs(
         contentType: "application/json",
         body: JSON.stringify({
           items: [
-            {
+            makeTarget({
               target_registry_name: "mock-target",
               target_type: "OpenAIChatTarget",
               endpoint: "https://mock.endpoint.com",
               model_name: "gpt-4o-mock",
-            },
+            }),
           ],
         }),
       });
@@ -438,12 +439,12 @@ test.describe("Error: create attack fails", () => {
           contentType: "application/json",
           body: JSON.stringify({
             items: [
-              {
+              makeTarget({
                 target_registry_name: "mock-target",
                 target_type: "OpenAIChatTarget",
                 endpoint: "https://mock.endpoint.com",
                 model_name: "gpt-4o-mock",
-              },
+              }),
             ],
           }),
         });
diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index 5088924cb2..7663291a4d 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -167,6 +167,7 @@ jest.mock("./components/Chat/ChatWindow", () => {
 });
 
 jest.mock("./components/Config/TargetConfig", () => {
+  const { makeTarget } = jest.requireActual("@/test-utils/targetFixtures") as typeof import("@/test-utils/targetFixtures");
   const MockTargetConfig = ({
     activeTarget,
     onSetActiveTarget,
@@ -181,12 +182,10 @@ jest.mock("./components/Config/TargetConfig", () => {
         </span>
         <button
           onClick={() =>
-            onSetActiveTarget({
-              target_id: "t1",
+            onSetActiveTarget(makeTarget({
               target_registry_name: "test_target",
               target_type: "OpenAIChatTarget",
-              status: "active",
-            })
+            }))
           }
           data-testid="set-target"
         >
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 70a10f6579..c617828545 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -18,6 +18,7 @@ import { DEFAULT_GLOBAL_LABELS } from './components/Labels/labelDefaults'
 import { filtersFromSearchParams, filtersToSearchParams } from './components/History/historyFilters'
 import type { ViewName } from './components/Sidebar/Navigation'
 import type { TargetInstance, TargetInfo } from './types'
+import { targetEndpoint, targetModelName, targetType } from './utils/targetIdentity'
 import { attacksApi, versionApi } from './services/api'
 import { toApiError } from './services/errors'
 import { useTour } from './hooks/useTour'
@@ -166,9 +167,9 @@ function App() {
     setActiveTarget(prev => {
       const isSame = prev &&
         prev.target_registry_name === target.target_registry_name &&
-        prev.target_type === target.target_type &&
-        (prev.endpoint ?? '') === (target.endpoint ?? '') &&
-        (prev.model_name ?? '') === (target.model_name ?? '')
+        targetType(prev) === targetType(target) &&
+        (targetEndpoint(prev) ?? '') === (targetEndpoint(target) ?? '') &&
+        (targetModelName(prev) ?? '') === (targetModelName(target) ?? '')
       if (isSame) return prev
       // Switching targets no longer clears the loaded attack.  The cross-target
       // guard in ChatWindow prevents sending to a mismatched target, and the
@@ -280,9 +281,9 @@ function App() {
     // its next fetch for this id, so the attack opens without a redundant load.
     const target: TargetInfo | null = activeTarget
       ? {
-          target_type: activeTarget.target_type,
-          endpoint: activeTarget.endpoint,
-          model_name: activeTarget.model_name,
+          target_type: targetType(activeTarget),
+          endpoint: targetEndpoint(activeTarget),
+          model_name: targetModelName(activeTarget),
         }
       : null
     skipNextLoadForAttackId.current = arId
@@ -405,7 +406,7 @@ function App() {
               context={{
                 app_version: appVersion || undefined,
                 current_view: currentView,
-                target_type: activeTarget?.target_type,
+                target_type: activeTarget ? targetType(activeTarget) : undefined,
               }}
             />
           )}
diff --git a/frontend/src/components/Chat/ChatInputArea.test.tsx b/frontend/src/components/Chat/ChatInputArea.test.tsx
index 9513762dc4..ffae7fc1d9 100644
--- a/frontend/src/components/Chat/ChatInputArea.test.tsx
+++ b/frontend/src/components/Chat/ChatInputArea.test.tsx
@@ -4,7 +4,8 @@ import userEvent from "@testing-library/user-event";
 import { FluentProvider, webLightTheme } from "@fluentui/react-components";
 import ChatInputArea from "./ChatInputArea";
 import type { ChatInputAreaHandle } from "./ChatInputArea";
-import type { TargetCapabilitiesInfo } from "../../types";
+import { makeTarget } from "@/test-utils/targetFixtures";
+import type { TargetCapabilities } from "../../types";
 
 // Wrapper component for Fluent UI context
 const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
@@ -12,8 +13,8 @@ const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
 );
 
 const buildCapabilities = (
-  overrides: Partial<TargetCapabilitiesInfo> = {}
-): TargetCapabilitiesInfo => ({
+  overrides: Partial<TargetCapabilities> = {}
+): TargetCapabilities => ({
   supports_multi_turn: true,
   supports_multi_message_pieces: false,
   supports_json_schema: false,
@@ -295,7 +296,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
         />
       </TestWrapper>
     );
@@ -395,11 +396,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "test",
             target_type: "TextTarget",
             capabilities: buildCapabilities({ supports_multi_turn: false }),
-          }}
+          })}
         />
       </TestWrapper>
     );
@@ -416,11 +417,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "test",
             target_type: "OpenAIChatTarget",
             capabilities: buildCapabilities({ supports_multi_turn: true }),
-          }}
+          })}
         />
       </TestWrapper>
     );
@@ -604,7 +605,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           mediaConversions={[{ pieceType: "image", convertedValue: "/tmp/converted.png", convertedDataType: "image_path" }]}
         />
       </TestWrapper>
@@ -632,7 +633,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           mediaConversions={[{ pieceType: "image", convertedValue: "/tmp/converted.png", convertedDataType: "image_path" }]}
           onClearMediaConversion={onClearMediaConversion}
         />
@@ -660,7 +661,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           convertedValue="aGVsbG8="
           originalValue="hello"
           onConvertedValueChange={onConvertedValueChange}
@@ -694,7 +695,7 @@ describe("ChatInputArea", () => {
         <ChatInputArea
           {...defaultProps}
           onSend={onSend}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           convertedValue="convertedHello"
           originalValue="hello"
           onClearConversion={onClearConversion}
@@ -715,7 +716,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           convertedFileChip={{
             name: "result.pdf",
             url: "/api/media?path=%2Ftmp%2Fresult.pdf",
@@ -741,7 +742,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           convertedFileChip={{
             name: "result.pdf",
             url: "/api/media?path=%2Ftmp%2Fresult.pdf",
@@ -761,7 +762,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           convertedFileChip={{
             name: "result.png",
             url: "/api/media?path=%2Ftmp%2Fresult.png",
@@ -785,7 +786,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           convertedFileChip={{
             name: "speech.wav",
             url: "/api/media?path=%2Ftmp%2Fspeech.wav",
@@ -808,7 +809,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           convertedFileChip={{
             name: "clip.mp4",
             url: "/api/media?path=%2Ftmp%2Fclip.mp4",
@@ -829,7 +830,7 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" }}
+          activeTarget={makeTarget({ target_registry_name: "t", target_type: "T", endpoint: "e", model_name: "m" })}
           convertedFileChip={{
             name: "result.pdf",
             url: "/api/media?path=%2Ftmp%2Fresult.pdf",
@@ -855,11 +856,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "TextTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text"] }),
-          }}
+          })}
         />
       </TestWrapper>
     );
@@ -881,11 +882,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "OpenAIChatTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text", "image_path"] }),
-          }}
+          })}
         />
       </TestWrapper>
     );
@@ -926,11 +927,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "OpenAIChatTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text", "image_path"] }),
-          }}
+          })}
         />
       </TestWrapper>
     );
@@ -952,11 +953,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "TextTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text"] }),
-          }}
+          })}
         />
       </TestWrapper>
     );
@@ -983,11 +984,11 @@ describe("ChatInputArea", () => {
         <ChatInputArea
           {...defaultProps}
           onSend={onSend}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "TextTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text"] }),
-          }}
+          })}
         />
       </TestWrapper>
     );
@@ -1011,11 +1012,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "TextTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text"] }),
-          }}
+          })}
         />
       </TestWrapper>
     );
@@ -1037,11 +1038,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "TextTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text"] }),
-          }}
+          })}
           converterOutputDataTypes={["image_path"]}
         />
       </TestWrapper>
@@ -1060,11 +1061,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "OpenAIChatTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text", "image_path"] }),
-          }}
+          })}
           converterOutputDataTypes={["image_path"]}
         />
       </TestWrapper>
@@ -1080,11 +1081,11 @@ describe("ChatInputArea", () => {
       <TestWrapper>
         <ChatInputArea
           {...defaultProps}
-          activeTarget={{
+          activeTarget={makeTarget({
             target_registry_name: "t",
             target_type: "TextTarget",
             capabilities: buildCapabilities({ supported_input_modalities: ["text"] }),
-          }}
+          })}
           converterOutputDataTypes={["audio_path"]}
         />
       </TestWrapper>
diff --git a/frontend/src/components/Chat/ChatWindow.test.tsx b/frontend/src/components/Chat/ChatWindow.test.tsx
index 57f9070b00..1f296aadb1 100644
--- a/frontend/src/components/Chat/ChatWindow.test.tsx
+++ b/frontend/src/components/Chat/ChatWindow.test.tsx
@@ -2,13 +2,14 @@ import { render, screen, waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { FluentProvider, webLightTheme } from "@fluentui/react-components";
 import ChatWindow from "./ChatWindow";
-import { Message, TargetCapabilitiesInfo, TargetInfo, TargetInstance } from "../../types";
+import { makeTarget } from "@/test-utils/targetFixtures";
+import { Message, TargetCapabilities, TargetInfo, TargetInstance } from "../../types";
 import { attacksApi, convertersApi } from "../../services/api";
 import * as messageMapper from "../../utils/messageMapper";
 
 const buildCapabilities = (
-  overrides: Partial<TargetCapabilitiesInfo> = {}
-): TargetCapabilitiesInfo => ({
+  overrides: Partial<TargetCapabilities> = {}
+): TargetCapabilities => ({
   supports_multi_turn: true,
   supports_multi_message_pieces: false,
   supports_json_schema: false,
@@ -58,12 +59,12 @@ const TestWrapper: React.FC<{ children: React.ReactNode }> = ({
   children,
 }) => <FluentProvider theme={webLightTheme}>{children}</FluentProvider>;
 
-const mockTarget: TargetInstance = {
+const mockTarget: TargetInstance = makeTarget({
   target_registry_name: "openai_chat_1",
   target_type: "OpenAIChatTarget",
   endpoint: "https://api.openai.com",
   model_name: "gpt-4",
-};
+});
 
 // ---------------------------------------------------------------------------
 // Helpers to build mock backend responses
@@ -388,7 +389,7 @@ describe("ChatWindow Integration", () => {
   it("should display target without model name", () => {
     const targetNoModel: TargetInstance = {
       ...mockTarget,
-      model_name: null,
+      identifier: { ...mockTarget.identifier, model_name: null },
     };
 
     render(
@@ -1247,11 +1248,11 @@ describe("ChatWindow Integration", () => {
   // -----------------------------------------------------------------------
 
   it("should show single-turn banner for single-turn target with existing user messages", async () => {
-    const singleTurnTarget: TargetInstance = {
+    const singleTurnTarget: TargetInstance = makeTarget({
       target_registry_name: "openai_image_1",
       target_type: "OpenAIImageTarget",
       capabilities: buildCapabilities({ supports_multi_turn: false }),
-    };
+    });
 
     const messagesWithUser: Message[] = [
       { role: "user", content: "Generate an image", timestamp: "2026-01-01T00:00:00Z" },
@@ -1281,11 +1282,11 @@ describe("ChatWindow Integration", () => {
   });
 
   it("should not show single-turn banner for single-turn target with no messages", () => {
-    const singleTurnTarget: TargetInstance = {
+    const singleTurnTarget: TargetInstance = makeTarget({
       target_registry_name: "openai_image_1",
       target_type: "OpenAIImageTarget",
       capabilities: buildCapabilities({ supports_multi_turn: false }),
-    };
+    });
 
     render(
       <TestWrapper>
@@ -1330,11 +1331,11 @@ describe("ChatWindow Integration", () => {
   });
 
   it("should show New Conversation button in single-turn banner when conversation exists", async () => {
-    const singleTurnTarget: TargetInstance = {
+    const singleTurnTarget: TargetInstance = makeTarget({
       target_registry_name: "openai_tts_1",
       target_type: "OpenAITTSTarget",
       capabilities: buildCapabilities({ supports_multi_turn: false }),
-    };
+    });
 
     const messagesWithUser: Message[] = [
       { role: "user", content: "Say hello", timestamp: "2026-01-01T00:00:00Z" },
@@ -1384,9 +1385,9 @@ describe("ChatWindow Integration", () => {
 
   it("should not show cross-target banner when attackTarget matches activeTarget", () => {
     const sameTarget: TargetInfo = {
-      target_type: mockTarget.target_type,
-      endpoint: mockTarget.endpoint,
-      model_name: mockTarget.model_name,
+      target_type: mockTarget.identifier.class_name,
+      endpoint: mockTarget.identifier.endpoint,
+      model_name: mockTarget.identifier.model_name,
     };
 
     render(
@@ -1543,11 +1544,11 @@ describe("ChatWindow Integration", () => {
       conversation_id: "new-conv-from-new",
     });
 
-    const singleTurnTarget: TargetInstance = {
+    const singleTurnTarget: TargetInstance = makeTarget({
       target_registry_name: "openai_image_1",
       target_type: "OpenAIImageTarget",
       capabilities: buildCapabilities({ supports_multi_turn: false }),
-    };
+    });
 
     const messagesWithUser: Message[] = [
       { role: "user", content: "Generate an image", timestamp: "2026-01-01T00:00:00Z" },
diff --git a/frontend/src/components/Chat/ChatWindow.tsx b/frontend/src/components/Chat/ChatWindow.tsx
index b94bc41a2b..ad8798a203 100644
--- a/frontend/src/components/Chat/ChatWindow.tsx
+++ b/frontend/src/components/Chat/ChatWindow.tsx
@@ -18,6 +18,7 @@ import { attacksApi } from '../../services/api'
 import { toApiError } from '../../services/errors'
 import { buildMessagePieces, backendMessagesToFrontend } from '../../utils/messageMapper'
 import type { Message, MessageAttachment, TargetInstance, TargetInfo } from '../../types'
+import { targetEndpoint, targetModelName, targetType } from '../../utils/targetIdentity'
 import type { ViewName } from '../Sidebar/Navigation'
 import { useChatWindowStyles } from './ChatWindow.styles'
 
@@ -526,9 +527,9 @@ export default function ChatWindow({
   // The user can "Continue with your target" to branch into a new attack with their target.
   const isCrossTargetLocked = Boolean(
     attackResultId && attackTarget && activeTarget && (
-      attackTarget.target_type !== activeTarget.target_type ||
-      (attackTarget.endpoint ?? '') !== (activeTarget.endpoint ?? '') ||
-      (attackTarget.model_name ?? '') !== (activeTarget.model_name ?? '')
+      attackTarget.target_type !== targetType(activeTarget) ||
+      (attackTarget.endpoint ?? '') !== (targetEndpoint(activeTarget) ?? '') ||
+      (attackTarget.model_name ?? '') !== (targetModelName(activeTarget) ?? '')
     )
   )
 
diff --git a/frontend/src/components/Chat/TargetBadge.test.tsx b/frontend/src/components/Chat/TargetBadge.test.tsx
index 172fbb3566..7cf40b4cce 100644
--- a/frontend/src/components/Chat/TargetBadge.test.tsx
+++ b/frontend/src/components/Chat/TargetBadge.test.tsx
@@ -1,13 +1,15 @@
 import { render, screen } from '@testing-library/react'
 import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { makeTarget } from '@/test-utils/targetFixtures'
 import TargetBadge from './TargetBadge'
+import type { FlatTargetInput } from '@/test-utils/targetFixtures'
 import type { TargetInstance } from '../../types'
 
 const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
   <FluentProvider theme={webLightTheme}>{children}</FluentProvider>
 )
 
-const baseTarget: TargetInstance = {
+const flatBaseTarget: FlatTargetInput = {
   target_registry_name: 'azure_openai_gpt4o',
   target_type: 'OpenAIChatTarget',
   endpoint: 'https://example.openai.azure.com/openai/deployments/gpt-4o',
@@ -28,6 +30,8 @@ const baseTarget: TargetInstance = {
   },
 }
 
+const baseTarget: TargetInstance = makeTarget(flatBaseTarget)
+
 describe('TargetBadge', () => {
   it('renders the type and model name as the visible badge label', () => {
     render(
@@ -51,7 +55,7 @@ describe('TargetBadge', () => {
   it('renders only the type when no model name is set', () => {
     render(
       <TestWrapper>
-        <TargetBadge target={{ ...baseTarget, model_name: null }} />
+        <TargetBadge target={makeTarget({ ...flatBaseTarget, model_name: null })} />
       </TestWrapper>
     )
     const badge = screen.getByTestId('target-badge')
@@ -60,10 +64,10 @@ describe('TargetBadge', () => {
   })
 
   it('does not throw on a target with no capabilities or params', () => {
-    const minimal: TargetInstance = {
+    const minimal: TargetInstance = makeTarget({
       target_registry_name: 't',
       target_type: 'TextTarget',
-    }
+    })
     expect(() =>
       render(
         <TestWrapper>
@@ -75,7 +79,7 @@ describe('TargetBadge', () => {
   })
 
   it('shows count in display name for RoundRobinTarget with inner targets', () => {
-    const rrTarget: TargetInstance = {
+    const rrTarget: TargetInstance = makeTarget({
       target_registry_name: 'rr_test',
       target_type: 'RoundRobinTarget',
       model_name: 'gpt-4o',
@@ -84,7 +88,7 @@ describe('TargetBadge', () => {
         { target_registry_name: 'b', target_type: 'OpenAIChatTarget', model_name: 'gpt-4o' },
         { target_registry_name: 'c', target_type: 'OpenAIChatTarget', model_name: 'gpt-4o' },
       ],
-    }
+    })
     render(
       <TestWrapper>
         <TargetBadge target={rrTarget} />
@@ -95,7 +99,7 @@ describe('TargetBadge', () => {
   })
 
   it('prefers underlying_model_name over model_name for RoundRobinTarget badge', () => {
-    const rrTarget: TargetInstance = {
+    const rrTarget: TargetInstance = makeTarget({
       target_registry_name: 'rr_mixed',
       target_type: 'RoundRobinTarget',
       model_name: 'gpt-4o-japan-nilfilter',
@@ -104,7 +108,7 @@ describe('TargetBadge', () => {
         { target_registry_name: 'a', target_type: 'OpenAIChatTarget', model_name: 'deploy-1' },
         { target_registry_name: 'b', target_type: 'OpenAIChatTarget', model_name: 'deploy-2' },
       ],
-    }
+    })
     render(
       <TestWrapper>
         <TargetBadge target={rrTarget} />
diff --git a/frontend/src/components/Chat/TargetBadge.tsx b/frontend/src/components/Chat/TargetBadge.tsx
index aee8be493c..df0acbb0c9 100644
--- a/frontend/src/components/Chat/TargetBadge.tsx
+++ b/frontend/src/components/Chat/TargetBadge.tsx
@@ -1,5 +1,6 @@
 import { Badge, Text, Tooltip } from '@fluentui/react-components'
 import type { TargetInstance } from '../../types'
+import { targetEndpoint, targetModelName, targetType, targetUnderlyingModelName } from '../../utils/targetIdentity'
 import { useTargetBadgeStyles } from './TargetBadge.styles'
 
 interface TargetBadgeProps {
@@ -36,24 +37,29 @@ export default function TargetBadge({ target }: TargetBadgeProps) {
   const innerTargets = target.inner_targets ?? []
   const isRoundRobin = innerTargets.length > 0
 
+  const targetTypeName = targetType(target)
+  const modelName = targetModelName(target)
+  const underlyingModelName = targetUnderlyingModelName(target)
+  const endpoint = targetEndpoint(target)
+
   // For RoundRobinTarget, prefer underlying_model_name because inner targets share
   // the same underlying model but may have different deployment names (model_name).
   // For regular targets, use model_name as before.
   const badgeModel = isRoundRobin
-    ? (target.underlying_model_name ?? target.model_name)
-    : target.model_name
+    ? (underlyingModelName ?? modelName)
+    : modelName
   const displayName = isRoundRobin
     ? badgeModel
-      ? `${target.target_type} (${badgeModel} ×${innerTargets.length})`
-      : `${target.target_type} (×${innerTargets.length})`
-    : target.model_name
-      ? `${target.target_type} (${target.model_name})`
-      : target.target_type
+      ? `${targetTypeName} (${badgeModel} ×${innerTargets.length})`
+      : `${targetTypeName} (×${innerTargets.length})`
+    : modelName
+      ? `${targetTypeName} (${modelName})`
+      : targetTypeName
 
   const showUnderlying =
-    target.underlying_model_name &&
-    target.model_name &&
-    target.underlying_model_name !== target.model_name
+    underlyingModelName &&
+    modelName &&
+    underlyingModelName !== modelName
   const supportedCaps = target.capabilities
     ? CAPABILITY_LABELS.filter(c => target.capabilities?.[c.key]).map(c => c.label)
     : []
@@ -71,14 +77,14 @@ export default function TargetBadge({ target }: TargetBadgeProps) {
         <Text size={200}>{displayName}</Text>
         {showUnderlying && (
           <Text size={200} italic>
-            Underlying model: {target.underlying_model_name}
+            Underlying model: {underlyingModelName}
           </Text>
         )}
       </div>
-      {target.endpoint && (
+      {endpoint && (
         <div className={styles.tooltipSection}>
           <span className={styles.sectionLabel}>Endpoint</span>
-          <Text className={styles.endpointText}>{target.endpoint}</Text>
+          <Text className={styles.endpointText}>{endpoint}</Text>
         </div>
       )}
       {(inputModalities.length > 0 || outputModalities.length > 0) && (
@@ -118,12 +124,12 @@ export default function TargetBadge({ target }: TargetBadgeProps) {
                 #{idx + 1}{weights?.[idx] != null ? ` (weight: ${weights[idx]})` : ''}
               </Text>
               <Text size={200}>
-                {inner.target_type}
-                {inner.model_name ? ` — ${inner.model_name}` : ''}
+                {targetType(inner)}
+                {targetModelName(inner) ? ` — ${targetModelName(inner)}` : ''}
               </Text>
-              {inner.endpoint && (
+              {targetEndpoint(inner) && (
                 <Text className={styles.endpointText} size={200}>
-                  {inner.endpoint}
+                  {targetEndpoint(inner)}
                 </Text>
               )}
             </div>
diff --git a/frontend/src/components/Config/CreateTargetDialog.test.tsx b/frontend/src/components/Config/CreateTargetDialog.test.tsx
index c825c32ac5..62c2a7e8fe 100644
--- a/frontend/src/components/Config/CreateTargetDialog.test.tsx
+++ b/frontend/src/components/Config/CreateTargetDialog.test.tsx
@@ -1,6 +1,7 @@
 import { render, screen, waitFor, fireEvent } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { FluentProvider, webLightTheme } from "@fluentui/react-components";
+import { makeTarget } from "@/test-utils/targetFixtures";
 import CreateTargetDialog from "./CreateTargetDialog";
 import { parseWeight, MAX_WEIGHT } from "./weightValidation";
 import { targetsApi } from "@/services/api";
@@ -8,11 +9,24 @@ import { targetsApi } from "@/services/api";
 jest.mock("@/services/api", () => ({
   targetsApi: {
     createTarget: jest.fn(),
+    listTargetCatalog: jest.fn(),
+    listTargets: jest.fn(),
   },
 }));
 
 const mockedTargetsApi = targetsApi as jest.Mocked<typeof targetsApi>;
 
+// Representative target catalog covering the types the dialog renders. Mirrors
+// the shape returned by GET /targets/catalog.
+const TARGET_CATALOG = {
+  items: [
+    { target_type: "OpenAIChatTarget", parameters: [], supported_auth_modes: ["api_key", "identity"] },
+    { target_type: "OpenAIResponseTarget", parameters: [], supported_auth_modes: ["api_key", "identity"] },
+    { target_type: "AzureMLChatTarget", parameters: [], supported_auth_modes: ["api_key", "identity"] },
+    { target_type: "RoundRobinTarget", parameters: [], supported_auth_modes: ["api_key"] },
+  ],
+};
+
 const TestWrapper: React.FC<{ children: React.ReactNode }> = ({
   children,
 }) => <FluentProvider theme={webLightTheme}>{children}</FluentProvider>;
@@ -104,6 +118,13 @@ describe("CreateTargetDialog", () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    mockedTargetsApi.listTargetCatalog.mockResolvedValue(
+      TARGET_CATALOG as unknown as Awaited<ReturnType<typeof mockedTargetsApi.listTargetCatalog>>,
+    );
+    mockedTargetsApi.listTargets.mockResolvedValue({
+      items: [],
+      pagination: { limit: 200, has_more: false, next_cursor: null, prev_cursor: null },
+    } as unknown as Awaited<ReturnType<typeof mockedTargetsApi.listTargets>>);
   });
 
   it("should render dialog when open", () => {
@@ -150,16 +171,16 @@ describe("CreateTargetDialog", () => {
 
     // No type is chosen yet, so authentication option is not visible yet, but plain API Key input is.
     expect(
-      screen.queryByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.queryByRole("radio", { name: /Identity-based/ })
     ).not.toBeInTheDocument();
     expect(
       screen.getByPlaceholderText("API key (stored in memory only)")
     ).toBeInTheDocument();
 
-    // Selecting an Entra-capable type should reveal the Authentication field.
+    // Selecting an identity-capable type should reveal the Authentication field.
     await selectTargetType(user, "OpenAIChatTarget");
     expect(
-      screen.getByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.getByRole("radio", { name: /Identity-based/ })
     ).toBeInTheDocument();
   });
 
@@ -181,10 +202,10 @@ describe("CreateTargetDialog", () => {
   it("should create target and call onCreated on successful submit", async () => {
     const onCreated = jest.fn();
     const user = userEvent.setup();
-    mockedTargetsApi.createTarget.mockResolvedValue({
+    mockedTargetsApi.createTarget.mockResolvedValue(makeTarget({
       target_registry_name: "openai_chat_new",
       target_type: "OpenAIChatTarget",
-    });
+    }));
 
     render(
       <TestWrapper>
@@ -222,10 +243,10 @@ describe("CreateTargetDialog", () => {
   it("should send underlying_model when toggle is enabled", async () => {
     const onCreated = jest.fn();
     const user = userEvent.setup();
-    mockedTargetsApi.createTarget.mockResolvedValue({
+    mockedTargetsApi.createTarget.mockResolvedValue(makeTarget({
       target_registry_name: "azure_deployment",
       target_type: "OpenAIChatTarget",
-    });
+    }));
 
     render(
       <TestWrapper>
@@ -271,10 +292,10 @@ describe("CreateTargetDialog", () => {
   it("should not send underlying_model when toggle is off", async () => {
     const onCreated = jest.fn();
     const user = userEvent.setup();
-    mockedTargetsApi.createTarget.mockResolvedValue({
+    mockedTargetsApi.createTarget.mockResolvedValue(makeTarget({
       target_registry_name: "simple_target",
       target_type: "OpenAIChatTarget",
-    });
+    }));
 
     render(
       <TestWrapper>
@@ -338,10 +359,10 @@ describe("CreateTargetDialog", () => {
 
   it("should include API key in params when provided", async () => {
     const user = userEvent.setup();
-    mockedTargetsApi.createTarget.mockResolvedValue({
+    mockedTargetsApi.createTarget.mockResolvedValue(makeTarget({
       target_registry_name: "openai_chat_keyed",
       target_type: "OpenAIChatTarget",
-    });
+    }));
 
     render(
       <TestWrapper>
@@ -455,10 +476,10 @@ describe("CreateTargetDialog", () => {
   it("should create AzureMLChatTarget with AzureML-specific params", async () => {
     const onCreated = jest.fn();
     const user = userEvent.setup();
-    mockedTargetsApi.createTarget.mockResolvedValue({
+    mockedTargetsApi.createTarget.mockResolvedValue(makeTarget({
       target_registry_name: "azure_ml_llama",
       target_type: "AzureMLChatTarget",
-    });
+    }));
 
     render(
       <TestWrapper>
@@ -524,10 +545,10 @@ describe("CreateTargetDialog", () => {
   it("should send custom AzureML params when fields are modified", async () => {
     const onCreated = jest.fn();
     const user = userEvent.setup();
-    mockedTargetsApi.createTarget.mockResolvedValue({
+    mockedTargetsApi.createTarget.mockResolvedValue(makeTarget({
       target_registry_name: "azure_ml_custom",
       target_type: "AzureMLChatTarget",
-    });
+    }));
 
     render(
       <TestWrapper>
@@ -601,13 +622,13 @@ describe("CreateTargetDialog", () => {
     expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
   });
 
-  it("should hide the API Key field and omit api_key/include auth_mode when Entra is selected", async () => {
+  it("should hide the API Key field and omit api_key/include auth_mode when identity is selected", async () => {
     const onCreated = jest.fn();
     const user = userEvent.setup();
-    mockedTargetsApi.createTarget.mockResolvedValue({
-      target_registry_name: "openai_chat_entra",
+    mockedTargetsApi.createTarget.mockResolvedValue(makeTarget({
+      target_registry_name: "openai_chat_identity",
       target_type: "OpenAIChatTarget",
-    });
+    }));
 
     render(
       <TestWrapper>
@@ -629,14 +650,14 @@ describe("CreateTargetDialog", () => {
       screen.getByPlaceholderText("API key (stored in memory only)")
     ).toBeInTheDocument();
 
-    // Select Entra option.
+    // Select identity option.
     await user.click(
       screen.getByRole("radio", {
-        name: /Microsoft Entra Authentication/,
+        name: /Identity-based/,
       })
     );
 
-    // check that API Key field is hidden when Entra mode is selected.
+    // check that API Key field is hidden when identity mode is selected.
     expect(
       screen.queryByPlaceholderText("API key (stored in memory only)")
     ).not.toBeInTheDocument();
@@ -649,19 +670,19 @@ describe("CreateTargetDialog", () => {
         params: {
           endpoint: "https://my-resource.openai.azure.com/",
         },
-        auth_mode: "entra",
+        auth_mode: "identity",
       });
       expect(onCreated).toHaveBeenCalled();
     });
   });
 
-  it("should clear a previously-typed API key when switching to Entra", async () => {
+  it("should clear a previously-typed API key when switching to identity", async () => {
     const onCreated = jest.fn();
     const user = userEvent.setup();
-    mockedTargetsApi.createTarget.mockResolvedValue({
-      target_registry_name: "openai_chat_entra",
+    mockedTargetsApi.createTarget.mockResolvedValue(makeTarget({
+      target_registry_name: "openai_chat_identity",
       target_type: "OpenAIChatTarget",
-    });
+    }));
 
     render(
       <TestWrapper>
@@ -678,26 +699,26 @@ describe("CreateTargetDialog", () => {
       target: { value: "https://my-resource.openai.azure.com/" },
     });
 
-    // Type a key, then switch to Entra option.
+    // Type a key, then switch to identity option.
     fireEvent.change(
       screen.getByPlaceholderText("API key (stored in memory only)"),
       { target: { value: "sk-typed-before-switch" } }
     );
 
     await user.click(
-      screen.getByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.getByRole("radio", { name: /Identity-based/ })
     );
 
     await user.click(screen.getByText("Create Target"));
 
     await waitFor(() => {
       const call = mockedTargetsApi.createTarget.mock.calls[0][0];
-      expect(call.auth_mode).toBe("entra");
+      expect(call.auth_mode).toBe("identity");
       expect(call.params).not.toHaveProperty("api_key");
     });
   });
 
-  it("should warn the user when Entra is selected for a non-Azure OpenAI endpoint", async () => {
+  it("should warn the user when identity is selected for a non-Azure OpenAI endpoint", async () => {
     const user = userEvent.setup();
 
     render(
@@ -714,15 +735,15 @@ describe("CreateTargetDialog", () => {
     fireEvent.change(endpointInput, { target: { value: "https://api.openai.com/" } });
 
     await user.click(
-      screen.getByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.getByRole("radio", { name: /Identity-based/ })
     );
 
     expect(
-      screen.getByText(/Entra auth only works with Azure OpenAI/)
+      screen.getByText(/Identity-based auth only works with Azure OpenAI/)
     ).toBeInTheDocument();
   });
 
-  it("should NOT warn when Entra is selected for a recognized Azure endpoint", async () => {
+  it("should NOT warn when identity is selected for a recognized Azure endpoint", async () => {
     const user = userEvent.setup();
 
     render(
@@ -741,15 +762,15 @@ describe("CreateTargetDialog", () => {
     });
 
     await user.click(
-      screen.getByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.getByRole("radio", { name: /Identity-based/ })
     );
 
     expect(
-      screen.queryByText(/Entra auth only works with Azure OpenAI/)
+      screen.queryByText(/Identity-based auth only works with Azure OpenAI/)
     ).not.toBeInTheDocument();
   });
 
-  it("should disable Create Target and skip API call for Entra + non-Azure OpenAI endpoint", async () => {
+  it("should disable Create Target and skip API call for identity + non-Azure OpenAI endpoint", async () => {
     const user = userEvent.setup();
 
     render(
@@ -766,7 +787,7 @@ describe("CreateTargetDialog", () => {
     fireEvent.change(endpointInput, { target: { value: "https://api.test.com/" } });
 
     await user.click(
-      screen.getByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.getByRole("radio", { name: /Identity-based/ })
     );
 
     const createButton = screen.getByText("Create Target").closest("button");
@@ -777,7 +798,7 @@ describe("CreateTargetDialog", () => {
     expect(mockedTargetsApi.createTarget).not.toHaveBeenCalled();
   });
 
-  it("should warn the user when Entra is selected for a non-AML endpoint on AzureMLChatTarget", async () => {
+  it("should warn the user when identity is selected for a non-AML endpoint on AzureMLChatTarget", async () => {
     const user = userEvent.setup();
 
     render(
@@ -796,17 +817,17 @@ describe("CreateTargetDialog", () => {
     });
 
     await user.click(
-      screen.getByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.getByRole("radio", { name: /Identity-based/ })
     );
 
     expect(
       screen.getByText(
-        /Entra auth for AzureMLChatTarget only works with Azure ML managed online endpoints/
+        /Identity-based auth for AzureMLChatTarget only works with Azure ML managed online endpoints/
       )
     ).toBeInTheDocument();
   });
 
-  it("should NOT warn when Entra is selected for a recognized AML endpoint", async () => {
+  it("should NOT warn when identity is selected for a recognized AML endpoint", async () => {
     const user = userEvent.setup();
 
     render(
@@ -825,17 +846,17 @@ describe("CreateTargetDialog", () => {
     });
 
     await user.click(
-      screen.getByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.getByRole("radio", { name: /Identity-based/ })
     );
 
     expect(
       screen.queryByText(
-        /Entra auth for AzureMLChatTarget only works with Azure ML managed online endpoints/
+        /Identity-based auth for AzureMLChatTarget only works with Azure ML managed online endpoints/
       )
     ).not.toBeInTheDocument();
   });
 
-  it("should disable Create Target and skip API call for Entra + non-AML endpoint on AzureMLChatTarget", async () => {
+  it("should disable Create Target and skip API call for identity + non-AML endpoint on AzureMLChatTarget", async () => {
     const user = userEvent.setup();
 
     render(
@@ -854,7 +875,7 @@ describe("CreateTargetDialog", () => {
     });
 
     await user.click(
-      screen.getByRole("radio", { name: /Microsoft Entra Authentication/ })
+      screen.getByRole("radio", { name: /Identity-based/ })
     );
 
     const createButton = screen.getByText("Create Target").closest("button");
@@ -873,18 +894,18 @@ describe("CreateTargetDialog", () => {
         <CreateTargetDialog
           {...defaultProps}
           existingTargets={[
-            {
+            makeTarget({
               target_registry_name: "openai_a",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               endpoint: "https://a.openai.azure.com",
-            },
-            {
+            }),
+            makeTarget({
               target_registry_name: "openai_b",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               endpoint: "https://b.openai.azure.com",
-            },
+            }),
           ]}
         />
       </TestWrapper>
@@ -909,11 +930,11 @@ describe("CreateTargetDialog", () => {
         <CreateTargetDialog
           {...defaultProps}
           existingTargets={[
-            {
+            makeTarget({
               target_registry_name: "openai_a",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
-            },
+            }),
           ]}
         />
       </TestWrapper>
@@ -936,27 +957,27 @@ describe("CreateTargetDialog", () => {
         <CreateTargetDialog
           {...defaultProps}
           existingTargets={[
-            {
+            makeTarget({
               target_registry_name: "openai_a",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               underlying_model_name: "gpt-4o",
               identifier_hash: "hash-a",
-            },
-            {
+            }),
+            makeTarget({
               target_registry_name: "openai_a_alias",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               underlying_model_name: "gpt-4o",
               identifier_hash: "hash-a",
-            },
-            {
+            }),
+            makeTarget({
               target_registry_name: "openai_b",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               underlying_model_name: "gpt-4o",
               identifier_hash: "hash-b",
-            },
+            }),
           ]}
         />
       </TestWrapper>
@@ -991,24 +1012,24 @@ describe("CreateTargetDialog", () => {
         <CreateTargetDialog
           {...defaultProps}
           existingTargets={[
-            {
+            makeTarget({
               target_registry_name: "foundry_a",
               target_type: "OpenAIChatTarget",
               model_name: "DeepSeek-R1",
               identifier_hash: "hash-a",
-            },
-            {
+            }),
+            makeTarget({
               target_registry_name: "foundry_b",
               target_type: "OpenAIChatTarget",
               model_name: "Gemini",
               identifier_hash: "hash-b",
-            },
-            {
+            }),
+            makeTarget({
               target_registry_name: "foundry_c",
               target_type: "OpenAIChatTarget",
               model_name: "DeepSeek-R1",
               identifier_hash: "hash-c",
-            },
+            }),
           ]}
         />
       </TestWrapper>
@@ -1049,18 +1070,18 @@ describe("CreateTargetDialog", () => {
         <CreateTargetDialog
           {...defaultProps}
           existingTargets={[
-            {
+            makeTarget({
               target_registry_name: "a",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               identifier_hash: "hash-a",
-            },
-            {
+            }),
+            makeTarget({
               target_registry_name: "b",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               identifier_hash: "hash-b",
-            },
+            }),
           ]}
         />
       </TestWrapper>
@@ -1100,18 +1121,18 @@ describe("CreateTargetDialog", () => {
         <CreateTargetDialog
           {...defaultProps}
           existingTargets={[
-            {
+            makeTarget({
               target_registry_name: "a",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               identifier_hash: "hash-a",
-            },
-            {
+            }),
+            makeTarget({
               target_registry_name: "b",
               target_type: "OpenAIChatTarget",
               model_name: "gpt-4o",
               identifier_hash: "hash-b",
-            },
+            }),
           ]}
         />
       </TestWrapper>
@@ -1199,6 +1220,7 @@ describe("CreateTargetDialog", () => {
     );
     const call = mockedTargetsApi.createTarget.mock.calls[0][0];
     expect(call.type).toBe("RoundRobinTarget");
+    expect(call.params?.targets).toEqual(["a", "b"]);
     expect(call.params?.weights).toEqual([7, 42]);
   }, 30000);
 
diff --git a/frontend/src/components/Config/CreateTargetDialog.tsx b/frontend/src/components/Config/CreateTargetDialog.tsx
index 2c39e1666a..9fcfebcd2d 100644
--- a/frontend/src/components/Config/CreateTargetDialog.tsx
+++ b/frontend/src/components/Config/CreateTargetDialog.tsx
@@ -23,32 +23,56 @@ import {
 import { DeleteRegular } from '@fluentui/react-icons'
 import { targetsApi } from '@/services/api'
 import { toApiError } from '@/services/errors'
-import type { TargetInstance } from '@/types'
+import type { TargetInstance, TargetCatalogEntry } from '@/types'
+import {
+  targetIdentifierHash,
+  targetModelName,
+  targetType as getTargetType,
+  targetUnderlyingModelName,
+} from '@/utils/targetIdentity'
 import { useCreateTargetDialogStyles } from './CreateTargetDialog.styles'
 import { MAX_WEIGHT, parseWeight } from './weightValidation'
 
-interface TargetTypeConfig {
-  readonly kind: 'openai' | 'azureml' | 'roundrobin'
-  readonly supportsEntra: boolean
+/**
+ * Form shape for each target type the dialog knows how to render.
+ *
+ * The dialog renders bespoke, type-specific forms (endpoint/model for OpenAI,
+ * extra sampling params for Azure ML, an inner-target picker for RoundRobin),
+ * so this map declares *which* types are renderable and *how*. The list of
+ * available types and their auth flags come from the backend catalog
+ * (`/targets/catalog`); this map only governs the form layout. Types the
+ * backend offers but that aren't in this map are simply not shown, and types in
+ * this map that the backend doesn't offer fall back to being listed anyway
+ * (e.g. when the catalog fetch fails).
+ */
+type TargetFormShape = 'openai' | 'azureml' | 'roundrobin'
+
+const TARGET_FORM_SHAPES: Record<string, TargetFormShape> = {
+  OpenAIChatTarget: 'openai',
+  OpenAICompletionTarget: 'openai',
+  OpenAIImageTarget: 'openai',
+  OpenAIVideoTarget: 'openai',
+  OpenAITTSTarget: 'openai',
+  OpenAIResponseTarget: 'openai',
+  AzureMLChatTarget: 'azureml',
+  RoundRobinTarget: 'roundrobin',
 }
 
-const TARGET_TYPE_CONFIG: Record<string, TargetTypeConfig> = {
-  OpenAIChatTarget: { kind: 'openai', supportsEntra: true },
-  OpenAICompletionTarget: { kind: 'openai', supportsEntra: true },
-  OpenAIImageTarget: { kind: 'openai', supportsEntra: true },
-  OpenAIVideoTarget: { kind: 'openai', supportsEntra: true },
-  OpenAITTSTarget: { kind: 'openai', supportsEntra: true },
-  OpenAIResponseTarget: { kind: 'openai', supportsEntra: true },
-  AzureMLChatTarget: { kind: 'azureml', supportsEntra: true },
-  RoundRobinTarget: { kind: 'roundrobin', supportsEntra: false },
-}
+const RENDERABLE_TARGET_TYPES = Object.keys(TARGET_FORM_SHAPES)
 
-const SUPPORTED_TARGET_TYPES = Object.keys(TARGET_TYPE_CONFIG)
+type AuthMode = 'api_key' | 'identity'
 
-type AuthMode = 'api_key' | 'entra'
+/**
+ * Fallback for whether a target type supports identity-based auth when the
+ * backend catalog hasn't loaded (or the fetch failed). Once the catalog is
+ * available it is authoritative; this only keeps the form usable offline / mid-load.
+ */
+function defaultSupportsIdentity(shape: TargetFormShape | undefined): boolean {
+  return shape === 'openai' || shape === 'azureml'
+}
 
 // Mirrors backend's hostname-suffix check (list in target_service.py).
-// The backend still does the check and will reject unsupported endpoints, but this allows us to show a warning in the UI if the user selects Microsoft Entra authentication with a non-Azure OpenAI endpoint.
+// The backend still does the check and will reject unsupported endpoints, but this allows us to show a warning in the UI if the user selects identity-based authentication with a non-Azure OpenAI endpoint.
 const AZURE_OPENAI_HOSTNAME_SUFFIXES = [
   '.openai.azure.com',
   '.ai.azure.com',
@@ -115,7 +139,7 @@ interface SelectedInnerTarget {
  * TestFrontendBackendCompatibilitySync test guards against drift.
  */
 function effectiveUnderlyingModel(t: TargetInstance): string | null {
-  return t.underlying_model_name || t.model_name || null
+  return targetUnderlyingModelName(t) || targetModelName(t) || null
 }
 
 /**
@@ -131,10 +155,10 @@ function effectiveUnderlyingModel(t: TargetInstance): string | null {
  */
 function isCompatible(a: TargetInstance, b: TargetInstance): boolean {
   return (
-    a.target_type === b.target_type &&
+    getTargetType(a) === getTargetType(b) &&
     effectiveUnderlyingModel(a) === effectiveUnderlyingModel(b) &&
-    (a.temperature ?? null) === (b.temperature ?? null) &&
-    (a.top_p ?? null) === (b.top_p ?? null)
+    (a.identifier.temperature ?? null) === (b.identifier.temperature ?? null) &&
+    (a.identifier.top_p ?? null) === (b.identifier.top_p ?? null)
   )
 }
 
@@ -161,24 +185,60 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
   // Targets the user has picked for the RoundRobinTarget, with their weights.
   const [selectedInnerTargets, setSelectedInnerTargets] = useState<SelectedInnerTarget[]>([])
 
-  const targetConfig = TARGET_TYPE_CONFIG[targetType]
-  const isRoundRobin = targetConfig?.kind === 'roundrobin'
-  const isAzureML = targetConfig?.kind === 'azureml'
-  const isOpenAi = targetConfig?.kind === 'openai'
-  const supportsEntra = targetConfig?.supportsEntra ?? false
-  const showAuthField = targetType !== '' && supportsEntra
-  const isEntra = showAuthField && authMode === 'entra'
-  const entraEndpointError: string | null = (() => {
-    if (!isEntra || endpoint === '') return null
+  // --- Catalog state ---
+  // Available target types + their auth facts, fetched from the backend registry.
+  const [catalogEntries, setCatalogEntries] = useState<TargetCatalogEntry[]>([])
+  const catalogByType = useMemo(
+    () => new Map(catalogEntries.map((entry) => [entry.target_type, entry])),
+    [catalogEntries],
+  )
+
+  // Fetch the target catalog once when the dialog opens. The backend is the
+  // authority on which types exist and which auth modes they support.
+  useEffect(() => {
+    if (!open) return
+    let cancelled = false
+    targetsApi.listTargetCatalog()
+      .then((res) => {
+        if (!cancelled) setCatalogEntries(res.items)
+      })
+      .catch(() => {
+        // Ignore fetch errors — fall back to the locally-known renderable types.
+      })
+    return () => { cancelled = true }
+  }, [open])
+
+  // The types offered in the dropdown: catalog types the dialog can render,
+  // preserving catalog order. Fall back to the locally-known types when the
+  // catalog hasn't loaded (or the fetch failed) so the form stays usable.
+  const targetTypeOptions = useMemo(() => {
+    const fromCatalog = catalogEntries
+      .map((entry) => entry.target_type)
+      .filter((type) => type in TARGET_FORM_SHAPES)
+    return fromCatalog.length > 0 ? fromCatalog : RENDERABLE_TARGET_TYPES
+  }, [catalogEntries])
+
+  const formShape = TARGET_FORM_SHAPES[targetType]
+  const isRoundRobin = formShape === 'roundrobin'
+  const isAzureML = formShape === 'azureml'
+  const isOpenAi = formShape === 'openai'
+  const catalogEntry = catalogByType.get(targetType)
+  const supportsIdentity = catalogEntry
+    ? catalogEntry.supported_auth_modes.includes('identity')
+    : defaultSupportsIdentity(formShape)
+  const showAuthField = targetType !== '' && supportsIdentity
+  const isIdentity = showAuthField && authMode === 'identity'
+  const identityEndpointError: string | null = (() => {
+    if (!isIdentity || endpoint === '') return null
     if (isOpenAi && !isAzureOpenAiEndpoint(endpoint)) {
-      return 'Entra auth only works with Azure OpenAI / AI Foundry endpoints (for example, *.openai.azure.com or *.ai.azure.com).'
+      return 'Identity-based auth only works with Azure OpenAI / AI Foundry endpoints (for example, *.openai.azure.com or *.ai.azure.com).'
     }
     if (isAzureML && !isAzureMlEndpoint(endpoint)) {
-      return 'Entra auth for AzureMLChatTarget only works with Azure ML managed online endpoints (for example, *.inference.ml.azure.com).'
+      return 'Identity-based auth for AzureMLChatTarget only works with Azure ML managed online endpoints (for example, *.inference.ml.azure.com).'
     }
     return null
   })()
-  const showEntraEndpointError = entraEndpointError !== null
+  const showIdentityEndpointError = identityEndpointError !== null
 
   // Fetch the available targets when the dialog opens with RoundRobin selected.
   // If the parent already passed targets, derive availableTargets from them
@@ -219,14 +279,17 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
     const selectedNames = new Set(selectedInnerTargets.map((t) => t.registryName))
     const selectedHashes = new Set(
       selectedInnerTargets
-        .map((sel) => availableTargets.find((t) => t.target_registry_name === sel.registryName)?.identifier_hash)
+        .map((sel) => {
+          const t = availableTargets.find((t) => t.target_registry_name === sel.registryName)
+          return t ? targetIdentifierHash(t) : null
+        })
         .filter((h): h is string => Boolean(h)),
     )
     const candidates = availableTargets.filter(
       (t) =>
-        t.target_type !== 'RoundRobinTarget' &&
+        getTargetType(t) !== 'RoundRobinTarget' &&
         !selectedNames.has(t.target_registry_name) &&
-        !(t.identifier_hash && selectedHashes.has(t.identifier_hash)),
+        !(targetIdentifierHash(t) && selectedHashes.has(targetIdentifierHash(t)!)),
     )
     // If nothing is selected yet, all non-RRT candidates are eligible
     if (selectedInnerTargets.length === 0) return candidates
@@ -301,7 +364,7 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
         await targetsApi.createTarget({
           type: 'RoundRobinTarget',
           params: {
-            target_registry_names: selectedInnerTargets.map((t) => t.registryName),
+            targets: selectedInnerTargets.map((t) => t.registryName),
             weights: parsedWeights,
           },
         })
@@ -334,7 +397,7 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
         endpoint,
       }
       if (modelName) params.model_name = modelName
-      if (!isEntra && apiKey) params.api_key = apiKey
+      if (!isIdentity && apiKey) params.api_key = apiKey
 
       if (hasDifferentUnderlying && underlyingModel) params.underlying_model = underlyingModel
 
@@ -352,7 +415,7 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
       await targetsApi.createTarget({
         type: targetType,
         params,
-        ...(isEntra ? { auth_mode: 'entra' as const } : {}),
+        ...(isIdentity ? { auth_mode: 'identity' as const } : {}),
       })
 
       resetForm()
@@ -390,13 +453,17 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
                   onChange={(_, data) => {
                     const next = data.value
                     setTargetType(next)
-                    if (!(TARGET_TYPE_CONFIG[next]?.supportsEntra ?? false)) {
+                    const nextEntry = catalogByType.get(next)
+                    const nextSupportsIdentity = nextEntry
+                      ? nextEntry.supported_auth_modes.includes('identity')
+                      : defaultSupportsIdentity(TARGET_FORM_SHAPES[next])
+                    if (!nextSupportsIdentity) {
                       setAuthMode('api_key')
                     }
                   }}
                 >
                   <option value="">Select a target type</option>
-                  {SUPPORTED_TARGET_TYPES.map((type) => (
+                  {targetTypeOptions.map((type) => (
                     <option key={type} value={type}>{type}</option>
                   ))}
                 </Select>
@@ -420,8 +487,8 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
                       </option>
                       {eligibleTargets.map((t) => (
                         <option key={t.target_registry_name} value={t.target_registry_name}>
-                          {t.target_registry_name} — {t.target_type}
-                          {t.model_name ? ` (${t.model_name})` : ''}
+                          {t.target_registry_name} — {getTargetType(t)}
+                          {targetModelName(t) ? ` (${targetModelName(t)})` : ''}
                         </option>
                       ))}
                     </Select>
@@ -450,7 +517,7 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
                                 <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
                                   <Text size={200} style={{ flex: 1, overflow: 'hidden', textOverflow: 'ellipsis' }}>
                                     {target?.target_registry_name ?? sel.registryName}
-                                    {target?.model_name ? ` (${target.model_name})` : ''}
+                                    {target && targetModelName(target) ? ` (${targetModelName(target)})` : ''}
                                   </Text>
                                   <div style={{ display: 'flex', alignItems: 'center', gap: '4px' }}>
                                     <Label size="small">Weight:</Label>
@@ -596,24 +663,24 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
                     onChange={(_, data) => {
                       const next = data.value as AuthMode
                       setAuthMode(next)
-                      if (next === 'entra') setApiKey('')
+                      if (next === 'identity') setApiKey('')
                     }}
                   >
                     <Radio value="api_key" label="API Key" />
-                    <Radio value="entra" label="Microsoft Entra Authentication" />
+                    <Radio value="identity" label="Identity-based (Microsoft Entra ID)" />
                   </RadioGroup>
                 </Field>
               )}
 
-              {showEntraEndpointError && (
+              {showIdentityEndpointError && (
                 <MessageBar intent="error" className={styles.warningMessage}>
                   <MessageBarBody className={styles.warningMessageBody}>
-                    {entraEndpointError}
+                    {identityEndpointError}
                   </MessageBarBody>
                 </MessageBar>
               )}
 
-              {!isEntra && (
+              {!isIdentity && (
                 <Field label="API Key">
                   <Input
                     type="password"
@@ -653,7 +720,7 @@ export default function CreateTargetDialog({ open, onClose, onCreated, existingT
                 (isRoundRobin
                   ? selectedInnerTargets.length < 2 ||
                     selectedInnerTargets.some((t) => !parseWeight(t.weightInput).ok)
-                  : !endpoint || showEntraEndpointError)
+                  : !endpoint || showIdentityEndpointError)
               }
             >
               {submitting ? 'Creating...' : 'Create Target'}
diff --git a/frontend/src/components/Config/TargetConfig.test.tsx b/frontend/src/components/Config/TargetConfig.test.tsx
index c798373087..8aed790042 100644
--- a/frontend/src/components/Config/TargetConfig.test.tsx
+++ b/frontend/src/components/Config/TargetConfig.test.tsx
@@ -1,6 +1,7 @@
 import { render, screen, waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { FluentProvider, webLightTheme } from "@fluentui/react-components";
+import { makeTarget } from "@/test-utils/targetFixtures";
 import TargetConfig from "./TargetConfig";
 import { targetsApi } from "../../services/api";
 import type { TargetInstance } from "../../types";
@@ -48,18 +49,18 @@ const TestWrapper: React.FC<{ children: React.ReactNode }> = ({
 }) => <FluentProvider theme={webLightTheme}>{children}</FluentProvider>;
 
 const sampleTargets: TargetInstance[] = [
-  {
+  makeTarget({
     target_registry_name: "openai_chat_gpt4",
     target_type: "OpenAIChatTarget",
     endpoint: "https://api.openai.com",
     model_name: "gpt-4",
-  },
-  {
+  }),
+  makeTarget({
     target_registry_name: "openai_image_dalle",
     target_type: "OpenAIImageTarget",
     endpoint: "https://api.openai.com",
     model_name: "dall-e-3",
-  },
+  }),
 ];
 
 describe("TargetConfig", () => {
@@ -281,7 +282,7 @@ describe("TargetConfig", () => {
 
   it("should display target_specific_params like reasoning_effort", async () => {
     const targetsWithParams: TargetInstance[] = [
-      {
+      makeTarget({
         target_registry_name: "azure_responses",
         target_type: "OpenAIResponseTarget",
         endpoint: "https://api.openai.com",
@@ -291,7 +292,7 @@ describe("TargetConfig", () => {
           reasoning_summary: "auto",
           max_output_tokens: 4096,
         },
-      },
+      }),
     ];
 
     mockedTargetsApi.listTargets.mockResolvedValue({
@@ -316,12 +317,12 @@ describe("TargetConfig", () => {
 
   it("should show dash when no target_specific_params", async () => {
     const targetsNoParams: TargetInstance[] = [
-      {
+      makeTarget({
         target_registry_name: "simple_target",
         target_type: "TextTarget",
         endpoint: "http://localhost",
         model_name: "text",
-      },
+      }),
     ];
 
     mockedTargetsApi.listTargets.mockResolvedValue({
diff --git a/frontend/src/components/Config/TargetTable.test.tsx b/frontend/src/components/Config/TargetTable.test.tsx
index 17408d6d3c..3cdd3b5025 100644
--- a/frontend/src/components/Config/TargetTable.test.tsx
+++ b/frontend/src/components/Config/TargetTable.test.tsx
@@ -1,5 +1,6 @@
 import { render, screen, fireEvent } from '@testing-library/react'
 import { FluentProvider, webLightTheme } from '@fluentui/react-components'
+import { makeTarget } from '@/test-utils/targetFixtures'
 import TargetTable from './TargetTable'
 import type { TargetInstance } from '../../types'
 
@@ -12,7 +13,7 @@ const TestWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (
 )
 
 const sampleTargets: TargetInstance[] = [
-  {
+  makeTarget({
     target_registry_name: 'openai_chat_gpt4',
     target_type: 'OpenAIChatTarget',
     endpoint: 'https://api.openai.com',
@@ -27,8 +28,8 @@ const sampleTargets: TargetInstance[] = [
       supported_input_modalities: ['text', 'image_path'],
       supported_output_modalities: ['text'],
     },
-  },
-  {
+  }),
+  makeTarget({
     target_registry_name: 'azure_image_dalle',
     target_type: 'AzureImageTarget',
     endpoint: 'https://azure.openai.com',
@@ -43,13 +44,13 @@ const sampleTargets: TargetInstance[] = [
       supported_input_modalities: ['text'],
       supported_output_modalities: ['image_path'],
     },
-  },
-  {
+  }),
+  makeTarget({
     target_registry_name: 'text_target_basic',
     target_type: 'TextTarget',
     endpoint: null,
     model_name: null,
-  },
+  }),
 ]
 
 describe('TargetTable', () => {
@@ -211,7 +212,7 @@ describe('TargetTable', () => {
   })
 
   it('should render modality icons in canonical order: text, image, audio, video, reasoning, function_call, tool_call', () => {
-    const target: TargetInstance = {
+    const target: TargetInstance = makeTarget({
       target_registry_name: 'multi_modal',
       target_type: 'CustomTarget',
       endpoint: null,
@@ -235,7 +236,7 @@ describe('TargetTable', () => {
         ],
         supported_output_modalities: ['text'],
       },
-    }
+    })
     render(
       <TestWrapper>
         <TargetTable {...defaultProps} targets={[target]} />
@@ -256,7 +257,7 @@ describe('TargetTable', () => {
 
   it('should display target_specific_params when present', () => {
     const targetWithParams: TargetInstance[] = [
-      {
+      makeTarget({
         target_registry_name: 'param_target',
         target_type: 'OpenAIResponseTarget',
         endpoint: 'https://api.openai.com',
@@ -265,7 +266,7 @@ describe('TargetTable', () => {
           reasoning_effort: 'high',
           max_output_tokens: 4096,
         },
-      },
+      }),
     ]
 
     render(
@@ -280,13 +281,13 @@ describe('TargetTable', () => {
 
   it('should show tooltip for model with different underlying model', () => {
     const targetWithUnderlying: TargetInstance[] = [
-      {
+      makeTarget({
         target_registry_name: 'azure_deployment',
         target_type: 'OpenAIChatTarget',
         endpoint: 'https://azure.openai.com',
         model_name: 'my-gpt4o-deployment',
         underlying_model_name: 'gpt-4o',
-      },
+      }),
     ]
 
     render(
@@ -346,7 +347,7 @@ describe('TargetTable', () => {
   })
 
   it('should show expand button for RoundRobinTarget with inner targets', () => {
-    const rrTarget: TargetInstance = {
+    const rrTarget: TargetInstance = makeTarget({
       target_registry_name: 'rr_gpt4o',
       target_type: 'RoundRobinTarget',
       model_name: 'gpt-4o',
@@ -365,7 +366,7 @@ describe('TargetTable', () => {
           model_name: 'gpt-4o',
         },
       ],
-    }
+    })
 
     render(
       <TestWrapper>
diff --git a/frontend/src/components/Config/TargetTable.tsx b/frontend/src/components/Config/TargetTable.tsx
index 79d1df3777..d78f807721 100644
--- a/frontend/src/components/Config/TargetTable.tsx
+++ b/frontend/src/components/Config/TargetTable.tsx
@@ -30,6 +30,7 @@ import {
   ChevronDownRegular,
 } from '@fluentui/react-icons'
 import type { TargetInstance } from '../../types'
+import { targetEndpoint, targetModelName, targetType, targetUnderlyingModelName } from '../../utils/targetIdentity'
 import { useTargetTableStyles } from './TargetTable.styles'
 
 interface TargetTableProps {
@@ -156,15 +157,17 @@ function CapabilityCell({ value }: { value: boolean | undefined }) {
 
 /** Render the model cell with a tooltip when underlying model differs. */
 function ModelCell({ target }: { target: TargetInstance }) {
-  const displayName = target.model_name || '—'
-  const hasUnderlying = target.underlying_model_name
-    && target.model_name
-    && target.underlying_model_name !== target.model_name
+  const modelName = targetModelName(target)
+  const underlyingModelName = targetUnderlyingModelName(target)
+  const displayName = modelName || '—'
+  const hasUnderlying = underlyingModelName
+    && modelName
+    && underlyingModelName !== modelName
 
   if (hasUnderlying) {
     return (
       <Tooltip
-        content={`Underlying model: ${target.underlying_model_name}`}
+        content={`Underlying model: ${underlyingModelName}`}
         relationship="description"
       >
         <Text size={200} style={{ textDecoration: 'underline dotted', cursor: 'help' }}>
@@ -209,14 +212,14 @@ function InnerTargetRows({ parentKey, innerTargets, weights }: {
             <Text size={200} style={{ paddingLeft: '28px' }}>#{idx + 1}</Text>
           </TableCell>
           <TableCell>
-            <Text size={200}>{inner.target_type}</Text>
+            <Text size={200}>{targetType(inner)}</Text>
           </TableCell>
           <TableCell>
             <ModelCell target={inner} />
           </TableCell>
           <TableCell>
-            <Text size={200} className={styles.endpointCell} title={inner.endpoint || undefined}>
-              {inner.endpoint || '—'}
+            <Text size={200} className={styles.endpointCell} title={targetEndpoint(inner) || undefined}>
+              {targetEndpoint(inner) || '—'}
             </Text>
           </TableCell>
           <TableCell className={styles.inputsModalityCell}>
@@ -261,12 +264,12 @@ export default function TargetTable({ targets, activeTarget, onSetActiveTarget }
     (target.inner_targets ?? []).length > 0
 
   const targetTypes = useMemo(
-    () => Array.from(new Set(targets.map(t => t.target_type))).sort(),
+    () => Array.from(new Set(targets.map(t => targetType(t)))).sort(),
     [targets],
   )
 
   const filteredTargets = useMemo(
-    () => typeFilter ? targets.filter(t => t.target_type === typeFilter) : targets,
+    () => typeFilter ? targets.filter(t => targetType(t) === typeFilter) : targets,
     [targets, typeFilter],
   )
 
@@ -293,15 +296,15 @@ export default function TargetTable({ targets, activeTarget, onSetActiveTarget }
                       aria-label={expandedRows.has(activeTarget.target_registry_name) ? 'Collapse inner targets' : 'Expand inner targets'}
                     />
                   )}
-                  <Text size={200}>{activeTarget.target_type}</Text>
+                  <Text size={200}>{targetType(activeTarget)}</Text>
                 </div>
               </TableCell>
               <TableCell style={{ width: '160px' }}>
                 <ModelCell target={activeTarget} />
               </TableCell>
               <TableCell style={{ width: '450px' }}>
-                <Text size={200} className={styles.endpointCell} title={activeTarget.endpoint || undefined}>
-                  {activeTarget.endpoint || '—'}
+                <Text size={200} className={styles.endpointCell} title={targetEndpoint(activeTarget) || undefined}>
+                  {targetEndpoint(activeTarget) || '—'}
                 </Text>
               </TableCell>
               <TableCell className={styles.inputsModalityCell}>
@@ -427,15 +430,15 @@ export default function TargetTable({ targets, activeTarget, onSetActiveTarget }
                           aria-label={expanded ? 'Collapse inner targets' : 'Expand inner targets'}
                         />
                       )}
-                      <Text size={200}>{target.target_type}</Text>
+                      <Text size={200}>{targetType(target)}</Text>
                     </div>
                   </TableCell>
                   <TableCell>
                     <ModelCell target={target} />
                   </TableCell>
                   <TableCell>
-                    <Text size={200} className={styles.endpointCell} title={target.endpoint || undefined}>
-                      {target.endpoint || '—'}
+                    <Text size={200} className={styles.endpointCell} title={targetEndpoint(target) || undefined}>
+                      {targetEndpoint(target) || '—'}
                     </Text>
                   </TableCell>
                   <TableCell className={styles.inputsModalityCell}>
diff --git a/frontend/src/components/Home/Home.test.tsx b/frontend/src/components/Home/Home.test.tsx
index 9938bf9c7e..e4776d9421 100644
--- a/frontend/src/components/Home/Home.test.tsx
+++ b/frontend/src/components/Home/Home.test.tsx
@@ -6,6 +6,7 @@
 import { render, screen, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { FluentProvider, webLightTheme } from "@fluentui/react-components";
+import { makeTarget } from "@/test-utils/targetFixtures";
 import Home from "./Home";
 import { attacksApi } from "../../services/api";
 import type { AttackSummary, TargetInstance } from "../../types";
@@ -75,12 +76,12 @@ describe("Home", () => {
   });
 
   it("renders active target summary and 'Manage targets' button when a target is set", async () => {
-    const target: TargetInstance = {
+    const target: TargetInstance = makeTarget({
       target_registry_name: "my_target",
       target_type: "OpenAIChatTarget",
       endpoint: "https://example.com",
       model_name: "gpt-test",
-    };
+    });
     render(<TestWrapper><Home {...defaultProps} activeTarget={target} /></TestWrapper>);
     expect(screen.getByTestId("home-target-active")).toHaveTextContent("gpt-test");
     expect(screen.getByRole("button", { name: /manage targets/i })).toBeInTheDocument();
diff --git a/frontend/src/components/Home/Home.tsx b/frontend/src/components/Home/Home.tsx
index 5ef8e844d4..c02df59814 100644
--- a/frontend/src/components/Home/Home.tsx
+++ b/frontend/src/components/Home/Home.tsx
@@ -21,6 +21,7 @@ import LabelsBar from '../Labels/LabelsBar'
 import { attacksApi } from '../../services/api'
 import { toApiError } from '../../services/errors'
 import type { AttackSummary, TargetInstance } from '../../types'
+import { targetEndpoint, targetModelName, targetType } from '../../utils/targetIdentity'
 import type { ViewName } from '../Sidebar/Navigation'
 import { useHomeStyles } from './Home.styles'
 
@@ -95,7 +96,7 @@ function formatRelativeTime(iso: string): string {
 }
 
 function targetDisplayName(target: TargetInstance): string {
-  return target.model_name || target.target_registry_name || target.target_type
+  return targetModelName(target) || target.target_registry_name || targetType(target)
 }
 
 export default function Home({
@@ -174,8 +175,8 @@ export default function Home({
                 <div className={styles.targetSummary} data-testid="home-target-active">
                   <Text className={styles.targetName}>{targetDisplayName(activeTarget)}</Text>
                   <Text size={200} className={styles.targetMeta}>
-                    {activeTarget.target_type}
-                    {activeTarget.endpoint ? ` · ${activeTarget.endpoint}` : ''}
+                    {targetType(activeTarget)}
+                    {targetEndpoint(activeTarget) ? ` · ${targetEndpoint(activeTarget)}` : ''}
                   </Text>
                 </div>
               ) : (
diff --git a/frontend/src/services/api.ts b/frontend/src/services/api.ts
index 3c04828cb0..5dfb44d8f0 100644
--- a/frontend/src/services/api.ts
+++ b/frontend/src/services/api.ts
@@ -5,6 +5,7 @@ import { getApiScopes } from '../auth/msalConfig'
 import type {
   TargetInstance,
   TargetListResponse,
+  TargetCatalogResponse,
   ConverterCatalogResponse,
   ConverterInstance,
   ConverterListResponse,
@@ -146,6 +147,11 @@ export const versionApi = {
 }
 
 export const targetsApi = {
+  listTargetCatalog: async (): Promise<TargetCatalogResponse> => {
+    const response = await apiClient.get('/targets/catalog')
+    return response.data
+  },
+
   listTargets: async (limit = 50, cursor?: string): Promise<TargetListResponse> => {
     const params: Record<string, string | number> = { limit }
     if (cursor) params.cursor = cursor
diff --git a/frontend/src/test-utils/targetFixtures.ts b/frontend/src/test-utils/targetFixtures.ts
new file mode 100644
index 0000000000..540ae1e4bc
--- /dev/null
+++ b/frontend/src/test-utils/targetFixtures.ts
@@ -0,0 +1,44 @@
+import type { TargetCapabilities, TargetIdentifier, TargetInstance } from '../types'
+
+/**
+ * Flat description of a target for tests, mirroring the old pre-slimming
+ * `TargetInstance` shape. `makeTarget` folds the identity scalars into the
+ * embedded `identifier` so tests can stay readable while exercising the
+ * current nested wire model.
+ */
+export interface FlatTargetInput {
+  target_registry_name: string
+  target_type?: string
+  endpoint?: string | null
+  model_name?: string | null
+  underlying_model_name?: string | null
+  temperature?: number | null
+  top_p?: number | null
+  max_requests_per_minute?: number | null
+  identifier_hash?: string | null
+  identifier?: Partial<TargetIdentifier>
+  capabilities?: TargetCapabilities | null
+  target_specific_params?: Record<string, unknown> | null
+  inner_targets?: FlatTargetInput[] | null
+}
+
+export function makeTarget(flat: FlatTargetInput): TargetInstance {
+  const identifier: TargetIdentifier = {
+    class_name: flat.target_type ?? 'TextTarget',
+    hash: flat.identifier_hash ?? `${flat.target_registry_name}-hash`,
+    endpoint: flat.endpoint ?? null,
+    model_name: flat.model_name ?? null,
+    underlying_model_name: flat.underlying_model_name ?? null,
+    temperature: flat.temperature ?? null,
+    top_p: flat.top_p ?? null,
+    max_requests_per_minute: flat.max_requests_per_minute ?? null,
+    ...flat.identifier,
+  }
+  return {
+    target_registry_name: flat.target_registry_name,
+    identifier,
+    capabilities: flat.capabilities ?? null,
+    target_specific_params: flat.target_specific_params ?? null,
+    inner_targets: flat.inner_targets ? flat.inner_targets.map(makeTarget) : null,
+  }
+}
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 236a5e49d9..02465d4c7f 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -58,33 +58,43 @@ export interface PaginationInfo {
 
 // --- Targets ---
 
-export interface TargetCapabilitiesInfo {
+export interface TargetCapabilities {
   supports_multi_turn: boolean
-  supports_multi_message_pieces: boolean
+  supports_multi_message_pieces?: boolean
   supports_json_schema: boolean
   supports_json_output: boolean
-  supports_editable_history: boolean
+  supports_editable_history?: boolean
   supports_system_prompt: boolean
+  supports_streaming_audio?: boolean
   supported_input_modalities: string[]
   supported_output_modalities: string[]
 }
 
-export interface TargetInstance {
-  target_registry_name: string
-  target_type: string
+export interface TargetIdentifier {
+  class_name: string
+  class_module?: string
+  hash: string
+  pyrit_version?: string
   endpoint?: string | null
   model_name?: string | null
   underlying_model_name?: string | null
   temperature?: number | null
   top_p?: number | null
   max_requests_per_minute?: number | null
-  capabilities?: TargetCapabilitiesInfo | null
+  // Promoted + target-specific constructor params are inlined at the top level;
+  // inner target identifiers live under `__children__`.
+  [key: string]: unknown
+}
+
+export interface TargetInstance {
+  target_registry_name: string
+  /** Typed identity: class name, endpoint, model name, generation params, content hash. */
+  identifier: TargetIdentifier
+  capabilities?: TargetCapabilities | null
+  /** Non-promoted constructor params, curated for display (e.g., RoundRobin weights). */
   target_specific_params?: Record<string, unknown> | null
   /** Inner targets for composite targets like RoundRobinTarget. */
   inner_targets?: TargetInstance[] | null
-  /** ComponentIdentifier content hash. Targets with the same hash resolve to the
-   *  same backend configuration and are treated as duplicates for RoundRobinTarget grouping. */
-  identifier_hash?: string | null
 }
 
 export interface TargetListResponse {
@@ -95,7 +105,7 @@ export interface TargetListResponse {
 export interface CreateTargetRequest {
   type: string
   params: Record<string, unknown>
-  auth_mode?: 'api_key' | 'entra'
+  auth_mode?: 'api_key' | 'identity'
 }
 
 // --- Converters ---
@@ -143,6 +153,17 @@ export interface ConverterCatalogResponse {
   items: ConverterCatalogEntry[]
 }
 
+export interface TargetCatalogEntry {
+  target_type: string
+  parameters: Parameter[]
+  supported_auth_modes: ('api_key' | 'identity')[]
+  description?: string | null
+}
+
+export interface TargetCatalogResponse {
+  items: TargetCatalogEntry[]
+}
+
 // --- Attacks ---
 
 export interface TargetInfo {
diff --git a/frontend/src/utils/targetIdentity.test.ts b/frontend/src/utils/targetIdentity.test.ts
new file mode 100644
index 0000000000..57cfc609db
--- /dev/null
+++ b/frontend/src/utils/targetIdentity.test.ts
@@ -0,0 +1,89 @@
+import { makeTarget } from '../test-utils/targetFixtures'
+import {
+  targetEndpoint,
+  targetIdentifierHash,
+  targetModelName,
+  targetType,
+  targetUnderlyingModelName,
+} from './targetIdentity'
+
+describe('targetIdentity', () => {
+  describe('targetType', () => {
+    it('returns the identifier class name', () => {
+      const target = makeTarget({ target_registry_name: 'openai_1', target_type: 'OpenAIChatTarget' })
+      expect(targetType(target)).toBe('OpenAIChatTarget')
+    })
+  })
+
+  describe('targetEndpoint', () => {
+    it('returns the endpoint when present', () => {
+      const target = makeTarget({ target_registry_name: 'openai_1', endpoint: 'https://example.openai.azure.com' })
+      expect(targetEndpoint(target)).toBe('https://example.openai.azure.com')
+    })
+
+    it('returns null when the endpoint is absent', () => {
+      const target = makeTarget({ target_registry_name: 'text_1' })
+      expect(targetEndpoint(target)).toBeNull()
+    })
+  })
+
+  describe('targetIdentifierHash', () => {
+    it('returns the identifier hash', () => {
+      const target = makeTarget({ target_registry_name: 'text_1', identifier_hash: 'abc123' })
+      expect(targetIdentifierHash(target)).toBe('abc123')
+    })
+  })
+
+  describe('targetModelName / targetUnderlyingModelName', () => {
+    it('returns the target own model name when set', () => {
+      const target = makeTarget({
+        target_registry_name: 'openai_1',
+        model_name: 'gpt-4o-deployment',
+        underlying_model_name: 'gpt-4o',
+      })
+      expect(targetModelName(target)).toBe('gpt-4o-deployment')
+      expect(targetUnderlyingModelName(target)).toBe('gpt-4o')
+    })
+
+    it('returns null when neither the target nor inner targets provide a value', () => {
+      const target = makeTarget({ target_registry_name: 'text_1' })
+      expect(targetModelName(target)).toBeNull()
+      expect(targetUnderlyingModelName(target)).toBeNull()
+    })
+
+    it('hoists a shared value from inner targets when they all agree', () => {
+      const composite = makeTarget({
+        target_registry_name: 'round_robin_1',
+        target_type: 'RoundRobinTarget',
+        inner_targets: [
+          { target_registry_name: 'inner_a', model_name: 'gpt-4o', underlying_model_name: 'gpt-4o' },
+          { target_registry_name: 'inner_b', model_name: 'gpt-4o', underlying_model_name: 'gpt-4o' },
+        ],
+      })
+      expect(targetModelName(composite)).toBe('gpt-4o')
+      expect(targetUnderlyingModelName(composite)).toBe('gpt-4o')
+    })
+
+    it('returns null when inner targets disagree', () => {
+      const composite = makeTarget({
+        target_registry_name: 'round_robin_1',
+        target_type: 'RoundRobinTarget',
+        inner_targets: [
+          { target_registry_name: 'inner_a', model_name: 'gpt-4o' },
+          { target_registry_name: 'inner_b', model_name: 'gpt-4o-mini' },
+        ],
+      })
+      expect(targetModelName(composite)).toBeNull()
+    })
+
+    it('prefers the target own value over inner targets', () => {
+      const composite = makeTarget({
+        target_registry_name: 'round_robin_1',
+        target_type: 'RoundRobinTarget',
+        model_name: 'explicit',
+        inner_targets: [{ target_registry_name: 'inner_a', model_name: 'gpt-4o' }],
+      })
+      expect(targetModelName(composite)).toBe('explicit')
+    })
+  })
+})
diff --git a/frontend/src/utils/targetIdentity.ts b/frontend/src/utils/targetIdentity.ts
new file mode 100644
index 0000000000..d49ec004ac
--- /dev/null
+++ b/frontend/src/utils/targetIdentity.ts
@@ -0,0 +1,51 @@
+import type { TargetInstance } from '../types'
+
+/**
+ * Helpers for reading a target's identity off its embedded `identifier`.
+ *
+ * `TargetInstance` no longer mirrors identity as flat fields — class name,
+ * endpoint, model name, and generation params all live on `identifier`. For
+ * composite targets (RoundRobinTarget) the identifier itself carries no model
+ * name, so the model helpers hoist a shared value from the inner targets when
+ * they all agree (mirroring how the backend used to present it).
+ */
+
+function hoistFromInner(
+  target: TargetInstance,
+  pick: (t: TargetInstance) => string | null | undefined,
+): string | null {
+  const own = pick(target)
+  if (own) return own
+
+  const inners = target.inner_targets ?? []
+  if (inners.length > 0) {
+    const values = new Set(inners.map(pick).filter((value): value is string => Boolean(value)))
+    if (values.size === 1) return [...values][0]
+  }
+  return null
+}
+
+/** The target class name (e.g., 'OpenAIChatTarget'). */
+export function targetType(target: TargetInstance): string {
+  return target.identifier.class_name
+}
+
+/** The deployment/model name, hoisted from inner targets for composite targets. */
+export function targetModelName(target: TargetInstance): string | null {
+  return hoistFromInner(target, (t) => t.identifier.model_name)
+}
+
+/** The underlying model name, hoisted from inner targets for composite targets. */
+export function targetUnderlyingModelName(target: TargetInstance): string | null {
+  return hoistFromInner(target, (t) => t.identifier.underlying_model_name)
+}
+
+/** The target endpoint URL, or null. */
+export function targetEndpoint(target: TargetInstance): string | null {
+  return (target.identifier.endpoint as string | null | undefined) ?? null
+}
+
+/** The ComponentIdentifier content hash used for duplicate detection. */
+export function targetIdentifierHash(target: TargetInstance): string | null {
+  return target.identifier.hash ?? null
+}
diff --git a/pyrit/auth/__init__.py b/pyrit/auth/__init__.py
index 3b17fcef61..ac37e89abf 100644
--- a/pyrit/auth/__init__.py
+++ b/pyrit/auth/__init__.py
@@ -15,6 +15,8 @@
     get_azure_openai_auth,
     get_azure_token_provider,
     get_default_azure_scope,
+    is_azure_ml_endpoint,
+    is_azure_openai_endpoint,
 )
 from pyrit.auth.azure_storage_auth import AzureStorageAuth
 from pyrit.auth.copilot_authenticator import CopilotAuthenticator
@@ -33,4 +35,6 @@
     "get_azure_async_token_provider",
     "get_default_azure_scope",
     "get_azure_openai_auth",
+    "is_azure_ml_endpoint",
+    "is_azure_openai_endpoint",
 ]
diff --git a/pyrit/auth/azure_auth.py b/pyrit/auth/azure_auth.py
index 8a6131d3a4..411f17504b 100644
--- a/pyrit/auth/azure_auth.py
+++ b/pyrit/auth/azure_auth.py
@@ -7,6 +7,7 @@
 import logging
 import time
 from typing import TYPE_CHECKING, Any, cast
+from urllib.parse import urlparse
 
 import msal
 from azure.core.credentials import AccessToken
@@ -32,6 +33,54 @@
 
 logger = logging.getLogger(__name__)
 
+# Recognised Azure OpenAI / AI Foundry hostname suffixes. Used for strict
+# endpoint validation before an Entra ID bearer token is minted, so a token is
+# only ever issued for a known Microsoft-operated endpoint (a substring check
+# such as ``"azure" in endpoint`` is not sufficient — anyone can host a domain
+# that merely contains "azure").
+_AZURE_OPENAI_HOSTNAME_SUFFIXES = (
+    ".openai.azure.com",
+    ".ai.azure.com",
+    ".services.ai.azure.com",
+    ".cognitiveservices.azure.com",
+)
+
+# Recognised Azure Machine Learning managed online endpoint hostname suffixes.
+_AZURE_ML_HOSTNAME_SUFFIXES = (".inference.ml.azure.com",)
+
+
+def is_azure_openai_endpoint(endpoint: str | None) -> bool:
+    """
+    Return True if ``endpoint`` resolves to a known Azure OpenAI / AI Foundry host.
+
+    Uses a strict hostname-suffix check (not a substring search) so an Entra ID
+    token is only minted for a Microsoft-operated endpoint.
+
+    Args:
+        endpoint (str | None): The endpoint URL to validate.
+
+    Returns:
+        bool: True if the endpoint's hostname ends with a recognised Azure suffix.
+    """
+    hostname = (urlparse(endpoint or "").hostname or "").lower()
+    return any(hostname.endswith(suffix) for suffix in _AZURE_OPENAI_HOSTNAME_SUFFIXES)
+
+
+def is_azure_ml_endpoint(endpoint: str | None) -> bool:
+    """
+    Return True if ``endpoint`` resolves to a known AML managed online host.
+
+    Uses a strict hostname-suffix check (not a substring search).
+
+    Args:
+        endpoint (str | None): The endpoint URL to validate.
+
+    Returns:
+        bool: True if the endpoint's hostname ends with a recognised AML suffix.
+    """
+    hostname = (urlparse(endpoint or "").hostname or "").lower()
+    return any(hostname.endswith(suffix) for suffix in _AZURE_ML_HOSTNAME_SUFFIXES)
+
 
 class TokenProviderCredential:
     """
diff --git a/pyrit/backend/mappers/target_mappers.py b/pyrit/backend/mappers/target_mappers.py
index efe89e13a4..c3b78792a4 100644
--- a/pyrit/backend/mappers/target_mappers.py
+++ b/pyrit/backend/mappers/target_mappers.py
@@ -4,60 +4,62 @@
 """
 Target mappers – domain → DTO translation for target-related models.
 
-Identity vs. presentation: ``TargetIdentifier``
-is the typed, lossless *identity* projection of a target's
-``ComponentIdentifier``. ``TargetInstance`` is the backend *presentation* view —
-it adds registry binding (``target_registry_name``), flattened capabilities, and
-composite ``inner_targets`` for the frontend. These mappers read typed fields off
-``TargetIdentifier`` instead of poking ``identifier.params`` by string key.
+Identity vs. presentation: ``TargetIdentifier`` is the typed, lossless *identity*
+projection of a target's ``ComponentIdentifier`` and is embedded directly on the
+``TargetInstance`` DTO. ``TargetInstance`` adds only the presentation concerns the
+identifier does not own: registry binding (``target_registry_name``), capabilities,
+composite ``inner_targets`` (full instances, not bare identifiers), and a curated
+``target_specific_params`` view of the non-promoted constructor params.
 """
 
+from typing import Any
+
 from pyrit.models import TargetIdentifier
-from pyrit.models.catalog.target import TargetCapabilitiesInfo, TargetInstance
+from pyrit.models.catalog.target import TargetInstance
 from pyrit.prompt_target import PromptTarget
-from pyrit.prompt_target.common.target_capabilities import CapabilityName, TargetCapabilities
-from pyrit.prompt_target.round_robin_target import RoundRobinTarget
+from pyrit.prompt_target.common.target_capabilities import CapabilityName
 
 # Capability flag names that should never be surfaced as identifier-level params:
 # they are sourced from `target_obj.capabilities` instead.
 _CAPABILITY_PARAM_NAMES = frozenset(cap.value for cap in CapabilityName)
 
 
-def _target_capabilities_to_info(
-    capabilities: TargetCapabilities,
-) -> TargetCapabilitiesInfo:
+def _target_specific_params(target_identifier: TargetIdentifier) -> dict[str, Any] | None:
     """
-    Build a TargetCapabilitiesInfo DTO from a domain TargetCapabilities object.
+    Collect the non-promoted constructor params for display.
 
-    Modality combinations are flattened into sorted unique modality lists since
-    the frontend uses them only for per-piece modality checks.
+    Promoted params (endpoint, model_name, …) are typed fields on the identifier;
+    capabilities are sourced separately. Everything else is surfaced here so the
+    frontend can show target-specific configuration (e.g., RoundRobin weights).
 
     Args:
-        capabilities: The domain TargetCapabilities object.
+        target_identifier: The typed identifier projection of the target.
 
     Returns:
-        TargetCapabilitiesInfo DTO mirroring the capability flags and flattened
-        input/output modalities.
+        A dict of curated target-specific params, or None when there are none.
     """
-    return TargetCapabilitiesInfo(
-        supports_multi_turn=capabilities.supports_multi_turn,
-        supports_multi_message_pieces=capabilities.supports_multi_message_pieces,
-        supports_json_schema=capabilities.supports_json_schema,
-        supports_json_output=capabilities.supports_json_output,
-        supports_editable_history=capabilities.supports_editable_history,
-        supports_system_prompt=capabilities.supports_system_prompt,
-        supports_streaming_audio=capabilities.supports_streaming_audio,
-        supported_input_modalities=sorted({str(t) for combo in capabilities.input_modalities for t in combo}),
-        supported_output_modalities=sorted({str(t) for combo in capabilities.output_modalities for t in combo}),
+    extracted_keys = (
+        {
+            "target_specific_params",
+            "target_configuration",
+        }
+        | _CAPABILITY_PARAM_NAMES
+        | set(TargetIdentifier._promoted_param_fields())
     )
 
+    raw_specific = target_identifier.params.get("target_specific_params")
+    explicit_specific = raw_specific if isinstance(raw_specific, dict) else {}
+    extra = {k: v for k, v in target_identifier.params.items() if k not in extracted_keys and v is not None}
+    return {**extra, **explicit_specific} or None
+
 
 def target_object_to_instance(target_registry_name: str, target_obj: PromptTarget) -> TargetInstance:
     """
     Build a TargetInstance DTO from a registry target object.
 
-    Extracts only the frontend-relevant fields from the internal identifier,
-    avoiding leakage of internal PyRIT core structures.
+    Identity is carried by the embedded ``identifier``; only presentation concerns
+    (registry name, capabilities, inner targets, curated specific params) are
+    derived here.
 
     Args:
         target_registry_name: The human-friendly target registry name.
@@ -68,55 +70,12 @@ def target_object_to_instance(target_registry_name: str, target_obj: PromptTarge
     """
     target_identifier = TargetIdentifier.from_component_identifier(target_obj.get_identifier())
 
-    # Promoted params (endpoint, model_name, …) are mirrored into params and also
-    # exposed as typed fields; strip them so they don't leak into
-    # target_specific_params. Capabilities are no longer part of the identifier at
-    # all. The strip set is also defensive: it drops the explicit
-    # target_specific_params bag (merged in separately) plus any legacy capability /
-    # configuration keys that might appear in older persisted identifiers.
-    extracted_keys = (
-        {
-            "target_specific_params",
-            "target_configuration",
-        }
-        | _CAPABILITY_PARAM_NAMES
-        | set(TargetIdentifier._promoted_param_fields())
-    )
-
-    # Collect remaining params as target_specific_params so the frontend can display them
-    raw_specific = target_identifier.params.get("target_specific_params")
-    explicit_specific = raw_specific if isinstance(raw_specific, dict) else {}
-    extra = {k: v for k, v in target_identifier.params.items() if k not in extracted_keys and v is not None}
-    combined_specific = {**extra, **explicit_specific} or None
-
-    inner_targets = _build_inner_targets(target_obj)
-
-    # For composite targets (RoundRobinTarget), hoist model_name from inner targets
-    # only when ALL inner targets share the same deployment name. When they differ
-    # (e.g. "gpt-4o-japan-nilfilter" vs "pyrit-github-gpt4"), show "—" for
-    # consistency with how other targets display model_name.
-    model_name = target_identifier.model_name or None
-    underlying_model_name = target_identifier.underlying_model_name or None
-    if model_name is None and inner_targets:
-        inner_models = {t.model_name for t in inner_targets}
-        model_name = inner_models.pop() if len(inner_models) == 1 else None
-    if underlying_model_name is None and inner_targets:
-        inner_underlying = {t.underlying_model_name for t in inner_targets}
-        underlying_model_name = inner_underlying.pop() if len(inner_underlying) == 1 else None
-
     return TargetInstance(
         target_registry_name=target_registry_name,
-        target_type=target_identifier.class_name,
-        endpoint=target_identifier.endpoint or None,
-        model_name=model_name,
-        underlying_model_name=underlying_model_name,
-        temperature=target_identifier.temperature,
-        top_p=target_identifier.top_p,
-        max_requests_per_minute=target_identifier.max_requests_per_minute,
-        capabilities=_target_capabilities_to_info(target_obj.capabilities),
-        target_specific_params=combined_specific,
-        inner_targets=inner_targets,
-        identifier_hash=target_identifier.hash,
+        identifier=target_identifier,
+        capabilities=target_obj.capabilities,
+        target_specific_params=_target_specific_params(target_identifier),
+        inner_targets=_build_inner_targets(target_obj),
     )
 
 
@@ -124,10 +83,12 @@ def _build_inner_targets(target_obj: PromptTarget) -> list[TargetInstance] | Non
     """
     Build inner target DTOs for composite targets like RoundRobinTarget.
 
-    For non-composite targets, returns None. For RoundRobinTarget, recursively
-    maps each inner target into a TargetInstance using the inner target's
-    ``unique_name`` as the registry name (inner targets may not be independently
-    registered in the registry, so we derive the name from the identifier).
+    Composite targets expose their children via a public ``inner_targets``
+    property; non-composite targets don't define one. The mapper stays generic —
+    it asks the target for its inner targets rather than knowing any concrete
+    composite type or reaching into private state — and recurses, deriving each
+    inner registry name from the inner target's ``unique_name`` (inner targets
+    may not be independently registered).
 
     Args:
         target_obj: The domain PromptTarget object.
@@ -135,11 +96,7 @@ def _build_inner_targets(target_obj: PromptTarget) -> list[TargetInstance] | Non
     Returns:
         A list of inner TargetInstance DTOs, or None for non-composite targets.
     """
-    if not isinstance(target_obj, RoundRobinTarget):
+    inner_targets = getattr(target_obj, "inner_targets", None)
+    if not inner_targets:
         return None
-
-    inner_instances: list[TargetInstance] = []
-    for inner_target in target_obj._targets:
-        inner_name = inner_target.get_identifier().unique_name
-        inner_instances.append(target_object_to_instance(inner_name, inner_target))
-    return inner_instances
+    return [target_object_to_instance(inner.get_identifier().unique_name, inner) for inner in inner_targets]
diff --git a/pyrit/backend/models/targets.py b/pyrit/backend/models/targets.py
index 3c3675c22b..87797d32d1 100644
--- a/pyrit/backend/models/targets.py
+++ b/pyrit/backend/models/targets.py
@@ -4,9 +4,8 @@
 """
 REST envelopes and write-request types for the target endpoints.
 
-Canonical target catalog types (``TargetInstance``, ``TargetCapabilitiesInfo``)
-live in ``pyrit.models.catalog.target`` and should be imported from there
-directly.
+Canonical target catalog types (``TargetInstance``) live in
+``pyrit.models.catalog.target`` and should be imported from there directly.
 """
 
 from typing import Literal
@@ -14,15 +13,42 @@
 from pydantic import BaseModel, Field
 
 from pyrit.backend.models.common import PaginationInfo
-from pyrit.models import JSONValue
+from pyrit.models import JSONValue, Parameter
 from pyrit.models.catalog.target import TargetInstance
 
 __all__ = [
     "CreateTargetRequest",
+    "TargetCatalogEntry",
+    "TargetCatalogResponse",
     "TargetListResponse",
 ]
 
 
+def _default_auth_modes() -> list[Literal["api_key", "identity"]]:
+    return ["api_key"]
+
+
+class TargetCatalogEntry(BaseModel):
+    """A target type available from the backend registry."""
+
+    target_type: str = Field(..., description="Target class name (e.g., 'OpenAIChatTarget')")
+    parameters: list[Parameter] = Field(
+        default_factory=list,
+        description="Constructor parameters for dynamic form generation",
+    )
+    supported_auth_modes: list[Literal["api_key", "identity"]] = Field(
+        default_factory=_default_auth_modes,
+        description="Authentication modes this target type supports",
+    )
+    description: str | None = Field(None, description="Short description of the target from its docstring")
+
+
+class TargetCatalogResponse(BaseModel):
+    """Response for listing available target types from the registry."""
+
+    items: list[TargetCatalogEntry] = Field(..., description="List of available target types")
+
+
 class TargetListResponse(BaseModel):
     """Response for listing target instances."""
 
@@ -35,11 +61,13 @@ class CreateTargetRequest(BaseModel):
 
     type: str = Field(..., description="Target type (e.g., 'OpenAIChatTarget')")
     params: dict[str, JSONValue] = Field(default_factory=dict, description="Target constructor parameters")
-    auth_mode: Literal["api_key", "entra"] = Field(
+    auth_mode: Literal["api_key", "identity"] = Field(
         "api_key",
         description=(
             "Authentication mode. 'api_key' uses the api_key in params (default). "
-            "'entra' uses Microsoft Entra ID; requires an Azure endpoint and is "
-            "supported by OpenAI-family targets and AzureMLChatTarget."
+            "'identity' omits the key so the target authenticates itself via an ambient "
+            "Azure identity (Entra ID token or DefaultAzureCredential); requires an Azure "
+            "endpoint and is supported by OpenAI-family targets, AzureMLChatTarget, "
+            "AzureBlobStorageTarget, and PromptShieldTarget."
         ),
     )
diff --git a/pyrit/backend/routes/targets.py b/pyrit/backend/routes/targets.py
index c55a6d9ff2..3bac8a23b7 100644
--- a/pyrit/backend/routes/targets.py
+++ b/pyrit/backend/routes/targets.py
@@ -13,6 +13,7 @@
 from pyrit.backend.models.common import ProblemDetail
 from pyrit.backend.models.targets import (
     CreateTargetRequest,
+    TargetCatalogResponse,
     TargetListResponse,
 )
 from pyrit.backend.services.target_service import get_target_service
@@ -44,15 +45,38 @@ async def list_targets(  # pyrit-async-suffix-exempt
     return await service.list_targets_async(limit=limit, cursor=cursor)
 
 
+@router.get(
+    "/catalog",
+    response_model=TargetCatalogResponse,
+    responses={
+        500: {"model": ProblemDetail, "description": "Internal server error"},
+    },
+)
+async def list_target_catalog() -> TargetCatalogResponse:  # pyrit-async-suffix-exempt
+    """
+    List all available target types from the backend target registry.
+
+    Returns:
+        TargetCatalogResponse: List of available target types.
+    """
+    service = get_target_service()
+    return await service.list_target_catalog_async()
+
+
 @router.post(
     "",
     response_model=TargetInstance,
     status_code=status.HTTP_201_CREATED,
     responses={
-        400: {"model": ProblemDetail, "description": "Invalid target type or parameters"},
+        400: {
+            "model": ProblemDetail,
+            "description": "Invalid target type or parameters",
+        },
     },
 )
-async def create_target(request: CreateTargetRequest) -> TargetInstance:  # pyrit-async-suffix-exempt
+async def create_target(
+    request: CreateTargetRequest,
+) -> TargetInstance:  # pyrit-async-suffix-exempt
     """
     Create a new target instance.
 
@@ -87,7 +111,9 @@ async def create_target(request: CreateTargetRequest) -> TargetInstance:  # pyri
         404: {"model": ProblemDetail, "description": "Target not found"},
     },
 )
-async def get_target(target_registry_name: str) -> TargetInstance:  # pyrit-async-suffix-exempt
+async def get_target(
+    target_registry_name: str,
+) -> TargetInstance:  # pyrit-async-suffix-exempt
     """
     Get a target instance by registry name.
 
diff --git a/pyrit/backend/services/target_service.py b/pyrit/backend/services/target_service.py
index 5e23bd9bad..1743e64145 100644
--- a/pyrit/backend/services/target_service.py
+++ b/pyrit/backend/services/target_service.py
@@ -13,158 +13,37 @@
 """
 
 import logging
-import os
 from functools import lru_cache
-from typing import Any, ClassVar
-from urllib.parse import urlparse
+from typing import Any, Literal, cast
 
-from pyrit import prompt_target
-from pyrit.auth import get_azure_async_token_provider, get_azure_openai_auth
 from pyrit.backend.mappers.target_mappers import target_object_to_instance
 from pyrit.backend.models.common import PaginationInfo
 from pyrit.backend.models.targets import (
     CreateTargetRequest,
+    TargetCatalogEntry,
+    TargetCatalogResponse,
     TargetListResponse,
 )
 from pyrit.models.catalog.target import TargetInstance
-from pyrit.prompt_target import PromptTarget
-from pyrit.prompt_target.azure_ml_chat_target import AzureMLChatTarget
-from pyrit.prompt_target.openai.openai_target import OpenAITarget
-from pyrit.prompt_target.round_robin_target import RoundRobinTarget
 from pyrit.registry import TargetRegistry
 
 logger = logging.getLogger(__name__)
 
-# Recognised Azure OpenAI / AI Foundry hostname suffixes. Used for strict
-# endpoint validation when Entra ID auth is requested, so a bearer token is
-# only ever issued for a known Microsoft-operated endpoint.
-_AZURE_OPENAI_HOSTNAME_SUFFIXES = (
-    ".openai.azure.com",
-    ".ai.azure.com",
-    ".services.ai.azure.com",
-    ".cognitiveservices.azure.com",
-)
-
-# Recognised Azure Machine Learning managed online endpoint hostname suffixes.
-# Used for the same strict endpoint validation when issuing Entra ID tokens
-# against an AML scope.
-_AZURE_ML_HOSTNAME_SUFFIXES = (".inference.ml.azure.com",)
-
-
-def _is_azure_openai_endpoint(endpoint: str) -> bool:
-    """
-    Return True if ``endpoint`` resolves to a known Azure OpenAI / AI Foundry host.
-    Uses a strict hostname-suffix check (not a substring search).
-
-    Args:
-        endpoint (str): The endpoint URL to validate.
-
-    Returns:
-        bool: True if the endpoint's hostname ends with a recognised Azure suffix;
-            False otherwise
-    """
-    hostname = (urlparse(endpoint).hostname or "").lower()
-    return any(hostname.endswith(suffix) for suffix in _AZURE_OPENAI_HOSTNAME_SUFFIXES)
-
-
-def _is_azure_ml_endpoint(endpoint: str) -> bool:
-    """
-    Return True if ``endpoint`` resolves to a known AML managed host.
-    Uses a strict hostname-suffix check (not a substring search).
-
-    Args:
-        endpoint (str): The endpoint URL to validate.
-
-    Returns:
-        bool: True if the endpoint's hostname ends with a recognised AML suffix;
-            False otherwise.
-    """
-    hostname = (urlparse(endpoint).hostname or "").lower()
-    return any(hostname.endswith(suffix) for suffix in _AZURE_ML_HOSTNAME_SUFFIXES)
-
-
-def _resolve_api_key_env_var(target_class: type) -> str | None:
-    """
-    Return the api_key environment variable name for a target class.
-
-    Args:
-        target_class (type): The target class to inspect.
-
-    Returns:
-        str | None: The env var name, or None if the class does not declare one.
-    """
-    if issubclass(target_class, AzureMLChatTarget):
-        env_var = getattr(target_class, "api_key_environment_variable", None)
-        return env_var if isinstance(env_var, str) and env_var else None
-    if issubclass(target_class, OpenAITarget):
-        try:
-            instance = target_class.__new__(target_class)
-            instance._set_openai_env_configuration_vars()
-        except Exception:
-            return None
-        env_var = getattr(instance, "api_key_environment_variable", None)
-        return env_var if isinstance(env_var, str) and env_var else None
-    return None
-
-
-def _build_target_class_registry() -> dict[str, type]:
-    """
-    Build a registry mapping target class names to their classes.
-
-    Uses the prompt_target module's __all__ to discover all available targets.
-
-    Returns:
-        Dict mapping class name (str) to class (type).
-    """
-    registry: dict[str, type] = {}
-    for name in prompt_target.__all__:
-        cls = getattr(prompt_target, name, None)
-        if cls is not None and isinstance(cls, type) and issubclass(cls, PromptTarget):
-            registry[name] = cls
-    return registry
-
-
-# Module-level class registry (built once on import)
-_TARGET_CLASS_REGISTRY: dict[str, type] = _build_target_class_registry()
-
 
 class TargetService:
     """
     Service for managing target instances.
 
-    Uses TargetRegistry as the sole source of truth.
-    API metadata is derived from the target objects' identifiers.
+    Uses TargetRegistry as the sole source of truth. Class discovery,
+    construction (incl. param coercion and reference resolution), and endpoint
+    validation are all owned by the registry and the target classes; this
+    service only orchestrates the request → registry hand-off.
     """
 
-    # Scope for Azure Machine Learning managed online endpoints.
-    _AZURE_ML_SCOPE: ClassVar[str] = "https://ml.azure.com/.default"
-
     def __init__(self) -> None:
         """Initialize the target service."""
         self._registry = TargetRegistry.get_registry_singleton()
 
-    def _get_target_class(self, *, target_type: str) -> type:
-        """
-        Get the target class for a given type name.
-
-        Looks up the class in the module-level target class registry.
-
-        Args:
-            target_type: The exact class name of the target (e.g., 'TextTarget').
-
-        Returns:
-            The target class.
-
-        Raises:
-            ValueError: If the target type is not found.
-        """
-        cls = _TARGET_CLASS_REGISTRY.get(target_type)
-        if cls is None:
-            raise ValueError(
-                f"Target type '{target_type}' not found. Available types: {sorted(_TARGET_CLASS_REGISTRY.keys())}"
-            )
-        return cls
-
     def _build_instance_from_object(self, *, target_registry_name: str, target_obj: Any) -> TargetInstance:
         """
         Build a TargetInstance from a registry object.
@@ -198,7 +77,12 @@ async def list_targets_async(
         next_cursor = page[-1].target_registry_name if has_more and page else None
         return TargetListResponse(
             items=page,
-            pagination=PaginationInfo(limit=limit, has_more=has_more, next_cursor=next_cursor, prev_cursor=cursor),
+            pagination=PaginationInfo(
+                limit=limit,
+                has_more=has_more,
+                next_cursor=next_cursor,
+                prev_cursor=cursor,
+            ),
         )
 
     @staticmethod
@@ -241,12 +125,46 @@ def get_target_object(self, *, target_registry_name: str) -> Any | None:
         """
         return self._registry.instances.get(target_registry_name)
 
+    async def list_target_catalog_async(self) -> TargetCatalogResponse:
+        """
+        List all available target types from the target class registry.
+
+        Returns every constructible target with its derived constructor
+        parameters and the auth modes it supports, all projected from the
+        registry's ``TargetMetadata``. Deciding which entries to surface to a
+        user is a presentation concern owned by the caller (e.g. the frontend),
+        not this service.
+
+        Returns:
+            TargetCatalogResponse containing all available target classes.
+        """
+        items: list[TargetCatalogEntry] = [
+            TargetCatalogEntry(
+                target_type=metadata.class_name,
+                parameters=[p for p in metadata.parameters if p.is_string_coercible],
+                supported_auth_modes=cast("list[Literal['api_key', 'identity']]", list(metadata.supported_auth_modes)),
+                description=metadata.class_description or None,
+            )
+            for metadata in self._registry.get_all_registered_class_metadata()
+        ]
+        return TargetCatalogResponse(items=items)
+
     async def create_target_async(self, *, request: CreateTargetRequest) -> TargetInstance:
         """
         Create a new target instance from API request.
 
-        Instantiates the target with the given type and params,
-        then registers it in the registry under its registry name.
+        Class discovery is owned by the ``TargetRegistry``. Targets whose build
+        contract references other registry instances (e.g. ``RoundRobinTarget``'s
+        ``targets``) are constructed via ``registry.create_instance`` so the
+        resolver turns registry names into live objects; all other targets carry
+        their base configuration (``endpoint`` / ``model_name`` / ``api_key``)
+        through ``**kwargs``, which is not part of the registry's derived
+        parameter contract, so they are constructed directly from the registry
+        class. Endpoint trust and identity token minting are owned by the target
+        classes themselves. This service only enforces the request-level auth
+        contract: for ``identity`` it confirms the target supports it and omits
+        the api_key so the target validates its own endpoint and authenticates
+        itself.
 
         Args:
             request: The create target request with type, params, and auth_mode.
@@ -255,197 +173,52 @@ async def create_target_async(self, *, request: CreateTargetRequest) -> TargetIn
             TargetInstance with the new target's details.
 
         Raises:
-            ValueError: if any of the following occur:
-                - Target type in request is not found in the class registry;
-                - Entra ID auth is requested but the target type does not support it;
-                - Entra ID auth is requested for an OpenAI target or AzureMLChatTarget
-                    but the endpoint is not valid (not managed by correct hosts);
-                - If auth_mode='api_key' is set for a target but no key is supplied;
-                - For RoundRobinTarget: if target_registry_names are missing, any name
-                    is not found, or inner targets fail compatibility checks.
+            ValueError: If the target type is not registered or identity auth is
+                requested but unsupported by the target type. Construction errors
+                (unknown params, incompatible inner targets, unrecognized identity
+                endpoints) are raised by the registry / target classes.
         """
-        target_class = self._get_target_class(target_type=request.type)
+        if request.type not in self._registry:
+            raise ValueError(
+                f"Target type '{request.type}' not found. Available types: {self._registry.get_class_names()}"
+            )
 
-        # RoundRobinTarget needs special handling: the user passes registry names
-        # of existing targets, and we resolve them to live objects.
-        if request.type == "RoundRobinTarget":
-            target_obj = self._create_round_robin_target(params=dict(request.params))
-        else:
-            # Copy params so we can modify values (eg api_key) without changing request.params.
-            params: dict[str, Any] = dict(request.params)
+        target_cls = self._registry.get_class(request.type)
+        params: dict[str, Any] = dict(request.params)
 
-            if request.auth_mode == "entra":
-                params = self._apply_entra_auth(target_class=target_class, target_type=request.type, params=params)
-            else:
-                self._validate_api_key_auth(target_class=target_class, params=params)
+        if request.auth_mode == "identity":
+            if "identity" not in target_cls.supported_auth_modes:
+                raise ValueError(f"Target type '{request.type}' does not support identity-based authentication.")
+            # Omit any api_key so the target validates its own endpoint and authenticates itself.
+            params.pop("api_key", None)
 
-            target_obj = target_class(**params)
+        if self._has_reference_params(target_type=request.type):
+            # e.g. RoundRobinTarget: `targets` is a list of registry names the
+            # resolver turns into live target objects.
+            target_obj = self._registry.create_instance(request.type, **params)
+        else:
+            target_obj = target_cls(**params)
 
         self._registry.instances.register(target_obj)
 
         target_registry_name = target_obj.get_identifier().unique_name
         return self._build_instance_from_object(target_registry_name=target_registry_name, target_obj=target_obj)
 
-    def _create_round_robin_target(self, *, params: dict[str, Any]) -> RoundRobinTarget:
+    def _has_reference_params(self, *, target_type: str) -> bool:
         """
-        Resolve registry names to target objects and create a RoundRobinTarget.
-
-        Targets resolving to the same ``ComponentIdentifier.hash`` are deduplicated
-        before construction (mirroring ``TargetInitializer._auto_group_targets``)
-        so duplicate registry aliases for the same underlying endpoint do not
-        produce a rotation that hits one target twice. If fewer than 2 distinct
-        targets remain after dedup, a ``ValueError`` is raised.
-
-        The RoundRobinTarget constructor validates all compatibility requirements
-        (same class, same configuration, same behavioral params, ≥2 targets).
+        Return True if the target type's build contract references other registry
+        instances (so construction must go through the resolver).
 
         Args:
-            params: Must contain ``target_registry_names`` (list of registry name
-                strings). May contain ``weights`` (list of positive ints) of the
-                same length as ``target_registry_names``; weights for deduped
-                entries are dropped along with their target.
+            target_type (str): The registered target class name.
 
         Returns:
-            A new RoundRobinTarget wrapping the resolved (deduped) targets.
-
-        Raises:
-            ValueError: If fewer than 2 names are supplied, a name is not found
-                in the registry, weights length does not match, dedup leaves
-                fewer than 2 distinct targets, or the RoundRobinTarget
-                constructor rejects the combination.
+            bool: True if any derived parameter is a registry reference.
         """
-        registry_names: list[str] = params.get("target_registry_names", [])
-        if len(registry_names) < 2:
-            raise ValueError("RoundRobinTarget requires at least 2 target_registry_names in params.")
-
-        raw_weights: list[int] | None = params.get("weights") or None
-        if raw_weights is not None and len(raw_weights) != len(registry_names):
-            raise ValueError(
-                f"weights length ({len(raw_weights)}) must match target_registry_names length ({len(registry_names)})."
-            )
-
-        # Deduplicate by ComponentIdentifier hash: two registry entries that
-        # resolve to the same identifier (same endpoint, model, api_version, etc.)
-        # would just hit the same target twice in the rotation. This mirrors the
-        # dedup in TargetInitializer._auto_group_targets so user-driven and
-        # auto-grouped flows behave the same.
-        seen_hashes: set[str | None] = set()
-        resolved_targets: list[PromptTarget] = []
-        resolved_weights: list[int] = []
-        duplicates: list[str] = []
-        for idx, name in enumerate(registry_names):
-            target_obj = self._registry.instances.get(name)
-            if target_obj is None:
-                raise ValueError(f"Target '{name}' not found in the registry.")
-            target_hash = target_obj.get_identifier().hash
-            if target_hash in seen_hashes:
-                duplicates.append(name)
-                logger.debug(f"Skipping duplicate target '{name}' (hash {target_hash}) in RoundRobinTarget creation")
-                continue
-            seen_hashes.add(target_hash)
-            resolved_targets.append(target_obj)
-            if raw_weights is not None:
-                resolved_weights.append(raw_weights[idx])
-
-        if len(resolved_targets) < 2:
-            raise ValueError(
-                f"RoundRobinTarget requires at least 2 distinct targets, but the provided names "
-                f"resolved to {len(resolved_targets)} unique target(s) after deduplication. "
-                f"Duplicate names skipped: {duplicates}. Please select targets with different "
-                f"endpoints or configurations."
-            )
-
-        weights = resolved_weights if raw_weights is not None else None
-
-        # The constructor validates same-class, same-config, behavioral consistency, etc.
-        return RoundRobinTarget(targets=resolved_targets, weights=weights)
-
-    @staticmethod
-    def _apply_entra_auth(*, target_class: type, target_type: str, params: dict[str, Any]) -> dict[str, Any]:
-        """
-        Replace ``api_key`` in ``params`` with an Entra ID token provider for
-        the given target class.
-
-        Args:
-            target_class (type): The target class being instantiated
-            target_type (str): The user-facing target type name
-            params (dict[str, Any]): The target constructor parameters from the request
-
-        Returns:
-            dict[str, Any]: A new params dict with ``api_key`` replaced by an async
-            token-provider callable suitable for the target class.
-
-        Raises:
-            ValueError: If the target type does not support Entra ID, if an
-                OpenAI target is given a non-Azure endpoint, or if an
-                AzureMLChatTarget is given a non-AML endpoint.
-        """
-        new_params = dict(params)
-        if "api_key" in new_params:
-            logger.debug("Discarding 'api_key' from params because auth_mode='entra'.")
-            new_params.pop("api_key", None)
-
-        if issubclass(target_class, OpenAITarget):
-            endpoint = new_params.get("endpoint")
-            if not isinstance(endpoint, str) or not endpoint:
-                raise ValueError("Entra ID authentication requires an 'endpoint' in params.")
-            if not _is_azure_openai_endpoint(endpoint):
-                raise ValueError(
-                    "Entra ID authentication requires an Azure endpoint "
-                    f"(*.openai.azure.com or *.ai.azure.com). Got: {endpoint}"
-                )
-            new_params["api_key"] = get_azure_openai_auth(endpoint)
-            return new_params
-
-        if issubclass(target_class, AzureMLChatTarget):
-            endpoint = new_params.get("endpoint")
-            if not isinstance(endpoint, str) or not endpoint:
-                raise ValueError("Entra ID authentication requires an 'endpoint' in params.")
-            if not _is_azure_ml_endpoint(endpoint):
-                raise ValueError(
-                    "Entra ID authentication for AzureMLChatTarget requires an AML endpoint "
-                    f"(*.inference.ml.azure.com). Got: {endpoint}"
-                )
-            new_params["api_key"] = get_azure_async_token_provider(TargetService._AZURE_ML_SCOPE)
-            return new_params
-
-        raise ValueError(
-            f"Target type '{target_type}' does not support Entra ID authentication. "
-            "Supported types are OpenAI-family targets and AzureMLChatTarget."
-        )
-
-    @staticmethod
-    def _validate_api_key_auth(*, target_class: type, params: dict[str, Any]) -> None:
-        """
-        Enforce that ``auth_mode='api_key'`` actually has a usable key.
-
-        Targets that do not authenticate via an api_key (e.g. ``TextTarget``)
-        are skipped since they have no env var and the underlying
-        constructor does not take any ``api_key`` arguments.
-
-        Args:
-            target_class (type): The target class being instantiated.
-            params (dict[str, Any]): The constructor parameters from the request.
-
-        Raises:
-            ValueError: If no API key is provided in params or in the relevant
-                environment variable for a target class that authenticates via
-                an API key.
-        """
-        env_var = _resolve_api_key_env_var(target_class)
-        if env_var is None:
-            return
-
-        if params.get("api_key"):
-            return
-        if os.environ.get(env_var):
-            return
-
-        raise ValueError(
-            f"auth_mode='api_key' requires an API key but none was provided. "
-            f"Pass 'api_key' in params or set the {env_var} environment variable. "
-            "To authenticate with Microsoft Entra ID instead, set auth_mode='entra'."
-        )
+        metadata = self._registry.get_registered_class_metadata(target_type)
+        if metadata is None:
+            return False
+        return any(param.reference is not None for param in metadata.parameters)
 
 
 @lru_cache(maxsize=1)
diff --git a/pyrit/cli/_output.py b/pyrit/cli/_output.py
index 3b80160b92..eb0226f5bf 100644
--- a/pyrit/cli/_output.py
+++ b/pyrit/cli/_output.py
@@ -181,13 +181,14 @@ def print_target_list(*, items: list[TargetInstance]) -> None:
     print("\nRegistered Targets:")
     print("=" * 80)
     for tgt in items:
+        identifier = tgt.identifier
         _header(tgt.target_registry_name)
-        print(f"    Class: {tgt.target_type}")
-        model = tgt.underlying_model_name or tgt.model_name or ""
+        print(f"    Class: {identifier.class_name}")
+        model = identifier.underlying_model_name or identifier.model_name or ""
         if model:
             print(f"    Model: {model}")
-        if tgt.endpoint:
-            print(f"    Endpoint: {tgt.endpoint}")
+        if identifier.endpoint:
+            print(f"    Endpoint: {identifier.endpoint}")
     print("\n" + "=" * 80)
     print(f"\nTotal targets: {len(items)}")
 
diff --git a/pyrit/models/catalog/__init__.py b/pyrit/models/catalog/__init__.py
index 1da5820194..79db260789 100644
--- a/pyrit/models/catalog/__init__.py
+++ b/pyrit/models/catalog/__init__.py
@@ -22,7 +22,6 @@
     ScenarioRunSummary,
 )
 from pyrit.models.catalog.target import (
-    TargetCapabilitiesInfo,
     TargetInstance,
 )
 
@@ -31,6 +30,5 @@
     "RegisteredScenario",
     "RunScenarioRequest",
     "ScenarioRunSummary",
-    "TargetCapabilitiesInfo",
     "TargetInstance",
 ]
diff --git a/pyrit/models/catalog/target.py b/pyrit/models/catalog/target.py
index 0da1a28c0c..cc9d76f0f8 100644
--- a/pyrit/models/catalog/target.py
+++ b/pyrit/models/catalog/target.py
@@ -15,40 +15,18 @@
 *is* the REST response model (FastAPI serves it directly), per-field
 ``Field(..., description=...)`` strings live here so they surface in the
 generated OpenAPI schema.
+
+Identity lives on the embedded ``TargetIdentifier`` (class
+name, endpoint, model name, generation params, inner-target identifiers) and is
+*not* duplicated as flat fields on ``TargetInstance``. Capabilities live on the
+embedded ``TargetCapabilities``.
 """
 
 from pydantic import BaseModel, Field
 
 from pyrit.models.identifiers.component_identifier import JSONValue
-
-
-class TargetCapabilitiesInfo(BaseModel):
-    """
-    Wire-format snapshot of a target's capabilities.
-
-    Mirrors the domain ``TargetCapabilities`` dataclass for API consumers
-    (notably the GUI). Modality combinations (``frozenset[frozenset[...]]``)
-    are flattened into sorted unique modality lists since the frontend uses
-    them only for per-piece modality checks.
-    """
-
-    supports_multi_turn: bool = Field(False, description="Target natively supports multi-turn conversations")
-    supports_multi_message_pieces: bool = Field(
-        False, description="Target supports multiple message pieces in a single request"
-    )
-    supports_json_schema: bool = Field(False, description="Target can constrain output to a provided JSON schema")
-    supports_json_output: bool = Field(False, description="Target supports JSON output mode")
-    supports_editable_history: bool = Field(False, description="Target allows attack history to be modified")
-    supports_system_prompt: bool = Field(False, description="Target natively supports system prompts")
-    supports_streaming_audio: bool = Field(False, description="Target supports streaming audio input/output")
-    supported_input_modalities: list[str] = Field(
-        default_factory=lambda: ["text"],
-        description="Sorted unique input modality data types the target accepts (e.g., ['image_path', 'text'])",
-    )
-    supported_output_modalities: list[str] = Field(
-        default_factory=lambda: ["text"],
-        description="Sorted unique output modality data types the target produces (e.g., ['audio_path', 'text'])",
-    )
+from pyrit.models.identifiers.target_identifier import TargetIdentifier
+from pyrit.models.target_capabilities import TargetCapabilities
 
 
 class TargetInstance(BaseModel):
@@ -57,21 +35,29 @@ class TargetInstance(BaseModel):
 
     Created either by an initializer (at startup) or by user (via API).
     Also used as the create-target response (same shape as GET).
+
+    Identity (class name, endpoint, model name, generation params, and inner
+    target identifiers) is carried by the typed ``identifier``; those values are
+    read from there rather than mirrored as flat fields. ``target_registry_name``,
+    ``capabilities``, ``inner_targets``, and ``target_specific_params`` are
+    presentation concerns the identifier does not own.
     """
 
     target_registry_name: str = Field(..., description="Target registry key (e.g., 'azure_openai_chat')")
-    target_type: str = Field(..., description="Target class name (e.g., 'OpenAIChatTarget')")
-    endpoint: str | None = Field(None, description="Target endpoint URL")
-    model_name: str | None = Field(None, description="Model or deployment name used in API calls")
-    underlying_model_name: str | None = Field(None, description="Underlying model name if different (e.g., 'gpt-4o')")
-    temperature: float | None = Field(None, description="Temperature parameter for generation")
-    top_p: float | None = Field(None, description="Top-p parameter for generation")
-    max_requests_per_minute: int | None = Field(None, description="Maximum requests per minute")
-    capabilities: TargetCapabilitiesInfo = Field(..., description="Structured snapshot of target capabilities")
+    identifier: TargetIdentifier = Field(
+        ...,
+        description=(
+            "The target's typed, lossless TargetIdentifier: class name, promoted "
+            "params (endpoint, model_name, temperature, ...), content hash, and inner "
+            "target identifiers. Source of truth for the target's identity."
+        ),
+    )
+    capabilities: TargetCapabilities = Field(..., description="Structured snapshot of target capabilities")
     target_specific_params: dict[str, JSONValue] | None = Field(
-        None, description="Additional target-specific parameters"
+        None,
+        description="Non-promoted constructor parameters, curated for display (e.g., RoundRobin weights)",
     )
     inner_targets: list["TargetInstance"] | None = Field(
-        None, description="Inner targets for composite targets like RoundRobinTarget"
+        None,
+        description="Inner targets for composite targets like RoundRobinTarget (full instances, not just identifiers)",
     )
-    identifier_hash: str | None = Field(None, description="ComponentIdentifier content hash for duplicate detection")
diff --git a/pyrit/models/identifiers/target_identifier.py b/pyrit/models/identifiers/target_identifier.py
index 2070322c93..ee84793c15 100644
--- a/pyrit/models/identifiers/target_identifier.py
+++ b/pyrit/models/identifiers/target_identifier.py
@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-from typing import Annotated, ClassVar
+from typing import Annotated, ClassVar, Literal
 
 from pydantic import Field
 
@@ -20,7 +20,10 @@ class TargetIdentifier(ComponentIdentifier):
     Strongly-typed projection of a ``PromptTarget``'s ``ComponentIdentifier``.
 
     Promotes the common target params to typed fields; any other params stay in
-    ``params``. Capabilities are not part of identity and are not surfaced here.
+    ``params``. Message-handling capabilities are not part of identity and are not
+    surfaced here. ``supported_auth_modes`` is the one non-identity fact surfaced:
+    a ``Param.ClassAttr`` (``Evaluate.Exclude``) the registry reads off the class
+    into ``TargetMetadata`` — never an identity input or a constructor argument.
 
     Promotes the one child slot a target owns in its own constructor:
     ``targets`` (inner targets of a multi-target like ``RoundRobinTarget``),
@@ -51,3 +54,11 @@ class TargetIdentifier(ComponentIdentifier):
     #: recursively. An included constructor parameter (the ctor arg is also
     #: ``targets``, a list) resolved by name from the target registry.
     targets: Annotated[list[TargetIdentifier], Evaluate.Unwrap(), Param.Include()] = Field(default_factory=list)
+    #: Auth modes this target type accepts, sourced from the ``supported_auth_modes``
+    #: class attribute (not a constructor argument, not part of identity). Read by
+    #: the registry so ``TargetMetadata`` can describe the class without building it.
+    supported_auth_modes: Annotated[
+        list[Literal["api_key", "identity"]] | None,
+        Evaluate.Exclude(),
+        Param.ClassAttr(attr_name="supported_auth_modes"),
+    ] = None
diff --git a/pyrit/models/target_capabilities.py b/pyrit/models/target_capabilities.py
index 2f0269292e..9565151f76 100644
--- a/pyrit/models/target_capabilities.py
+++ b/pyrit/models/target_capabilities.py
@@ -22,7 +22,7 @@
 from enum import Enum
 from typing import cast
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, computed_field
 
 from pyrit.models.literals import PromptDataType  # noqa: TC001  (runtime-required by Pydantic field annotations)
 
@@ -63,6 +63,12 @@ class attribute. Users can override individual capabilities per instance
 
     Immutable (``frozen``) so a single capabilities object can be safely shared
     across targets and reused as a known-model profile.
+
+    This model also serves as the REST wire snapshot of a target's capabilities
+    (it is embedded in ``TargetInstance``). The modality *combination* fields
+    (``input_modalities`` / ``output_modalities``) are excluded from serialization;
+    API consumers read the flattened ``supported_input_modalities`` /
+    ``supported_output_modalities`` computed fields instead.
     """
 
     model_config = ConfigDict(frozen=True)
@@ -97,11 +103,44 @@ class attribute. Users can override individual capabilities per instance
     #: ``BargeInAttack``.
     supports_streaming_audio: bool = False
 
-    #: The input modalities supported by the target (e.g., "text", "image").
-    input_modalities: frozenset[frozenset[PromptDataType]] = Field(default=_DEFAULT_TEXT_MODALITIES)
+    #: The input modalities supported by the target, as combinations of data types
+    #: (e.g., ``{{"text"}, {"image_path", "text"}}``). Excluded from serialization —
+    #: API consumers read the flattened ``supported_input_modalities`` instead.
+    input_modalities: frozenset[frozenset[PromptDataType]] = Field(default=_DEFAULT_TEXT_MODALITIES, exclude=True)
+
+    #: The output modalities supported by the target, as combinations of data types.
+    #: Excluded from serialization — see ``supported_output_modalities``.
+    output_modalities: frozenset[frozenset[PromptDataType]] = Field(default=_DEFAULT_TEXT_MODALITIES, exclude=True)
+
+    @computed_field(  # type: ignore[prop-decorator]
+        description="Sorted unique input modality data types the target accepts (e.g., ['image_path', 'text'])",
+    )
+    @property
+    def supported_input_modalities(self) -> list[str]:
+        """
+        Flattened, sorted unique input modality data types.
+
+        The internal ``input_modalities`` models modality *combinations*
+        (``frozenset[frozenset]``); API consumers use only per-piece modality
+        checks, so this flattens the combinations into a sorted unique list.
+
+        Returns:
+            list[str]: Sorted unique input modality data types.
+        """
+        return sorted({str(data_type) for combo in self.input_modalities for data_type in combo})
+
+    @computed_field(  # type: ignore[prop-decorator]
+        description="Sorted unique output modality data types the target produces (e.g., ['audio_path', 'text'])",
+    )
+    @property
+    def supported_output_modalities(self) -> list[str]:
+        """
+        Flattened, sorted unique output modality data types.
 
-    #: The output modalities supported by the target (e.g., "text", "image").
-    output_modalities: frozenset[frozenset[PromptDataType]] = Field(default=_DEFAULT_TEXT_MODALITIES)
+        Returns:
+            list[str]: Sorted unique output modality data types.
+        """
+        return sorted({str(data_type) for combo in self.output_modalities for data_type in combo})
 
     def includes(self, *, capability: CapabilityName) -> bool:
         """
diff --git a/pyrit/prompt_target/azure_blob_storage_target.py b/pyrit/prompt_target/azure_blob_storage_target.py
index 4c5f1e2d2b..5cb6b89886 100644
--- a/pyrit/prompt_target/azure_blob_storage_target.py
+++ b/pyrit/prompt_target/azure_blob_storage_target.py
@@ -3,6 +3,7 @@
 
 import logging
 from enum import Enum
+from typing import ClassVar
 from urllib.parse import urlparse
 
 from azure.core.exceptions import ClientAuthenticationError
@@ -12,7 +13,7 @@
 
 from pyrit.common import default_values
 from pyrit.models import ComponentIdentifier, Message, construct_response_from_request
-from pyrit.prompt_target.common.prompt_target import PromptTarget
+from pyrit.prompt_target.common.prompt_target import AuthMode, PromptTarget
 from pyrit.prompt_target.common.target_capabilities import TargetCapabilities
 from pyrit.prompt_target.common.target_configuration import TargetConfiguration
 from pyrit.prompt_target.common.utils import limit_requests_per_minute
@@ -50,6 +51,10 @@ class AzureBlobStorageTarget(PromptTarget):
     AZURE_STORAGE_CONTAINER_ENVIRONMENT_VARIABLE: str = "AZURE_STORAGE_ACCOUNT_CONTAINER_URL"
     SAS_TOKEN_ENVIRONMENT_VARIABLE: str = "AZURE_STORAGE_ACCOUNT_SAS_TOKEN"
 
+    # A SAS token is the "api_key"; with no token the target falls back to
+    # ``DefaultAzureCredential`` (identity-based auth).
+    supported_auth_modes: ClassVar[tuple[AuthMode, ...]] = ("api_key", "identity")
+
     _DEFAULT_CONFIGURATION: TargetConfiguration = TargetConfiguration(
         capabilities=TargetCapabilities(
             input_modalities=frozenset(
diff --git a/pyrit/prompt_target/azure_ml_chat_target.py b/pyrit/prompt_target/azure_ml_chat_target.py
index 0bb58fa2d1..d0e0be8b6e 100644
--- a/pyrit/prompt_target/azure_ml_chat_target.py
+++ b/pyrit/prompt_target/azure_ml_chat_target.py
@@ -3,11 +3,15 @@
 
 import logging
 from collections.abc import Awaitable, Callable
-from typing import Any, cast
+from typing import Any, ClassVar, cast
 
 from httpx import HTTPStatusError
 
-from pyrit.auth import ensure_async_token_provider
+from pyrit.auth import (
+    ensure_async_token_provider,
+    get_azure_async_token_provider,
+    is_azure_ml_endpoint,
+)
 from pyrit.common import default_values, net_utility
 from pyrit.exceptions import (
     EmptyResponseException,
@@ -21,7 +25,7 @@
     Message,
     construct_response_from_request,
 )
-from pyrit.prompt_target.common.prompt_target import PromptTarget
+from pyrit.prompt_target.common.prompt_target import AuthMode, PromptTarget
 from pyrit.prompt_target.common.target_capabilities import TargetCapabilities
 from pyrit.prompt_target.common.target_configuration import TargetConfiguration
 from pyrit.prompt_target.common.utils import limit_requests_per_minute, validate_temperature, validate_top_p
@@ -44,6 +48,13 @@ class AzureMLChatTarget(PromptTarget):
     endpoint_uri_environment_variable: str = "AZURE_ML_MANAGED_ENDPOINT"
     api_key_environment_variable: str = "AZURE_ML_KEY"
 
+    # AML managed online endpoints can authenticate with a Microsoft Entra ID
+    # token scoped to AML, so this target supports both auth modes.
+    supported_auth_modes: ClassVar[tuple[AuthMode, ...]] = ("api_key", "identity")
+
+    # Entra ID token scope for Azure Machine Learning managed online endpoints.
+    _AZURE_ML_SCOPE: ClassVar[str] = "https://ml.azure.com/.default"
+
     _DEFAULT_CONFIGURATION: TargetConfiguration = TargetConfiguration(
         capabilities=TargetCapabilities(
             supports_multi_message_pieces=True,
@@ -164,6 +175,11 @@ def _initialize_vars(
                 The API key for accessing the Azure ML endpoint, or a callable
                 which returns a bearer token, or None to fall back to the
                 ``AZURE_ML_KEY`` env variable.
+
+        Raises:
+            ValueError: If no api_key is supplied (via parameter or environment
+                variable) and the endpoint is not a recognized Azure ML managed
+                online endpoint for which Entra ID authentication can be used.
         """
         self._endpoint = default_values.get_required_value(
             env_var_name=self.endpoint_uri_environment_variable, passed_value=endpoint
@@ -176,10 +192,28 @@ def _initialize_vars(
             self._api_key = ""
             return
 
-        self._api_key_provider = None
-        self._api_key = default_values.get_required_value(
+        api_key_value = default_values.get_non_required_value(
             env_var_name=self.api_key_environment_variable, passed_value=api_key
         )
+        if api_key_value:
+            self._api_key_provider = None
+            self._api_key = api_key_value
+            return
+
+        # No key supplied: fall back to Microsoft Entra ID, but only for a
+        # recognized AML managed online endpoint so a bearer token is never
+        # minted for an arbitrary host.
+        if is_azure_ml_endpoint(self._endpoint):
+            normalized = ensure_async_token_provider(get_azure_async_token_provider(self._AZURE_ML_SCOPE))
+            self._api_key_provider = cast("Callable[[], Awaitable[str]]", normalized)
+            self._api_key = ""
+            return
+
+        raise ValueError(
+            f"Environment variable {self.api_key_environment_variable} is required unless the endpoint is a "
+            "recognized Azure ML managed online endpoint (*.inference.ml.azure.com), for which Entra ID "
+            "authentication is used automatically. Pass an api_key or a token provider callable instead."
+        )
 
     @limit_requests_per_minute
     async def _send_prompt_to_target_async(self, *, normalized_conversation: list[Message]) -> list[Message]:
diff --git a/pyrit/prompt_target/common/prompt_target.py b/pyrit/prompt_target/common/prompt_target.py
index 65000a6139..306819d165 100644
--- a/pyrit/prompt_target/common/prompt_target.py
+++ b/pyrit/prompt_target/common/prompt_target.py
@@ -3,7 +3,7 @@
 
 import abc
 import logging
-from typing import Any, final
+from typing import Any, ClassVar, Literal, final
 
 from pyrit.common.deprecation import print_deprecation_message
 from pyrit.memory import CentralMemory, MemoryInterface
@@ -18,6 +18,13 @@
 
 logger = logging.getLogger(__name__)
 
+# Authentication modes a target can expose to the create-target catalog / API.
+# ``api_key`` passes a key (from params or the target's env var); ``identity``
+# omits the key so the target authenticates itself via an ambient Azure identity
+# (e.g. minting a Microsoft Entra ID token for its own endpoint, or falling back
+# to ``DefaultAzureCredential``).
+AuthMode = Literal["api_key", "identity"]
+
 
 class PromptTarget(Identifiable):
     """
@@ -46,6 +53,19 @@ class PromptTarget(Identifiable):
     # constructor parameter, which takes precedence over the class-level value.
     _DEFAULT_CONFIGURATION: TargetConfiguration = TargetConfiguration(capabilities=TargetCapabilities())
 
+    # Declarative auth facts consumed by the create-target service and catalog.
+    # Kept off ``TargetCapabilities`` (auth is a construction/credential axis, not
+    # a message-handling capability) and out of the identity hash. It is surfaced
+    # on ``TargetIdentifier`` only as a ``Param.ClassAttr`` (``Evaluate.Exclude``)
+    # so the registry can read it into ``TargetMetadata`` without building an
+    # instance — never as an identity input or a constructor argument.
+    #
+    # ``supported_auth_modes`` lists the auth modes the create-target API accepts
+    # for this type. Base default is api-key only; targets that can authenticate
+    # via an ambient Azure identity when given no key (e.g. OpenAI, Azure ML,
+    # Azure Blob Storage, Prompt Shield) override this to add ``"identity"``.
+    supported_auth_modes: ClassVar[tuple[AuthMode, ...]] = ("api_key",)
+
     def __init_subclass__(cls, **kwargs: object) -> None:
         """
         Validate that subclasses follow the keyword-only ``__init__`` contract.
diff --git a/pyrit/prompt_target/openai/openai_target.py b/pyrit/prompt_target/openai/openai_target.py
index bcd9b48162..3700ebc370 100644
--- a/pyrit/prompt_target/openai/openai_target.py
+++ b/pyrit/prompt_target/openai/openai_target.py
@@ -6,7 +6,7 @@
 import re
 from abc import abstractmethod
 from collections.abc import Awaitable, Callable
-from typing import Any
+from typing import Any, ClassVar
 from urllib.parse import urlparse
 
 from openai import (
@@ -22,14 +22,14 @@
     AuthenticationError,
 )
 
-from pyrit.auth import ensure_async_token_provider, get_azure_openai_auth
+from pyrit.auth import ensure_async_token_provider, get_azure_openai_auth, is_azure_openai_endpoint
 from pyrit.common import default_values
 from pyrit.exceptions.exception_classes import (
     RateLimitException,
     handle_bad_request_exception,
 )
 from pyrit.models import Message, MessagePiece
-from pyrit.prompt_target.common.prompt_target import PromptTarget
+from pyrit.prompt_target.common.prompt_target import AuthMode, PromptTarget
 from pyrit.prompt_target.common.target_capabilities import TargetCapabilities
 from pyrit.prompt_target.common.target_configuration import TargetConfiguration
 from pyrit.prompt_target.openai.openai_error_handling import (
@@ -57,6 +57,10 @@ class OpenAITarget(PromptTarget):
         capabilities=TargetCapabilities(supports_multi_message_pieces=True)
     )
 
+    # OpenAI-family targets can mint an Entra ID token for a recognized Azure
+    # endpoint (see ``is_azure_openai_endpoint``), so they support both modes.
+    supported_auth_modes: ClassVar[tuple[AuthMode, ...]] = ("api_key", "identity")
+
     model_name_environment_variable: str
     endpoint_environment_variable: str
     api_key_environment_variable: str
@@ -96,8 +100,8 @@ def __init__(
             endpoint (str, Optional): The target URL for the OpenAI service.
             api_key (str | Callable[[], str | Awaitable[str]], Optional): The API key for accessing the
                 OpenAI service, or a callable that returns an access token (sync or async).
-                For Azure endpoints, if no API key is provided (via parameter or environment variable),
-                Entra ID authentication is used automatically.
+                For recognized Azure OpenAI / AI Foundry endpoints, if no API key is provided
+                (via parameter or environment variable), Entra ID authentication is used automatically.
                 You can also explicitly pass a token provider from pyrit.auth
                 (e.g., get_azure_openai_auth(endpoint) for async, or get_azure_token_provider(scope) for sync).
                 Synchronous token providers are automatically wrapped to work with async clients.
@@ -116,7 +120,8 @@ def __init__(
                 this target instance. If None, uses the class-level defaults. Defaults to None.
 
         Raises:
-            ValueError: If no API key is provided and the endpoint is not an Azure endpoint.
+            ValueError: If no API key is provided (via parameter or environment variable) and the
+                endpoint is not a recognized Azure OpenAI / AI Foundry endpoint.
         """
         self._headers: dict[str, str] = {}
         self._httpx_client_kwargs = httpx_client_kwargs or {}
@@ -157,12 +162,13 @@ def __init__(
             )
             if api_key_value:
                 resolved_api_key = api_key_value
-            elif "azure" in endpoint_value.lower():
+            elif is_azure_openai_endpoint(endpoint_value):
                 resolved_api_key = get_azure_openai_auth(endpoint_value)
             else:
                 raise ValueError(
                     f"Environment variable {self.api_key_environment_variable} is required for non-Azure endpoints. "
-                    "For Azure endpoints, Entra ID authentication is used automatically."
+                    "For recognized Azure OpenAI / AI Foundry endpoints, Entra ID authentication is used "
+                    "automatically."
                 )
 
         # Ensure api_key is async-compatible (wrap sync token providers if needed)
diff --git a/pyrit/prompt_target/prompt_shield_target.py b/pyrit/prompt_target/prompt_shield_target.py
index 78b28367fc..e41f9f2eb7 100644
--- a/pyrit/prompt_target/prompt_shield_target.py
+++ b/pyrit/prompt_target/prompt_shield_target.py
@@ -4,15 +4,20 @@
 import json
 import logging
 from collections.abc import Callable
-from typing import Any, Literal
+from typing import Any, ClassVar, Literal
 
+from pyrit.auth import (
+    get_azure_token_provider,
+    get_default_azure_scope,
+    is_azure_openai_endpoint,
+)
 from pyrit.common import default_values, net_utility
 from pyrit.models import (
     ComponentIdentifier,
     Message,
     construct_response_from_request,
 )
-from pyrit.prompt_target.common.prompt_target import PromptTarget
+from pyrit.prompt_target.common.prompt_target import AuthMode, PromptTarget
 from pyrit.prompt_target.common.target_configuration import TargetConfiguration
 from pyrit.prompt_target.common.utils import limit_requests_per_minute
 
@@ -49,6 +54,10 @@ class PromptShieldTarget(PromptTarget):
     ENDPOINT_URI_ENVIRONMENT_VARIABLE: str = "AZURE_CONTENT_SAFETY_API_ENDPOINT"
     API_KEY_ENVIRONMENT_VARIABLE: str = "AZURE_CONTENT_SAFETY_API_KEY"
 
+    # A subscription key is the "api_key"; with no key a recognized Azure Content
+    # Safety endpoint falls back to an Entra ID token provider (identity-based auth).
+    supported_auth_modes: ClassVar[tuple[AuthMode, ...]] = ("api_key", "identity")
+
     _endpoint: str
     _api_key: str | Callable[[], str] | None
     _api_version: str
@@ -77,8 +86,10 @@ def __init__(
                 Defaults to the `ENDPOINT_URI_ENVIRONMENT_VARIABLE` environment variable.
             api_key (str | Callable[[], str | Awaitable[str]], Optional):
                 The API key for accessing the Azure Content Safety service,
-                or a callable that returns an access token. For Azure endpoints with Entra authentication,
-                pass a token provider from pyrit.auth
+                or a callable that returns an access token. For recognized Azure endpoints
+                (``*.cognitiveservices.azure.com``) with no key provided, an Entra ID token
+                provider is minted automatically (identity-based auth). To supply your own
+                token provider, pass one from pyrit.auth
                 (e.g., get_azure_token_provider('https://cognitiveservices.azure.com/.default')).
                 Defaults to the `API_KEY_ENVIRONMENT_VARIABLE` environment variable.
             api_version (str, Optional): The version of the Azure Content Safety API. Defaults to "2024-09-01".
@@ -92,7 +103,8 @@ def __init__(
                 this target instance. Defaults to None.
 
         Raises:
-            ValueError: If the endpoint value is not provided.
+            ValueError: If the endpoint value is not provided, or if no API key is
+                provided for a non-Azure Content Safety endpoint.
         """
         endpoint_value = default_values.get_required_value(
             env_var_name=self.ENDPOINT_URI_ENVIRONMENT_VARIABLE, passed_value=endpoint
@@ -107,13 +119,25 @@ def __init__(
 
         self._api_version = api_version or "2024-09-01"
 
-        # API key is required - either from parameter or environment variable
-        _api_key_value = default_values.get_required_value(
-            env_var_name=self.API_KEY_ENVIRONMENT_VARIABLE, passed_value=api_key
-        )
-        if _api_key_value is None:
-            raise ValueError("API key is required")
-        self._api_key = _api_key_value
+        # Resolve authentication: an explicit key or token-provider callable, the
+        # env var, or — for a recognized Azure Content Safety endpoint with no key —
+        # an Entra ID token provider minted for the endpoint (identity-based auth).
+        if api_key is not None and callable(api_key):
+            self._api_key = api_key
+        else:
+            api_key_value = default_values.get_non_required_value(
+                env_var_name=self.API_KEY_ENVIRONMENT_VARIABLE, passed_value=api_key
+            )
+            if api_key_value:
+                self._api_key = api_key_value
+            elif is_azure_openai_endpoint(endpoint_value):
+                self._api_key = get_azure_token_provider(get_default_azure_scope(endpoint_value))
+            else:
+                raise ValueError(
+                    "API key is required for non-Azure Content Safety endpoints. For recognized Azure "
+                    "endpoints (*.cognitiveservices.azure.com), identity-based authentication is used "
+                    "automatically."
+                )
 
         self._force_entry_field: PromptShieldEntryField = field
 
diff --git a/pyrit/prompt_target/round_robin_target.py b/pyrit/prompt_target/round_robin_target.py
index 3086601d72..5ce1d850a4 100644
--- a/pyrit/prompt_target/round_robin_target.py
+++ b/pyrit/prompt_target/round_robin_target.py
@@ -5,7 +5,12 @@
 import logging
 from typing import Any
 
-from pyrit.models import TARGET_EVAL_PARAM_FALLBACKS, TARGET_EVAL_PARAMS, ComponentIdentifier, Message
+from pyrit.models import (
+    TARGET_EVAL_PARAM_FALLBACKS,
+    TARGET_EVAL_PARAMS,
+    ComponentIdentifier,
+    Message,
+)
 from pyrit.prompt_target.common.prompt_target import PromptTarget
 from pyrit.prompt_target.common.target_requirements import CHAT_TARGET_REQUIREMENTS
 
@@ -65,11 +70,11 @@ def __init__(
                 requests to the first target. Defaults to equal weight.
 
         Raises:
-            ValueError: If fewer than 2 targets are provided, targets are
-                different classes, a nested RoundRobinTarget is detected,
-                weights length doesn't match, weights contain non-positive
-                values, inner targets have different configurations, or
-                targets lack required capabilities.
+            ValueError: If fewer than 2 targets are provided, the same target instance is
+                passed more than once, targets are different classes, a nested
+                RoundRobinTarget is detected, weights length doesn't match, weights contain
+                non-positive values, inner targets have different configurations, or targets
+                lack required capabilities.
         """
         if len(targets) < 2:
             raise ValueError(f"RoundRobinTarget requires at least 2 targets, got {len(targets)}.")
@@ -77,6 +82,17 @@ def __init__(
         if any(isinstance(t, RoundRobinTarget) for t in targets):
             raise ValueError("Nesting RoundRobinTarget inside another RoundRobinTarget is not supported.")
 
+        # Reject the same target *instance* referenced more than once. We compare by object
+        # identity, not ComponentIdentifier hash: the hash excludes credentials (api_key),
+        # so two distinct targets that share an endpoint/model but use different keys (e.g.
+        # round-robining across accounts to spread rate limits) are legitimately different
+        # and must be allowed.
+        if len({id(t) for t in targets}) != len(targets):
+            raise ValueError("RoundRobinTarget received the same target instance more than once.")
+
+        if weights is not None and len(weights) != len(targets):
+            raise ValueError(f"weights length ({len(weights)}) must match targets length ({len(targets)}).")
+
         first_type = type(targets[0])
         mismatched = [(i, type(t).__name__) for i, t in enumerate(targets[1:], start=1) if type(t) is not first_type]
         if mismatched:
@@ -86,8 +102,6 @@ def __init__(
             )
 
         weights = weights or [1] * len(targets)
-        if len(weights) != len(targets):
-            raise ValueError(f"weights length ({len(weights)}) must match targets length ({len(targets)}).")
         if any(w <= 0 for w in weights):
             raise ValueError("All weights must be positive integers.")
 
@@ -117,6 +131,20 @@ def __init__(
 
         self._counter: int = 0
 
+    @property
+    def inner_targets(self) -> list[PromptTarget]:
+        """
+        The inner targets this round-robin distributes requests across.
+
+        Exposed so composition-aware consumers (e.g. DTO mappers) can read the
+        children without knowing this concrete type or reaching into private
+        state.
+
+        Returns:
+            list[PromptTarget]: A copy of the inner targets.
+        """
+        return list(self._targets)
+
     def _next_target(self) -> PromptTarget:
         """
         Return the next inner target in the weighted rotation.
diff --git a/pyrit/registry/components/target_registry.py b/pyrit/registry/components/target_registry.py
index 8233770127..eff8338121 100644
--- a/pyrit/registry/components/target_registry.py
+++ b/pyrit/registry/components/target_registry.py
@@ -43,10 +43,18 @@ class TargetMetadata(RegistryMetadata):
     Metadata describing a registered ``PromptTarget`` class.
 
     Carries the derived ``parameters`` build contract (the same list the resolver
-    consumes to build an instance). Use ``TargetRegistry.get_class()`` to get the
-    actual class or ``create_instance()`` to build a configured instance.
+    consumes to build an instance) and, via ``class_attributes`` on the base, the
+    target's declarative auth facts. ``supported_auth_modes`` is projected from
+    those rather than stored, so the entry can never drift from the class. Use
+    ``TargetRegistry.get_class()`` to get the actual class or ``create_instance()``
+    to build a configured instance.
     """
 
+    @property
+    def supported_auth_modes(self) -> tuple[str, ...]:
+        """Auth modes this target type accepts (e.g. ``"api_key"``, ``"identity"``)."""
+        return tuple(self.class_attributes.get("supported_auth_modes") or ())
+
 
 class TargetRegistry(Registry["PromptTarget", TargetMetadata]):
     """
diff --git a/tests/unit/auth/test_azure_auth.py b/tests/unit/auth/test_azure_auth.py
index d61f871129..6bf8ce2ccc 100644
--- a/tests/unit/auth/test_azure_auth.py
+++ b/tests/unit/auth/test_azure_auth.py
@@ -13,6 +13,8 @@
     get_azure_token_provider,
     get_speech_config,
     get_speech_config_from_default_azure_credential,
+    is_azure_ml_endpoint,
+    is_azure_openai_endpoint,
 )
 
 curr_epoch_time = int(time.time())
@@ -170,3 +172,70 @@ def test_get_access_token_from_interactive_login_propagates_exception():
     ):
         with pytest.raises(ValueError, match="auth failed"):
             get_access_token_from_interactive_login(scope="https://test.scope")
+
+
+class TestIsAzureOpenAIEndpoint:
+    """Strict hostname-suffix validation for Azure OpenAI / AI Foundry endpoints."""
+
+    @pytest.mark.parametrize(
+        "endpoint",
+        [
+            "https://my-resource.openai.azure.com",
+            "https://my-resource.openai.azure.com/openai/deployments/gpt-4o",
+            "https://my-project.ai.azure.com",
+            "https://my-project.services.ai.azure.com",
+            "https://my-resource.cognitiveservices.azure.com",
+            "https://MY-RESOURCE.OpenAI.Azure.Com",  # case-insensitive
+        ],
+    )
+    def test_recognises_valid_endpoints(self, endpoint: str) -> None:
+        assert is_azure_openai_endpoint(endpoint) is True
+
+    @pytest.mark.parametrize(
+        "endpoint",
+        [
+            None,
+            "",
+            "not a url",
+            "https://openai.com",
+            "https://api.openai.com/v1",
+            "https://my-resource.notazure.com",
+            # Suffix-injection / spoofing: the real suffix is only a substring, not the host suffix.
+            "https://evil.openai.azure.com.attacker.com",
+            "https://openai.azure.com.attacker.com",
+            "https://myopenai.azure.com",  # ".azure.com" without a recognised leading label
+        ],
+    )
+    def test_rejects_invalid_or_spoofed_endpoints(self, endpoint: str | None) -> None:
+        assert is_azure_openai_endpoint(endpoint) is False
+
+    def test_does_not_match_azure_ml_endpoint(self) -> None:
+        assert is_azure_openai_endpoint("https://my-endpoint.inference.ml.azure.com") is False
+
+
+class TestIsAzureMLEndpoint:
+    """Strict hostname-suffix validation for Azure ML managed online endpoints."""
+
+    @pytest.mark.parametrize(
+        "endpoint",
+        [
+            "https://my-endpoint.inference.ml.azure.com",
+            "https://my-endpoint.inference.ml.azure.com/score",
+            "https://MY-ENDPOINT.Inference.ML.Azure.Com",  # case-insensitive
+        ],
+    )
+    def test_recognises_valid_endpoints(self, endpoint: str) -> None:
+        assert is_azure_ml_endpoint(endpoint) is True
+
+    @pytest.mark.parametrize(
+        "endpoint",
+        [
+            None,
+            "",
+            "https://my-resource.openai.azure.com",
+            "https://my-endpoint.inference.ml.azure.com.attacker.com",  # suffix injection
+            "https://myinference.ml.azure.com",
+        ],
+    )
+    def test_rejects_invalid_or_spoofed_endpoints(self, endpoint: str | None) -> None:
+        assert is_azure_ml_endpoint(endpoint) is False
diff --git a/tests/unit/backend/test_api_routes.py b/tests/unit/backend/test_api_routes.py
index e6299313ef..18ab602316 100644
--- a/tests/unit/backend/test_api_routes.py
+++ b/tests/unit/backend/test_api_routes.py
@@ -35,11 +35,12 @@
     PreviewStep,
 )
 from pyrit.backend.models.targets import (
+    TargetCatalogResponse,
     TargetListResponse,
 )
 from pyrit.backend.routes.labels import get_label_options
-from pyrit.models import ConverterIdentifier, MessagePiece
-from pyrit.models.catalog.target import TargetCapabilitiesInfo, TargetInstance
+from pyrit.models import ConverterIdentifier, MessagePiece, TargetCapabilities, TargetIdentifier
+from pyrit.models.catalog.target import TargetInstance
 
 
 def _make_message_view(*, role: str = "user", value: str = "hello", sequence: int = 1) -> MessageView:
@@ -795,6 +796,29 @@ def test_list_targets_returns_empty_list(self, client: TestClient) -> None:
             assert data["items"] == []
             assert data["pagination"]["has_more"] is False
 
+    def test_list_target_catalog(self, client: TestClient) -> None:
+        """Test listing available target types from the target catalog."""
+        with patch("pyrit.backend.routes.targets.get_target_service") as mock_get_service:
+            mock_service = MagicMock()
+            mock_service.list_target_catalog_async = AsyncMock(
+                return_value=TargetCatalogResponse(
+                    items=[
+                        {
+                            "target_type": "OpenAIChatTarget",
+                            "supported_auth_modes": ["api_key", "identity"],
+                        }
+                    ]
+                )
+            )
+            mock_get_service.return_value = mock_service
+
+            response = client.get("/api/targets/catalog")
+
+            assert response.status_code == status.HTTP_200_OK
+            data = response.json()
+            assert data["items"][0]["target_type"] == "OpenAIChatTarget"
+            assert data["items"][0]["supported_auth_modes"] == ["api_key", "identity"]
+
     def test_create_target_success(self, client: TestClient) -> None:
         """Test successful target creation."""
         with patch("pyrit.backend.routes.targets.get_target_service") as mock_get_service:
@@ -802,8 +826,8 @@ def test_create_target_success(self, client: TestClient) -> None:
             mock_service.create_target_async = AsyncMock(
                 return_value=TargetInstance(
                     target_registry_name="target-1",
-                    target_type="TextTarget",
-                    capabilities=TargetCapabilitiesInfo(),
+                    identifier=TargetIdentifier(class_name="TextTarget"),
+                    capabilities=TargetCapabilities(),
                 )
             )
             mock_get_service.return_value = mock_service
@@ -852,8 +876,8 @@ def test_get_target_success(self, client: TestClient) -> None:
             mock_service.get_target_async = AsyncMock(
                 return_value=TargetInstance(
                     target_registry_name="target-1",
-                    target_type="TextTarget",
-                    capabilities=TargetCapabilitiesInfo(),
+                    identifier=TargetIdentifier(class_name="TextTarget"),
+                    capabilities=TargetCapabilities(),
                 )
             )
             mock_get_service.return_value = mock_service
@@ -884,11 +908,13 @@ def test_list_targets_includes_target_specific_params(self, client: TestClient)
                     items=[
                         TargetInstance(
                             target_registry_name="azure_responses",
-                            target_type="OpenAIResponseTarget",
-                            endpoint="https://api.openai.com",
-                            model_name="o3",
-                            temperature=1.0,
-                            capabilities=TargetCapabilitiesInfo(supports_multi_turn=True),
+                            identifier=TargetIdentifier(
+                                class_name="OpenAIResponseTarget",
+                                endpoint="https://api.openai.com",
+                                model_name="o3",
+                                temperature=1.0,
+                            ),
+                            capabilities=TargetCapabilities(supports_multi_turn=True),
                             target_specific_params={
                                 "reasoning_effort": "high",
                                 "reasoning_summary": "auto",
@@ -917,11 +943,13 @@ def test_get_target_includes_target_specific_params(self, client: TestClient) ->
             mock_service.get_target_async = AsyncMock(
                 return_value=TargetInstance(
                     target_registry_name="azure_chat",
-                    target_type="OpenAIChatTarget",
-                    endpoint="https://api.openai.com",
-                    model_name="gpt-4",
-                    temperature=0.7,
-                    capabilities=TargetCapabilitiesInfo(supports_multi_turn=True),
+                    identifier=TargetIdentifier(
+                        class_name="OpenAIChatTarget",
+                        endpoint="https://api.openai.com",
+                        model_name="gpt-4",
+                        temperature=0.7,
+                    ),
+                    capabilities=TargetCapabilities(supports_multi_turn=True),
                     target_specific_params={
                         "frequency_penalty": 0.5,
                         "presence_penalty": 0.3,
diff --git a/tests/unit/backend/test_mappers.py b/tests/unit/backend/test_mappers.py
index 563e2de040..9ca8d032be 100644
--- a/tests/unit/backend/test_mappers.py
+++ b/tests/unit/backend/test_mappers.py
@@ -1316,7 +1316,8 @@ class TestTargetObjectToInstance:
 
     def test_maps_target_with_identifier(self) -> None:
         """Test mapping a target object that has get_identifier."""
-        target_obj = MagicMock()
+        target_obj = MagicMock(spec=PromptTarget)
+        target_obj.capabilities = TargetCapabilities()
         mock_identifier = ComponentIdentifier(
             class_name="OpenAIChatTarget",
             class_module="pyrit.prompt_target",
@@ -1331,19 +1332,20 @@ def test_maps_target_with_identifier(self) -> None:
         result = target_object_to_instance("t-1", target_obj)
 
         assert result.target_registry_name == "t-1"
-        assert result.target_type == "OpenAIChatTarget"
-        assert result.endpoint == "http://test"
-        assert result.model_name == "gpt-4"
-        assert result.temperature == 0.7
-        # identifier_hash is auto-populated by the ComponentIdentifier validator and
-        # surfaced on the DTO so the frontend can dedupe targets that resolve to the
+        assert result.identifier.class_name == "OpenAIChatTarget"
+        assert result.identifier.endpoint == "http://test"
+        assert result.identifier.model_name == "gpt-4"
+        assert result.identifier.temperature == 0.7
+        # hash is auto-populated by the ComponentIdentifier validator and surfaced on
+        # the embedded identifier so the frontend can dedupe targets that resolve to the
         # same underlying configuration.
-        assert result.identifier_hash is not None
-        assert result.identifier_hash == mock_identifier.hash
+        assert result.identifier.hash is not None
+        assert result.identifier.hash == mock_identifier.hash
 
     def test_no_endpoint_returns_none(self) -> None:
         """Test that missing endpoint returns None."""
-        target_obj = MagicMock()
+        target_obj = MagicMock(spec=PromptTarget)
+        target_obj.capabilities = TargetCapabilities()
         mock_identifier = ComponentIdentifier(
             class_name="TextTarget",
             class_module="pyrit.prompt_target",
@@ -1352,21 +1354,22 @@ def test_no_endpoint_returns_none(self) -> None:
 
         result = target_object_to_instance("t-1", target_obj)
 
-        assert result.target_type == "TextTarget"
-        assert result.endpoint is None
-        assert result.model_name is None
+        assert result.identifier.class_name == "TextTarget"
+        assert result.identifier.endpoint is None
+        assert result.identifier.model_name is None
 
     def test_no_get_identifier_uses_class_name(self) -> None:
         """Test that target uses class name from identifier."""
-        target_obj = MagicMock()
+        target_obj = MagicMock(spec=PromptTarget)
+        target_obj.capabilities = TargetCapabilities()
         mock_identifier = ComponentIdentifier(class_name="FakeTarget", class_module="pyrit.prompt_target")
         target_obj.get_identifier.return_value = mock_identifier
 
         result = target_object_to_instance("t-1", target_obj)
 
-        assert result.target_type == "FakeTarget"
-        assert result.endpoint is None
-        assert result.model_name is None
+        assert result.identifier.class_name == "FakeTarget"
+        assert result.identifier.endpoint is None
+        assert result.identifier.model_name is None
 
     def test_supports_multi_turn_true_when_capability_set(self) -> None:
         """Test that targets with supports_multi_turn capability expose it via capabilities."""
@@ -1480,7 +1483,7 @@ def test_extra_params_in_target_specific_params(self) -> None:
 
         result = target_object_to_instance("t-1", target_obj)
 
-        assert result.temperature == 1.0
+        assert result.identifier.temperature == 1.0
         assert result.target_specific_params is not None
         assert result.target_specific_params["reasoning_effort"] == "high"
         assert result.target_specific_params["reasoning_summary"] == "auto"
@@ -1504,8 +1507,8 @@ def test_no_extra_params_returns_none_target_specific(self) -> None:
 
         result = target_object_to_instance("t-1", target_obj)
 
-        assert result.temperature == 0.7
-        assert result.top_p == 0.9
+        assert result.identifier.temperature == 0.7
+        assert result.identifier.top_p == 0.9
         assert result.target_specific_params is None
 
     def test_none_valued_extra_params_excluded(self) -> None:
@@ -1576,8 +1579,8 @@ def test_chat_target_extra_params_preserved(self) -> None:
 
         result = target_object_to_instance("t-1", target_obj)
 
-        assert result.temperature == 0.7
-        assert result.top_p == 0.9
+        assert result.identifier.temperature == 0.7
+        assert result.identifier.top_p == 0.9
         assert result.target_specific_params is not None
         assert result.target_specific_params["frequency_penalty"] == 0.5
         assert result.target_specific_params["presence_penalty"] == 0.3
@@ -1729,7 +1732,7 @@ def test_round_robin_populates_inner_targets(self) -> None:
             params={"endpoint": "https://b.openai.azure.com", "model_name": "gpt-4o"},
         )
 
-        rr._targets = [inner_a, inner_b]
+        rr.inner_targets = [inner_a, inner_b]
         rr.get_identifier.return_value = ComponentIdentifier(
             class_name="RoundRobinTarget",
             class_module="pyrit.prompt_target.round_robin_target",
@@ -1738,14 +1741,19 @@ def test_round_robin_populates_inner_targets(self) -> None:
 
         result = target_object_to_instance("rr-1", rr)
 
-        assert result.target_type == "RoundRobinTarget"
+        assert result.identifier.class_name == "RoundRobinTarget"
         assert result.inner_targets is not None
         assert len(result.inner_targets) == 2
-        assert result.inner_targets[0].endpoint == "https://a.openai.azure.com"
-        assert result.inner_targets[1].endpoint == "https://b.openai.azure.com"
+        assert result.inner_targets[0].identifier.endpoint == "https://a.openai.azure.com"
+        assert result.inner_targets[1].identifier.endpoint == "https://b.openai.azure.com"
+
+    def test_round_robin_identifier_carries_no_model_name(self) -> None:
+        """The composite identifier owns no model_name; inner targets carry theirs.
 
-    def test_round_robin_hoists_model_name_when_all_inner_targets_match(self) -> None:
-        """model_name is hoisted only when all inner targets share the same deployment name."""
+        Hoisting a shared model name for display is now the frontend's concern
+        (``targetIdentity.hoistFromInner``); the mapper faithfully reflects that a
+        RoundRobinTarget's own identifier has no model_name.
+        """
         from pyrit.prompt_target.round_robin_target import RoundRobinTarget
 
         rr = MagicMock(spec=RoundRobinTarget)
@@ -1767,7 +1775,7 @@ def test_round_robin_hoists_model_name_when_all_inner_targets_match(self) -> Non
             params={"model_name": "gpt-4o", "underlying_model_name": "gpt-4o"},
         )
 
-        rr._targets = [inner_a, inner_b]
+        rr.inner_targets = [inner_a, inner_b]
         rr.get_identifier.return_value = ComponentIdentifier(
             class_name="RoundRobinTarget",
             class_module="pyrit.prompt_target.round_robin_target",
@@ -1776,11 +1784,14 @@ def test_round_robin_hoists_model_name_when_all_inner_targets_match(self) -> Non
 
         result = target_object_to_instance("rr-2", rr)
 
-        assert result.model_name == "gpt-4o"
-        assert result.underlying_model_name == "gpt-4o"
+        assert result.identifier.model_name is None
+        assert result.identifier.underlying_model_name is None
+        assert result.inner_targets is not None
+        assert result.inner_targets[0].identifier.model_name == "gpt-4o"
+        assert result.inner_targets[1].identifier.underlying_model_name == "gpt-4o"
 
-    def test_round_robin_omits_model_name_when_inner_targets_differ(self) -> None:
-        """model_name is None when inner targets have different deployment names."""
+    def test_round_robin_inner_targets_retain_distinct_models(self) -> None:
+        """Inner targets keep their own deployment names; the mapper does not merge them."""
         from pyrit.prompt_target.round_robin_target import RoundRobinTarget
 
         rr = MagicMock(spec=RoundRobinTarget)
@@ -1802,7 +1813,7 @@ def test_round_robin_omits_model_name_when_inner_targets_differ(self) -> None:
             params={"model_name": "deploy-us", "underlying_model_name": "gpt-4o"},
         )
 
-        rr._targets = [inner_a, inner_b]
+        rr.inner_targets = [inner_a, inner_b]
         rr.get_identifier.return_value = ComponentIdentifier(
             class_name="RoundRobinTarget",
             class_module="pyrit.prompt_target.round_robin_target",
@@ -1811,10 +1822,10 @@ def test_round_robin_omits_model_name_when_inner_targets_differ(self) -> None:
 
         result = target_object_to_instance("rr-3", rr)
 
-        # model_name should be None since deployments differ
-        assert result.model_name is None
-        # underlying_model_name should still be hoisted (they all share gpt-4o)
-        assert result.underlying_model_name == "gpt-4o"
+        assert result.identifier.model_name is None
+        assert result.inner_targets is not None
+        assert result.inner_targets[0].identifier.model_name == "deploy-japan"
+        assert result.inner_targets[1].identifier.model_name == "deploy-us"
 
     def test_non_round_robin_has_no_inner_targets(self) -> None:
         """Regular targets return None for inner_targets."""
diff --git a/tests/unit/backend/test_target_service.py b/tests/unit/backend/test_target_service.py
index f8926b5778..8a70b7c9bc 100644
--- a/tests/unit/backend/test_target_service.py
+++ b/tests/unit/backend/test_target_service.py
@@ -13,8 +13,9 @@
 from pyrit.backend.models.targets import CreateTargetRequest
 from pyrit.backend.services.target_service import TargetService, get_target_service
 from pyrit.models import ComponentIdentifier
-from pyrit.prompt_target import PromptTarget
+from pyrit.prompt_target import PromptTarget, TargetCapabilities
 from pyrit.registry import TargetRegistry
+from unit.mocks import MockPromptTarget
 
 
 @pytest.fixture(autouse=True)
@@ -43,6 +44,14 @@ def _mock_target_identifier(*, class_name: str = "MockTarget", **kwargs) -> Comp
     )
 
 
+def _mock_prompt_target(*, identifier: ComponentIdentifier | None = None) -> MagicMock:
+    """Create a MagicMock PromptTarget with an identifier and default capabilities."""
+    mock_target = MagicMock(spec=PromptTarget)
+    mock_target.get_identifier.return_value = identifier if identifier is not None else _mock_target_identifier()
+    mock_target.capabilities = TargetCapabilities()
+    return mock_target
+
+
 async def _test_token_provider() -> str:
     """Shared async token provider used in Entra authentication tests."""
     return "test-token"
@@ -65,15 +74,14 @@ async def test_list_targets_returns_targets_from_registry(self) -> None:
         service = TargetService()
 
         # Register a mock target
-        mock_target = MagicMock(spec=PromptTarget)
-        mock_target.get_identifier.return_value = _mock_target_identifier(endpoint="http://test")
+        mock_target = _mock_prompt_target(identifier=_mock_target_identifier(endpoint="http://test"))
         service._registry.instances.register(mock_target, name="target-1")
 
         result = await service.list_targets_async()
 
         assert len(result.items) == 1
         assert result.items[0].target_registry_name == "target-1"
-        assert result.items[0].target_type == "MockTarget"
+        assert result.items[0].identifier.class_name == "MockTarget"
         assert result.pagination.has_more is False
 
     async def test_list_targets_paginates_with_limit(self) -> None:
@@ -81,8 +89,7 @@ async def test_list_targets_paginates_with_limit(self) -> None:
         service = TargetService()
 
         for i in range(5):
-            mock_target = MagicMock(spec=PromptTarget)
-            mock_target.get_identifier.return_value = _mock_target_identifier()
+            mock_target = _mock_prompt_target()
             service._registry.instances.register(mock_target, name=f"target-{i}")
 
         result = await service.list_targets_async(limit=3)
@@ -97,8 +104,7 @@ async def test_list_targets_cursor_returns_next_page(self) -> None:
         service = TargetService()
 
         for i in range(5):
-            mock_target = MagicMock(spec=PromptTarget)
-            mock_target.get_identifier.return_value = _mock_target_identifier()
+            mock_target = _mock_prompt_target()
             service._registry.instances.register(mock_target, name=f"target-{i}")
 
         first_page = await service.list_targets_async(limit=2)
@@ -113,8 +119,7 @@ async def test_list_targets_last_page_has_no_more(self) -> None:
         service = TargetService()
 
         for i in range(3):
-            mock_target = MagicMock(spec=PromptTarget)
-            mock_target.get_identifier.return_value = _mock_target_identifier()
+            mock_target = _mock_prompt_target()
             service._registry.instances.register(mock_target, name=f"target-{i}")
 
         first_page = await service.list_targets_async(limit=2)
@@ -140,21 +145,19 @@ async def test_get_target_returns_target_from_registry(self) -> None:
         """Test that get_target returns target built from registry object."""
         service = TargetService()
 
-        mock_target = MagicMock(spec=PromptTarget)
-        mock_target.get_identifier.return_value = _mock_target_identifier()
+        mock_target = _mock_prompt_target()
         service._registry.instances.register(mock_target, name="target-1")
 
         result = await service.get_target_async(target_registry_name="target-1")
 
         assert result is not None
         assert result.target_registry_name == "target-1"
-        assert result.target_type == "MockTarget"
+        assert result.identifier.class_name == "MockTarget"
 
     async def test_list_targets_includes_extra_params_in_target_specific(self) -> None:
         """Test that extra identifier params (reasoning_effort etc.) appear in target_specific_params."""
         service = TargetService()
 
-        mock_target = MagicMock(spec=PromptTarget)
         identifier = ComponentIdentifier(
             class_name="OpenAIResponseTarget",
             class_module="pyrit.prompt_target",
@@ -167,14 +170,14 @@ async def test_list_targets_includes_extra_params_in_target_specific(self) -> No
                 "max_output_tokens": 4096,
             },
         )
-        mock_target.get_identifier.return_value = identifier
+        mock_target = _mock_prompt_target(identifier=identifier)
         service._registry.instances.register(mock_target, name="response-target")
 
         result = await service.list_targets_async()
 
         assert len(result.items) == 1
         target = result.items[0]
-        assert target.temperature == 1.0
+        assert target.identifier.temperature == 1.0
         assert target.target_specific_params is not None
         assert target.target_specific_params["reasoning_effort"] == "high"
         assert target.target_specific_params["reasoning_summary"] == "auto"
@@ -184,7 +187,6 @@ async def test_get_target_includes_extra_params_in_target_specific(self) -> None
         """Test that get_target returns target_specific_params with extra identifier params."""
         service = TargetService()
 
-        mock_target = MagicMock(spec=PromptTarget)
         identifier = ComponentIdentifier(
             class_name="OpenAIChatTarget",
             class_module="pyrit.prompt_target",
@@ -195,7 +197,7 @@ async def test_get_target_includes_extra_params_in_target_specific(self) -> None
                 "seed": 42,
             },
         )
-        mock_target.get_identifier.return_value = identifier
+        mock_target = _mock_prompt_target(identifier=identifier)
         service._registry.instances.register(mock_target, name="chat-target")
 
         result = await service.get_target_async(target_registry_name="chat-target")
@@ -228,6 +230,30 @@ def test_get_target_object_returns_object_from_registry(self) -> None:
         assert result is mock_target
 
 
+class TestListTargetCatalog:
+    """Tests for TargetService.list_target_catalog_async method."""
+
+    async def test_catalog_returns_known_target_types(self) -> None:
+        """The catalog exposes constructible target classes from the registry."""
+        service = TargetService()
+
+        result = await service.list_target_catalog_async()
+
+        target_types = [item.target_type for item in result.items]
+        assert "OpenAIChatTarget" in target_types
+        assert "AzureMLChatTarget" in target_types
+
+    async def test_catalog_includes_declarative_auth_facts(self) -> None:
+        """Catalog entries surface the per-class auth facts the frontend needs."""
+        service = TargetService()
+
+        result = await service.list_target_catalog_async()
+
+        openai_entry = next(item for item in result.items if item.target_type == "OpenAIChatTarget")
+        assert "api_key" in openai_entry.supported_auth_modes
+        assert "identity" in openai_entry.supported_auth_modes
+
+
 class TestCreateTarget:
     """Tests for TargetService.create_target method."""
 
@@ -255,7 +281,7 @@ async def test_create_target_success(self, sqlite_instance) -> None:
         result = await service.create_target_async(request=request)
 
         assert result.target_registry_name is not None
-        assert result.target_type == "TextTarget"
+        assert result.identifier.class_name == "TextTarget"
 
     async def test_create_target_registers_in_registry(self, sqlite_instance) -> None:
         """Test that create_target registers object in registry."""
@@ -288,9 +314,9 @@ async def test_create_target_model_name_not_overridden_by_env_var(self, sqlite_i
 
             result = await service.create_target_async(request=request)
 
-            assert result.model_name == "claude-sonnet-4-6"
-            # underlying_model_name should be None since no underlying_model was passed
-            assert result.underlying_model_name is None
+            assert result.identifier.model_name == "claude-sonnet-4-6"
+            # underlying_model_name is empty since no underlying_model was passed
+            assert not result.identifier.underlying_model_name
 
     async def test_create_target_with_different_underlying_model(self, sqlite_instance) -> None:
         """Test that explicit underlying_model is used when it differs from model_name."""
@@ -308,457 +334,211 @@ async def test_create_target_with_different_underlying_model(self, sqlite_instan
 
         result = await service.create_target_async(request=request)
 
-        assert result.model_name == "my-gpt4o-deployment"
-        assert result.underlying_model_name == "gpt-4o"
+        assert result.identifier.model_name == "my-gpt4o-deployment"
+        assert result.identifier.underlying_model_name == "gpt-4o"
 
 
 class TestCreateTargetEntraAuth:
-    """Test that creating targets with Entra auth mode properly authenticates and handles edge cases."""
+    """Entra auth at the service boundary: the service only omits the api_key and
+    confirms the target type supports Entra. Endpoint trust + token minting are the
+    target's job and are covered in the target-level tests (see
+    tests/unit/prompt_target/target/)."""
 
-    async def test_create_openai_target_with_entra_injects_token_provider(self, sqlite_instance) -> None:
-        """Entra auth path: api_key is replaced with the authentication callable"""
-
-        with patch(
-            "pyrit.backend.services.target_service.get_azure_openai_auth",
-            return_value=_test_token_provider,
-        ) as mock_get_auth:
-            service = TargetService()
+    async def test_create_openai_target_with_entra_omits_key_and_target_mints_token(self, sqlite_instance) -> None:
+        """Entra path: the service omits the api_key so the target mints its own token."""
 
-            request = CreateTargetRequest(
-                type="OpenAIChatTarget",
-                params={
-                    "endpoint": "https://test.openai.azure.com/",
-                    "model_name": "gpt-4o",
-                },
-                auth_mode="entra",
-            )
-
-            result = await service.create_target_async(request=request)
-
-            mock_get_auth.assert_called_once_with("https://test.openai.azure.com/")
-            target_obj = service.get_target_object(target_registry_name=result.target_registry_name)
-            assert target_obj is not None
-            # OpenAI target preserves async callables verbatim through ensure_async_token_provider.
-            assert target_obj._api_key is _test_token_provider  # type: ignore[attr-defined]
-
-    async def test_create_openai_target_with_entra_drops_user_api_key(self, sqlite_instance) -> None:
-        """Any api_key supplied alongside auth_mode='entra' must be discarded."""
-
-        with patch(
-            "pyrit.backend.services.target_service.get_azure_openai_auth",
-            return_value=_test_token_provider,
-        ):
-            service = TargetService()
-
-            request = CreateTargetRequest(
-                type="OpenAIChatTarget",
-                params={
-                    "endpoint": "https://test.openai.azure.com/",
-                    "model_name": "gpt-4o",
-                    "api_key": "should-be-ignored",
-                },
-                auth_mode="entra",
-            )
-
-            result = await service.create_target_async(request=request)
-
-            target_obj = service.get_target_object(target_registry_name=result.target_registry_name)
-            assert target_obj is not None
-            assert target_obj._api_key is _test_token_provider  # type: ignore[attr-defined]
-            # The literal "should-be-ignored" string must never appear.
-            assert target_obj._api_key != "should-be-ignored"  # type: ignore[attr-defined]
+        with patch.dict(os.environ, {}, clear=False):
+            os.environ.pop("OPENAI_CHAT_KEY", None)
+            with patch(
+                "pyrit.prompt_target.openai.openai_target.get_azure_openai_auth",
+                return_value=_test_token_provider,
+            ) as mock_get_auth:
+                service = TargetService()
+
+                request = CreateTargetRequest(
+                    type="OpenAIChatTarget",
+                    params={
+                        "endpoint": "https://test.openai.azure.com/",
+                        "model_name": "gpt-4o",
+                    },
+                    auth_mode="identity",
+                )
+
+                result = await service.create_target_async(request=request)
+
+                mock_get_auth.assert_called_once_with("https://test.openai.azure.com/")
+                target_obj = service.get_target_object(target_registry_name=result.target_registry_name)
+                assert target_obj is not None
+                # OpenAI target preserves async callables verbatim through ensure_async_token_provider.
+                assert target_obj._api_key is _test_token_provider  # type: ignore[attr-defined]
+
+    async def test_create_openai_target_with_identity_drops_user_api_key(self, sqlite_instance) -> None:
+        """Any api_key supplied alongside auth_mode='identity' must be discarded."""
 
-    async def test_create_openai_target_with_entra_does_not_mutate_request_params(self, sqlite_instance) -> None:
+        with patch.dict(os.environ, {}, clear=False):
+            os.environ.pop("OPENAI_CHAT_KEY", None)
+            with patch(
+                "pyrit.prompt_target.openai.openai_target.get_azure_openai_auth",
+                return_value=_test_token_provider,
+            ):
+                service = TargetService()
+
+                request = CreateTargetRequest(
+                    type="OpenAIChatTarget",
+                    params={
+                        "endpoint": "https://test.openai.azure.com/",
+                        "model_name": "gpt-4o",
+                        "api_key": "should-be-ignored",
+                    },
+                    auth_mode="identity",
+                )
+
+                result = await service.create_target_async(request=request)
+
+                target_obj = service.get_target_object(target_registry_name=result.target_registry_name)
+                assert target_obj is not None
+                assert target_obj._api_key is _test_token_provider  # type: ignore[attr-defined]
+                # The literal "should-be-ignored" string must never appear.
+                assert target_obj._api_key != "should-be-ignored"  # type: ignore[attr-defined]
+
+    async def test_create_openai_target_with_identity_does_not_mutate_request_params(self, sqlite_instance) -> None:
         """The CreateTargetRequest.params object must remain unchanged after creation."""
 
-        with patch(
-            "pyrit.backend.services.target_service.get_azure_openai_auth",
-            return_value=_test_token_provider,
-        ):
-            service = TargetService()
-
-            original_params = {
-                "endpoint": "https://test.openai.azure.com/",
-                "model_name": "gpt-4o",
-                "api_key": "original-key",
-            }
-            request = CreateTargetRequest(
-                type="OpenAIChatTarget",
-                params=dict(original_params),
-                auth_mode="entra",
-            )
-
-            await service.create_target_async(request=request)
-
-            # The caller's request.params must be unchanged after the call.
-            assert request.params == original_params
-
-    async def test_create_openai_target_with_entra_non_azure_endpoint_raises(self, sqlite_instance) -> None:
-        """Entra ID requires a known Azure OpenAI / AI Foundry hostname suffix."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="OpenAIChatTarget",
-            params={"endpoint": "https://api.openai.com/"},
-            auth_mode="entra",
-        )
-
-        with pytest.raises(ValueError, match="Azure endpoint"):
-            await service.create_target_async(request=request)
-
-    async def test_create_openai_target_with_entra_substring_lookalike_endpoint_raises(self, sqlite_instance) -> None:
-        """Substring 'azure' in the hostname must not be enough to pass Entra validation."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="OpenAIChatTarget",
-            # Hostname contains 'azure' but does NOT end with an approved suffix.
-            params={"endpoint": "https://evil-azure.example.com/"},
-            auth_mode="entra",
-        )
-
-        with pytest.raises(ValueError, match="Azure endpoint"):
-            await service.create_target_async(request=request)
-
-    async def test_create_openai_target_with_entra_missing_endpoint_raises(self, sqlite_instance) -> None:
-        """Entra ID for OpenAI must reject a missing endpoint with a clear error."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="OpenAIChatTarget",
-            params={},
-            auth_mode="entra",
-        )
-
-        with pytest.raises(ValueError, match="endpoint"):
-            await service.create_target_async(request=request)
-
-    async def test_create_azureml_target_with_entra_injects_token_provider(self, sqlite_instance) -> None:
-        """AzureML Entra path: api_key is replaced with the ML scope token provider."""
-
-        with patch(
-            "pyrit.backend.services.target_service.get_azure_async_token_provider",
-            return_value=_test_token_provider,
-        ) as mock_get_provider:
-            service = TargetService()
-
-            request = CreateTargetRequest(
-                type="AzureMLChatTarget",
-                params={"endpoint": "https://my-aml.region.inference.ml.azure.com/score"},
-                auth_mode="entra",
-            )
-
-            result = await service.create_target_async(request=request)
-
-            mock_get_provider.assert_called_once_with("https://ml.azure.com/.default")
-            target_obj = service.get_target_object(target_registry_name=result.target_registry_name)
-            assert target_obj is not None
-            # AzureMLChatTarget stores the provider on _api_key_provider; static _api_key is cleared.
-            assert target_obj._api_key_provider is _test_token_provider  # type: ignore[attr-defined]
-            assert target_obj._api_key == ""  # type: ignore[attr-defined]
-
-    async def test_create_azureml_target_with_entra_non_aml_endpoint_raises(self, sqlite_instance) -> None:
-        """Entra ID for AzureMLChatTarget requires a known AML hostname suffix."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="AzureMLChatTarget",
-            params={"endpoint": "https://example.com/score"},
-            auth_mode="entra",
-        )
-
-        with pytest.raises(ValueError, match="AML endpoint"):
-            await service.create_target_async(request=request)
-
-    async def test_create_azureml_target_with_entra_substring_lookalike_endpoint_raises(self, sqlite_instance) -> None:
-        """Substring 'inference.ml.azure.com' in the hostname must not be enough to pass AML validation."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="AzureMLChatTarget",
-            # Hostname contains the AML suffix as a substring but does NOT end with it.
-            params={"endpoint": "https://evil-inference.ml.azure.com.attacker.com/score"},
-            auth_mode="entra",
-        )
-
-        with pytest.raises(ValueError, match="AML endpoint"):
-            await service.create_target_async(request=request)
-
-    async def test_create_azureml_target_with_entra_missing_endpoint_raises(self, sqlite_instance) -> None:
-        """Entra ID for AzureMLChatTarget must reject a missing endpoint with a clear error."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="AzureMLChatTarget",
-            params={},
-            auth_mode="entra",
-        )
-
-        with pytest.raises(ValueError, match="endpoint"):
-            await service.create_target_async(request=request)
-
-    async def test_create_target_entra_unsupported_type_raises(self, sqlite_instance) -> None:
-        """Entra ID is only supported for OpenAI-family and AzureMLChatTarget."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="TextTarget",
-            params={},
-            auth_mode="entra",
-        )
-
-        with pytest.raises(ValueError, match="does not support Entra"):
-            await service.create_target_async(request=request)
-
-
-class TestCreateTargetApiKeyAuth:
-    """Test that auth_mode='api_key' strictly requires a key in params or environment."""
-
-    async def test_create_openai_target_api_key_mode_without_key_raises(self, sqlite_instance) -> None:
-        """Without an api_key (params or env), OpenAITarget would silently fall back to Entra;
-        the service must reject this so the user's explicit choice is honored."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="OpenAIChatTarget",
-            params={
-                "model_name": "gpt-4o",
-                "endpoint": "https://test.openai.azure.com/",
-            },
-            auth_mode="api_key",
-        )
-
         with patch.dict(os.environ, {}, clear=False):
             os.environ.pop("OPENAI_CHAT_KEY", None)
-            with pytest.raises(ValueError, match="auth_mode='api_key' requires an API key"):
-                await service.create_target_async(request=request)
+            with patch(
+                "pyrit.prompt_target.openai.openai_target.get_azure_openai_auth",
+                return_value=_test_token_provider,
+            ):
+                service = TargetService()
 
-    async def test_create_openai_target_api_key_mode_with_env_var_succeeds(self, sqlite_instance) -> None:
-        """An env-var-supplied key satisfies the api_key requirement."""
-        service = TargetService()
-
-        request = CreateTargetRequest(
-            type="OpenAIChatTarget",
-            params={
-                "model_name": "gpt-4o",
-                "endpoint": "https://test.openai.azure.com/",
-            },
-            auth_mode="api_key",
-        )
+                original_params = {
+                    "endpoint": "https://test.openai.azure.com/",
+                    "model_name": "gpt-4o",
+                    "api_key": "original-key",
+                }
+                request = CreateTargetRequest(
+                    type="OpenAIChatTarget",
+                    params=dict(original_params),
+                    auth_mode="identity",
+                )
 
-        with patch.dict(os.environ, {"OPENAI_CHAT_KEY": "env-test-key"}):
-            result = await service.create_target_async(request=request)
+                await service.create_target_async(request=request)
 
-        assert result.target_type == "OpenAIChatTarget"
+                # The caller's request.params must be unchanged after the call.
+                assert request.params == original_params
 
-    async def test_create_openai_target_api_key_mode_rejects_empty_key(self, sqlite_instance) -> None:
-        """An empty-string api_key counts as missing and must be rejected."""
-        service = TargetService()
+    async def test_create_azureml_target_with_identity_omits_key_and_target_mints_token(self, sqlite_instance) -> None:
+        """AzureML identity path: the service omits the key so the target mints the ML scope token."""
 
-        request = CreateTargetRequest(
-            type="OpenAIChatTarget",
-            params={
-                "model_name": "gpt-4o",
-                "endpoint": "https://test.openai.azure.com/",
-                "api_key": "",
-            },
-            auth_mode="api_key",
-        )
+        with patch.dict(os.environ, {}, clear=False):
+            os.environ.pop("AZURE_ML_KEY", None)
+            with patch(
+                "pyrit.prompt_target.azure_ml_chat_target.get_azure_async_token_provider",
+                return_value=_test_token_provider,
+            ) as mock_get_provider:
+                service = TargetService()
+
+                request = CreateTargetRequest(
+                    type="AzureMLChatTarget",
+                    params={"endpoint": "https://my-aml.region.inference.ml.azure.com/score"},
+                    auth_mode="identity",
+                )
+
+                result = await service.create_target_async(request=request)
+
+                mock_get_provider.assert_called_once_with("https://ml.azure.com/.default")
+                target_obj = service.get_target_object(target_registry_name=result.target_registry_name)
+                assert target_obj is not None
+                # AzureMLChatTarget stores the provider on _api_key_provider; static _api_key is cleared.
+                assert target_obj._api_key_provider is _test_token_provider  # type: ignore[attr-defined]
+                assert target_obj._api_key == ""  # type: ignore[attr-defined]
+
+    async def test_create_openai_target_with_identity_non_azure_endpoint_raises(self, sqlite_instance) -> None:
+        """The target (not the service) rejects an unrecognized endpoint under identity auth."""
 
         with patch.dict(os.environ, {}, clear=False):
             os.environ.pop("OPENAI_CHAT_KEY", None)
-            with pytest.raises(ValueError, match="auth_mode='api_key' requires an API key"):
-                await service.create_target_async(request=request)
-
-    async def test_create_azureml_target_api_key_mode_without_key_raises(self, sqlite_instance) -> None:
-        """AzureMLChatTarget in api_key mode also requires an explicit key."""
-        service = TargetService()
+            service = TargetService()
 
-        request = CreateTargetRequest(
-            type="AzureMLChatTarget",
-            params={"endpoint": "https://my-endpoint.eastus.inference.ml.azure.com/score"},
-            auth_mode="api_key",
-        )
+            request = CreateTargetRequest(
+                type="OpenAIChatTarget",
+                params={"endpoint": "https://api.openai.com/", "model_name": "gpt-4o"},
+                auth_mode="identity",
+            )
 
-        with patch.dict(os.environ, {}, clear=False):
-            os.environ.pop("AZURE_ML_KEY", None)
-            with pytest.raises(ValueError, match="auth_mode='api_key' requires an API key"):
+            with pytest.raises(ValueError, match="non-Azure endpoints"):
                 await service.create_target_async(request=request)
 
-    async def test_create_text_target_api_key_mode_skips_validation(self, sqlite_instance) -> None:
-        """Targets without an api_key_environment_variable (e.g. TextTarget) are unaffected."""
+    async def test_create_target_identity_unsupported_type_raises(self, sqlite_instance) -> None:
+        """Identity-based auth is only supported for targets that declare it."""
         service = TargetService()
 
         request = CreateTargetRequest(
             type="TextTarget",
             params={},
-            auth_mode="api_key",
+            auth_mode="identity",
         )
 
-        result = await service.create_target_async(request=request)
-        assert result.target_type == "TextTarget"
+        with pytest.raises(ValueError, match="does not support identity-based authentication"):
+            await service.create_target_async(request=request)
 
 
 class TestCreateRoundRobinTarget:
-    """Tests for creating RoundRobinTarget via the service."""
+    """Service-level tests for building RoundRobinTarget through the registry.
+
+    The service passes ``targets`` (registry names) to ``registry.create_instance``;
+    the resolver turns the names into live target objects and RoundRobinTarget owns
+    its own construction validation (dedup, class/config consistency). Those rules
+    are covered in tests/unit/prompt_target/test_round_robin_target.py — here we only
+    exercise the service wiring.
+    """
 
     async def test_create_round_robin_target_resolves_registry_names(self, sqlite_instance) -> None:
         """RoundRobinTarget creation resolves registry names to live target objects."""
         service = TargetService()
 
-        # Register two mock targets in the registry to serve as inner targets.
-        # We mock the RoundRobinTarget constructor because it does deep validation
-        # (same class, multi-turn, editable history) that requires real compatible
-        # targets. The service's job is to resolve registry names and pass them
-        # through — the constructor validation is tested in RoundRobinTarget's own tests.
-        mock_a = MagicMock(spec=PromptTarget)
-        mock_a.get_identifier.return_value = _mock_target_identifier(
-            class_name="OpenAIChatTarget", endpoint="https://a.openai.azure.com", model_name="gpt-4o"
-        )
-        mock_b = MagicMock(spec=PromptTarget)
-        mock_b.get_identifier.return_value = _mock_target_identifier(
-            class_name="OpenAIChatTarget", endpoint="https://b.openai.azure.com", model_name="gpt-4o"
-        )
-        service._registry.instances.register(mock_a, name="target-a")
-        service._registry.instances.register(mock_b, name="target-b")
-
-        # Patch RoundRobinTarget so the constructor returns a mock that behaves
-        # like a registered target (has get_identifier, capabilities, etc.)
-        mock_rr = MagicMock(spec=PromptTarget)
-        mock_rr.get_identifier.return_value = ComponentIdentifier(
-            class_name="RoundRobinTarget",
-            class_module="pyrit.prompt_target.round_robin_target",
-            params={"weights": [2, 1]},
-        )
-        mock_rr._targets = [mock_a, mock_b]
-
-        with patch(
-            "pyrit.backend.services.target_service.RoundRobinTarget",
-            return_value=mock_rr,
-        ) as mock_rr_cls:
-            rr_request = CreateTargetRequest(
-                type="RoundRobinTarget",
-                params={
-                    "target_registry_names": ["target-a", "target-b"],
-                    "weights": [2, 1],
-                },
-            )
-
-            result = await service.create_target_async(request=rr_request)
-
-            # Verify the constructor was called with the resolved targets and weights
-            mock_rr_cls.assert_called_once_with(targets=[mock_a, mock_b], weights=[2, 1])
-            assert result.target_type == "RoundRobinTarget"
-
-    async def test_create_round_robin_target_fewer_than_2_raises(self, sqlite_instance) -> None:
-        """RoundRobinTarget with fewer than 2 registry names raises ValueError."""
-        service = TargetService()
+        target_a = MockPromptTarget()
+        target_b = MockPromptTarget()
+        service._registry.instances.register(target_a, name="target-a")
+        service._registry.instances.register(target_b, name="target-b")
 
         rr_request = CreateTargetRequest(
             type="RoundRobinTarget",
-            params={"target_registry_names": ["only-one"]},
+            params={"targets": ["target-a", "target-b"], "weights": [2, 1]},
         )
 
-        with pytest.raises(ValueError, match="at least 2"):
-            await service.create_target_async(request=rr_request)
-
-    async def test_create_round_robin_target_unknown_name_raises(self, sqlite_instance) -> None:
-        """RoundRobinTarget with a non-existent registry name raises ValueError."""
-        service = TargetService()
+        result = await service.create_target_async(request=rr_request)
 
-        rr_request = CreateTargetRequest(
-            type="RoundRobinTarget",
-            params={"target_registry_names": ["does-not-exist-a", "does-not-exist-b"]},
-        )
-
-        with pytest.raises(ValueError, match="not found"):
-            await service.create_target_async(request=rr_request)
-
-    async def test_create_round_robin_target_deduplicates_identical_targets(self, sqlite_instance) -> None:
-        """Targets that resolve to the same identifier hash are deduplicated, and
-        the corresponding weights are dropped alongside them."""
-        service = TargetService()
-
-        # mock_a and mock_a_alias share the same identifier params, so their
-        # ComponentIdentifier.hash is identical — they should dedupe to one entry.
-        identifier_a = _mock_target_identifier(
-            class_name="OpenAIChatTarget", endpoint="https://a.openai.azure.com", model_name="gpt-4o"
-        )
-        mock_a = MagicMock(spec=PromptTarget)
-        mock_a.get_identifier.return_value = identifier_a
-        mock_a_alias = MagicMock(spec=PromptTarget)
-        mock_a_alias.get_identifier.return_value = identifier_a
-
-        mock_b = MagicMock(spec=PromptTarget)
-        mock_b.get_identifier.return_value = _mock_target_identifier(
-            class_name="OpenAIChatTarget", endpoint="https://b.openai.azure.com", model_name="gpt-4o"
-        )
-
-        service._registry.instances.register(mock_a, name="target-a")
-        service._registry.instances.register(mock_a_alias, name="target-a-alias")
-        service._registry.instances.register(mock_b, name="target-b")
-
-        mock_rr = MagicMock(spec=PromptTarget)
-        mock_rr.get_identifier.return_value = ComponentIdentifier(
-            class_name="RoundRobinTarget",
-            class_module="pyrit.prompt_target.round_robin_target",
-            params={"weights": [3, 1]},
-        )
-        mock_rr._targets = [mock_a, mock_b]
-
-        with patch(
-            "pyrit.backend.services.target_service.RoundRobinTarget",
-            return_value=mock_rr,
-        ) as mock_rr_cls:
-            rr_request = CreateTargetRequest(
-                type="RoundRobinTarget",
-                params={
-                    "target_registry_names": ["target-a", "target-a-alias", "target-b"],
-                    "weights": [3, 2, 1],
-                },
-            )
-
-            await service.create_target_async(request=rr_request)
-
-            # The duplicate alias and its weight (2) should be dropped.
-            mock_rr_cls.assert_called_once_with(targets=[mock_a, mock_b], weights=[3, 1])
+        assert result.identifier.class_name == "RoundRobinTarget"
+        target_obj = service.get_target_object(target_registry_name=result.target_registry_name)
+        assert target_obj._targets == [target_a, target_b]
+        assert target_obj._weights == [2, 1]
 
-    async def test_create_round_robin_target_all_duplicates_raises(self, sqlite_instance) -> None:
-        """If dedup leaves fewer than 2 distinct targets, raise a clear error."""
+    async def test_create_round_robin_target_fewer_than_2_raises(self, sqlite_instance) -> None:
+        """A single inner target bubbles up RoundRobinTarget's own validation error."""
         service = TargetService()
 
-        identifier = _mock_target_identifier(
-            class_name="OpenAIChatTarget", endpoint="https://a.openai.azure.com", model_name="gpt-4o"
-        )
-        mock_a = MagicMock(spec=PromptTarget)
-        mock_a.get_identifier.return_value = identifier
-        mock_a_alias = MagicMock(spec=PromptTarget)
-        mock_a_alias.get_identifier.return_value = identifier
-
-        service._registry.instances.register(mock_a, name="target-a")
-        service._registry.instances.register(mock_a_alias, name="target-a-alias")
+        service._registry.instances.register(MockPromptTarget(), name="only-one")
 
         rr_request = CreateTargetRequest(
             type="RoundRobinTarget",
-            params={"target_registry_names": ["target-a", "target-a-alias"]},
+            params={"targets": ["only-one"]},
         )
 
-        with pytest.raises(ValueError, match="at least 2 distinct targets"):
+        with pytest.raises(ValueError, match="at least 2 targets"):
             await service.create_target_async(request=rr_request)
 
-    async def test_create_round_robin_target_weights_length_mismatch_raises(self, sqlite_instance) -> None:
-        """Mismatched weights length raises before any registry lookups."""
+    async def test_create_round_robin_target_unknown_name_raises(self, sqlite_instance) -> None:
+        """A non-existent registry name is rejected by the resolver."""
         service = TargetService()
 
         rr_request = CreateTargetRequest(
             type="RoundRobinTarget",
-            params={
-                "target_registry_names": ["a", "b", "c"],
-                "weights": [1, 2],
-            },
+            params={"targets": ["does-not-exist-a", "does-not-exist-b"]},
         )
 
-        with pytest.raises(ValueError, match="weights length"):
+        with pytest.raises(ValueError, match="not found"):
             await service.create_target_async(request=rr_request)
 
 
diff --git a/tests/unit/cli/test_api_client.py b/tests/unit/cli/test_api_client.py
index 63a1de07a3..df888e7ec6 100644
--- a/tests/unit/cli/test_api_client.py
+++ b/tests/unit/cli/test_api_client.py
@@ -12,13 +12,12 @@
 import pytest
 
 from pyrit.cli.api_client import PyRITApiClient, ServerNotAvailableError
-from pyrit.models import ScenarioRunState
+from pyrit.models import ScenarioRunState, TargetCapabilities
 from pyrit.models.catalog import (
     RegisteredInitializer,
     RegisteredScenario,
     RunScenarioRequest,
     ScenarioRunSummary,
-    TargetCapabilitiesInfo,
     TargetInstance,
 )
 from unit.mocks import make_scenario_result
@@ -78,17 +77,13 @@ def _initializer_payload(*, initializer_name: str = "x") -> dict:
 def _target_payload(*, target_registry_name: str = "t1") -> dict:
     return {
         "target_registry_name": target_registry_name,
-        "target_type": "OpenAIChatTarget",
-        "endpoint": None,
-        "model_name": None,
-        "underlying_model_name": None,
-        "temperature": None,
-        "top_p": None,
-        "max_requests_per_minute": None,
-        "capabilities": TargetCapabilitiesInfo().model_dump(mode="json"),
+        "identifier": {
+            "class_name": "OpenAIChatTarget",
+            "class_module": "pyrit.prompt_target",
+        },
+        "capabilities": TargetCapabilities().model_dump(mode="json"),
         "target_specific_params": None,
         "inner_targets": None,
-        "identifier_hash": None,
     }
 
 
diff --git a/tests/unit/cli/test_output.py b/tests/unit/cli/test_output.py
index 8561e01f24..a02dec1018 100644
--- a/tests/unit/cli/test_output.py
+++ b/tests/unit/cli/test_output.py
@@ -14,12 +14,11 @@
 from unittest.mock import AsyncMock, MagicMock, patch
 
 from pyrit.cli import _output
-from pyrit.models import Parameter, ScenarioRunState
+from pyrit.models import Parameter, ScenarioRunState, TargetCapabilities, TargetIdentifier
 from pyrit.models.catalog import (
     RegisteredInitializer,
     RegisteredScenario,
     ScenarioRunSummary,
-    TargetCapabilitiesInfo,
     TargetInstance,
 )
 from unit.mocks import make_scenario_result
@@ -57,19 +56,23 @@ def _make_initializer(**overrides) -> RegisteredInitializer:
 
 
 def _make_target(**overrides) -> TargetInstance:
+    """Build a ``TargetInstance``; identity kwargs (``target_type``/``endpoint``/
+    ``model_name``/...) are folded into the embedded ``TargetIdentifier``."""
+    if "target_type" in overrides:
+        overrides["class_name"] = overrides.pop("target_type")
+    identifier_kwargs = {
+        "class_name": overrides.pop("class_name", "X"),
+        "class_module": overrides.pop("class_module", "pyrit.prompt_target"),
+    }
+    for key in ("endpoint", "model_name", "underlying_model_name", "temperature", "top_p", "max_requests_per_minute"):
+        if key in overrides:
+            identifier_kwargs[key] = overrides.pop(key)
     defaults = {
         "target_registry_name": "t1",
-        "target_type": "X",
-        "endpoint": None,
-        "model_name": None,
-        "underlying_model_name": None,
-        "temperature": None,
-        "top_p": None,
-        "max_requests_per_minute": None,
-        "capabilities": TargetCapabilitiesInfo(),
+        "identifier": TargetIdentifier(**identifier_kwargs),
+        "capabilities": TargetCapabilities(),
         "target_specific_params": None,
         "inner_targets": None,
-        "identifier_hash": None,
     }
     defaults.update(overrides)
     return TargetInstance(**defaults)
diff --git a/tests/unit/cli/test_pyrit_scan.py b/tests/unit/cli/test_pyrit_scan.py
index 7ec86a0814..3f987b44e8 100644
--- a/tests/unit/cli/test_pyrit_scan.py
+++ b/tests/unit/cli/test_pyrit_scan.py
@@ -214,11 +214,10 @@ def _mock_api_client():
     """Create a mock PyRITApiClient with default response behaviors (typed wire-data)."""
     from datetime import datetime, timezone
 
-    from pyrit.models import ScenarioRunState
+    from pyrit.models import ScenarioRunState, TargetCapabilities
     from pyrit.models.catalog import (
         RegisteredScenario,
         ScenarioRunSummary,
-        TargetCapabilitiesInfo,
         TargetInstance,
     )
 
@@ -272,7 +271,7 @@ def _mock_api_client():
     client.__aenter__ = AsyncMock(return_value=client)
     client.__aexit__ = AsyncMock(return_value=None)
     # Marker so tests that re-shape the mock can find the unused TargetInstance helper.
-    _ = (TargetCapabilitiesInfo, TargetInstance)
+    _ = (TargetCapabilities, TargetInstance)
     return client
 
 
diff --git a/tests/unit/prompt_target/target/test_azure_ml_chat_target.py b/tests/unit/prompt_target/target/test_azure_ml_chat_target.py
index a219a8fab5..1b48070264 100644
--- a/tests/unit/prompt_target/target/test_azure_ml_chat_target.py
+++ b/tests/unit/prompt_target/target/test_azure_ml_chat_target.py
@@ -54,6 +54,35 @@ def test_initialization_with_no_api_raises():
         AzureMLChatTarget(api_key="xxxxx")
 
 
+def test_no_key_recognized_aml_endpoint_auto_mints_entra(patch_central_database):
+    """With no key and a recognized *.inference.ml.azure.com endpoint, the target
+    auto-mints an Entra token provider for the AML scope."""
+
+    async def _provider() -> str:
+        return "aml-entra-token"
+
+    with (
+        patch.dict(os.environ, {AzureMLChatTarget.api_key_environment_variable: ""}),
+        patch(
+            "pyrit.prompt_target.azure_ml_chat_target.get_azure_async_token_provider",
+            return_value=_provider,
+        ) as mock_provider,
+    ):
+        target = AzureMLChatTarget(endpoint="https://my-aml.region.inference.ml.azure.com/score")
+
+    mock_provider.assert_called_once_with(AzureMLChatTarget._AZURE_ML_SCOPE)
+    assert target._api_key_provider is _provider
+    assert target._api_key == ""
+
+
+def test_no_key_non_aml_endpoint_raises(patch_central_database):
+    """With no key and an endpoint that is not a recognized AML host, the target
+    refuses to mint a bearer token."""
+    with patch.dict(os.environ, {AzureMLChatTarget.api_key_environment_variable: ""}):
+        with pytest.raises(ValueError, match="recognized Azure ML"):
+            AzureMLChatTarget(endpoint="https://example.com/score")
+
+
 async def test_complete_chat_async(aml_online_chat: AzureMLChatTarget):
     messages = [
         Message(message_pieces=[MessagePiece(role="user", conversation_id="123", original_value="user content")]),
diff --git a/tests/unit/prompt_target/target/test_openai_chat_target.py b/tests/unit/prompt_target/target/test_openai_chat_target.py
index 452decb0ac..dbf1018a1b 100644
--- a/tests/unit/prompt_target/target/test_openai_chat_target.py
+++ b/tests/unit/prompt_target/target/test_openai_chat_target.py
@@ -729,6 +729,44 @@ def test_set_auth_with_api_key(patch_central_database):
     assert target._api_key == "test_api_key_456"
 
 
+def test_no_key_recognized_azure_endpoint_auto_mints_entra(patch_central_database):
+    """With no key and a recognized Azure OpenAI endpoint, the target auto-mints
+    an Entra token provider for that endpoint."""
+
+    async def _provider() -> str:
+        return "aoai-entra-token"
+
+    with (
+        patch.dict(os.environ, {}, clear=True),
+        patch(
+            "pyrit.prompt_target.openai.openai_target.get_azure_openai_auth",
+            return_value=_provider,
+        ) as mock_get_auth,
+    ):
+        target = OpenAIChatTarget(
+            model_name="gpt-4",
+            endpoint="https://test.openai.azure.com/",
+        )
+
+    mock_get_auth.assert_called_once_with("https://test.openai.azure.com/")
+    assert target._api_key is _provider
+
+
+def test_no_key_non_azure_endpoint_raises(patch_central_database):
+    """With no key and a non-Azure endpoint, the target refuses to mint a token."""
+    with patch.dict(os.environ, {}, clear=True):
+        with pytest.raises(ValueError, match="non-Azure endpoints"):
+            OpenAIChatTarget(model_name="gpt-4", endpoint="https://api.openai.com/")
+
+
+def test_no_key_substring_lookalike_endpoint_raises(patch_central_database):
+    """A hostname merely containing 'azure' (but not a recognized suffix) must not
+    trigger auto-Entra minting (loose->strict hardening)."""
+    with patch.dict(os.environ, {}, clear=True):
+        with pytest.raises(ValueError, match="non-Azure endpoints"):
+            OpenAIChatTarget(model_name="gpt-4", endpoint="https://evil-azure.example.com/")
+
+
 def test_url_validation_no_warning_for_custom_endpoint(caplog, patch_central_database):
     """Test that URL validation doesn't warn for custom endpoint paths."""
     with patch.dict(os.environ, {}, clear=True), caplog.at_level(logging.WARNING):
diff --git a/tests/unit/prompt_target/target/test_prompt_shield_target.py b/tests/unit/prompt_target/target/test_prompt_shield_target.py
index 05003dac32..64c7c80d8d 100644
--- a/tests/unit/prompt_target/target/test_prompt_shield_target.py
+++ b/tests/unit/prompt_target/target/test_prompt_shield_target.py
@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT license.
 
+import os
 from collections.abc import MutableSequence
 from unittest.mock import MagicMock, patch
 
@@ -129,17 +130,36 @@ def test_add_auth_header_with_string_api_key():
 
 
 def test_init_raises_when_endpoint_none():
-    """Guard at line 98: endpoint_value is None raises ValueError."""
+    """A missing endpoint raises ValueError."""
     with patch("pyrit.prompt_target.prompt_shield_target.default_values") as mock_dv:
         mock_dv.get_required_value = MagicMock(return_value=None)
         with pytest.raises(ValueError, match="Endpoint value is required"):
             PromptShieldTarget(endpoint=None, api_key="test_key")
 
 
-def test_init_raises_when_api_key_none(sqlite_instance):
-    """Guard at line 113: _api_key_value is None raises ValueError."""
-    with patch("pyrit.prompt_target.prompt_shield_target.default_values") as mock_dv:
-        # First call for endpoint returns valid, second call for api_key returns None
-        mock_dv.get_required_value = MagicMock(side_effect=["https://test.endpoint.com", None])
-        with pytest.raises(ValueError, match="API key is required"):
-            PromptShieldTarget(endpoint=None, api_key=None)
+def test_init_raises_when_no_api_key_and_non_azure_endpoint(sqlite_instance):
+    """No key + a non-Azure endpoint raises (identity auth only works for Azure endpoints)."""
+    with patch.dict(os.environ, {}, clear=False):
+        os.environ.pop("AZURE_CONTENT_SAFETY_API_KEY", None)
+        with pytest.raises(ValueError, match="API key is required for non-Azure"):
+            PromptShieldTarget(endpoint="https://test.endpoint.com", api_key=None)
+
+
+def test_init_uses_identity_token_provider_for_azure_endpoint(sqlite_instance):
+    """No key + a recognized Azure Content Safety endpoint falls back to an Entra ID token provider."""
+    token_provider = MagicMock(return_value="minted-token")
+    with patch.dict(os.environ, {}, clear=False):
+        os.environ.pop("AZURE_CONTENT_SAFETY_API_KEY", None)
+        with patch(
+            "pyrit.prompt_target.prompt_shield_target.get_azure_token_provider",
+            return_value=token_provider,
+        ) as mock_provider:
+            target = PromptShieldTarget(endpoint="https://myresource.cognitiveservices.azure.com", api_key=None)
+
+    mock_provider.assert_called_once_with("https://cognitiveservices.azure.com/.default")
+    assert target._api_key is token_provider
+
+
+def test_supported_auth_modes_includes_identity():
+    """Prompt Shield advertises identity-based auth alongside api_key."""
+    assert PromptShieldTarget.supported_auth_modes == ("api_key", "identity")
diff --git a/tests/unit/prompt_target/target/test_prompt_target_azure_blob_storage.py b/tests/unit/prompt_target/target/test_prompt_target_azure_blob_storage.py
index eb31ef7f2e..d0ab2b4ec9 100644
--- a/tests/unit/prompt_target/target/test_prompt_target_azure_blob_storage.py
+++ b/tests/unit/prompt_target/target/test_prompt_target_azure_blob_storage.py
@@ -34,6 +34,11 @@ def test_initialization_with_required_parameters(azure_blob_storage_target: Azur
     assert azure_blob_storage_target._sas_token == "valid_sas_token"
 
 
+def test_supported_auth_modes_includes_identity():
+    """Blob advertises identity-based auth (DefaultAzureCredential) alongside api_key."""
+    assert AzureBlobStorageTarget.supported_auth_modes == ("api_key", "identity")
+
+
 def test_initialization_with_required_parameters_from_env():
     os.environ[AzureBlobStorageTarget.AZURE_STORAGE_CONTAINER_ENVIRONMENT_VARIABLE] = (
         "https://test.blob.core.windows.net/test"
diff --git a/tests/unit/prompt_target/test_round_robin_target.py b/tests/unit/prompt_target/test_round_robin_target.py
index bb2bf55bf7..ade87f676c 100644
--- a/tests/unit/prompt_target/test_round_robin_target.py
+++ b/tests/unit/prompt_target/test_round_robin_target.py
@@ -30,6 +30,13 @@ def test_init_rejects_nested_round_robin():
         RoundRobinTarget(targets=[rr, rr])
 
 
+@pytest.mark.usefixtures("patch_central_database")
+def test_init_rejects_duplicate_instance():
+    t1 = MockPromptTarget()
+    with pytest.raises(ValueError, match="same target instance more than once"):
+        RoundRobinTarget(targets=[t1, t1])
+
+
 @pytest.mark.usefixtures("patch_central_database")
 def test_init_rejects_mixed_classes():
     from pyrit.prompt_target import TextTarget
diff --git a/tests/unit/registry/test_target_registry.py b/tests/unit/registry/test_target_registry.py
index 575c17dea1..e77e0d53bb 100644
--- a/tests/unit/registry/test_target_registry.py
+++ b/tests/unit/registry/test_target_registry.py
@@ -299,6 +299,17 @@ def test_round_robin_targets_param_is_reference(self, registry: TargetRegistry):
         meta = self._metadata_for(registry, "RoundRobinTarget")
         assert any(p.is_reference_to(ComponentType.TARGET) for p in meta.parameters)
 
+    def test_metadata_supported_auth_modes_projects_class_attribute(self, registry: TargetRegistry):
+        # Identity-capable targets expose both modes; api-key-only targets expose one.
+        assert self._metadata_for(registry, "OpenAIChatTarget").supported_auth_modes == ("api_key", "identity")
+        assert self._metadata_for(registry, "TextTarget").supported_auth_modes == ("api_key",)
+
+    def test_metadata_supported_auth_modes_sourced_from_class_attributes(self, registry: TargetRegistry):
+        # Auth modes are read off the class via Param.ClassAttr, not a fabricated instance.
+        meta = self._metadata_for(registry, "OpenAIChatTarget")
+        assert "supported_auth_modes" in meta.class_attributes
+        assert meta.class_attributes["supported_auth_modes"] == ("api_key", "identity")
+
 
 class TestRegistrationGate:
     """The identifier blueprint must line up with a resolvable contract for every target."""