BlazorMentor 0.1.0-preview.1

BlazorMentor

Preview Release — BlazorMentor is currently in public preview. APIs may change before the stable release.

BlazorMentor is a .NET library that embeds a fully functional AI assistant directly into any Blazor application — with a floating chat widget, multi-agent orchestration, contextual memory, and voice support — all configured via a single AddBlazorMentor() call.

Built on top of Microsoft Agent Framework (Microsoft.Agents.AI), BlazorMentor abstracts the complexity of multi-agent systems into a clean, attribute-driven programming model designed specifically for Blazor developers.

---

Table of Contents

• What is BlazorMentor?
• What can it do?
• Architecture overview
• Getting started
  • Installation
  • Minimal setup
  • Add the widget to your layout
• AI providers
• The three-level agent model
  • Level 1 — Actions on a service
  • Level 2 — Specialized agent with Handoff
  • Level 3 — Collaborative team (Group Chat)
• Page navigation
• Page context and UI actions
• Contextual memory
• Persistent conversation history
• Blazor Server vs Blazor WASM — service lifetime
• Built-in AI tools
• Streaming responses
• Session serialize and restore
• Security
• Widget customization
• All configuration options
• Extensibility
• Requirements

---

What is BlazorMentor?

BlazorMentor turns any Blazor application into an AI-assisted experience. It provides:

• A floating chat widget rendered automatically in the UI (no manual HTML needed).
• A Main Coordinator agent that understands the application context and routes requests.
• An attribute-driven discovery system that scans your assemblies and turns plain C# methods and classes into AI tools and agents — zero boilerplate.
• Full integration with Microsoft Agent Framework, supporting Handoff Workflows, Group Chat teams, and any AI provider compatible with the IChatClient abstraction.

The developer defines what the AI can do using attributes. BlazorMentor handles everything else: prompt building, agent wiring, session management, rate limiting, safety checks, memory, and UI.

Before every LLM call, BlazorMentor automatically enriches the system prompt with real-time context: the current URL, the active page name, the authenticated user and their roles, the data registered by the current page via IMentorPageContext, the available UI actions, and the user's contextual memory — so the AI always knows exactly where it is and what it can do.

---

What can it do?

Feature	Description
🤖 Multi-agent orchestration	Coordinator + specialized agents connected via Handoff Workflow
👥 Group Chat teams	Multiple agents collaborate in a structured conversation before executing
🛠️ Tool discovery	C# methods become AI tools via [Description] or [MentorAction]
🧠 Contextual memory	Remembers user preferences and actions across sessions
🗺️ Page navigation	AI navigates to any page decorated with [MentorPage]
💬 Session management	Conversation history managed by Agent Framework (AgentSession)
💾 Persistent history	Pluggable ChatHistoryProvider (CosmosDB, Redis, custom)
🎨 Customizable widget	Themes, colors, position, avatar, bot name
🌐 Multi-language	Configurable language for AI responses and the widget UI
🎤 Voice input/output	Browser-native Speech Recognition and Speech Synthesis
🔒 Safety check	Optional AI-based prompt injection and jailbreak detection
⏱️ Rate limiting	Per-user message limit with configurable time window
✅ Confirmation dialogs	Destructive actions ask for user confirmation before execution
🔐 Role-based actions	Actions restricted by ASP.NET Core identity roles
📦 Pluggable memory store	Default in-memory, replaceable with Redis/EF Core/MongoDB
🔌 Any AI provider	Azure OpenAI, OpenAI, Ollama, Azure AI Foundry, Anthropic, and more

---

Architecture overview

┌─────────────────────────────────────────────────────┐
│                  Blazor Application                 │
│                                                     │
│   ┌──────────────┐      ┌────────────────────────┐  │
│   │  ChatWidget  │◄────►│   MentorOrchestrator   │  │
│   │  (Razor UI)  │      │   (Main Coordinator)   │  │
│   └──────────────┘      └────────┬───────────────┘  │
│                                  │  Handoff / GroupChat │
│              ┌───────────────────┼───────────────┐   │
│              ▼                   ▼               ▼   │
│        [MentorAgent]       [MentorAgent]   [MentorTeam]│
│        OrderAgent          CustomerAgent  AnalysisTeam │
│        (L2 Handoff)        (L2 Handoff)   (L3 GroupChat)│
│              │                   │               │   │
│        [Description]       [MentorAction]  [TeamMember]│
│        C# methods          C# methods      sub-agents  │
└─────────────────────────────────────────────────────┘
						│
			  Microsoft Agent Framework
			  (ChatClientAgent, HandoffWorkflow,
			   GroupChatWorkflow, AgentSession)

The MentorOrchestrator builds and drives a HandoffWorkflow (or GroupChatWorkflow for teams). The Main Coordinator receives every message, understands context (current page, user, app description, memory), and decides which agent — or team — should handle the request.

---

Getting started

Installation

dotnet add package BlazorMentor --prerelease

Minimal setup

In Program.cs:

using BlazorMentor.Extensions;

builder.Services.AddBlazorMentor(options =>
{
	options.AppName        = "My App";
	options.AppDescription = "An order management application";
	options.Language       = MentorLanguage.Italian;

	// Choose your AI provider (see "AI providers" section below)
	options.ChatClient = new AzureOpenAIClient(
			new Uri("https://myresource.openai.azure.com"),
			new AzureKeyCredential(builder.Configuration["AzureOpenAI:Key"]!))
		.GetChatClient("gpt-4o-mini")
		.AsIChatClient();

	// Assemblies to scan for agents, actions, and pages
	options.ScanAssemblies = [typeof(Program).Assembly];
});

Add the widget to your layout

In MainLayout.razor (or App.razor):

@using BlazorMentor.Components

<ChatWidget />

That's it. The widget injects its own CSS and JS automatically — no changes to App.razor or _Host.cshtml are required.

---

AI providers

BlazorMentor supports any provider via two entry points: IChatClient (recommended for most cases) or AIAgent (required for providers that don't expose IChatClient).

// ── Azure OpenAI — Chat Completions
options.ChatClient = new AzureOpenAIClient(endpoint, credential)
	.GetChatClient("gpt-4o-mini").AsIChatClient();

// ── Azure OpenAI — Responses API (service-managed history)
options.ChatClient = new AzureOpenAIClient(endpoint, credential)
	.GetResponsesClient("gpt-4o-mini").AsIChatClient();

// ── OpenAI direct
options.ChatClient = new OpenAIClient("sk-...")
	.GetChatClient("gpt-4o").AsIChatClient();

// ── Ollama (local)
options.ChatClient = new OllamaChatClient(new Uri("http://localhost:11434"), "llama3.2");

// ── Azure AI Foundry (AIProjectClient) — requires AIAgent
options.Agent = new AIProjectClient(endpoint, credential)
	.AsAIAgent(model: "gpt-4o-mini", instructions: "You are a helpful assistant.");

// ── Anthropic Claude — requires AIAgent
options.Agent = new AnthropicClient() { APIKey = apiKey }
	.AsAIAgent(model: "claude-haiku-4-5", instructions: "...");

⚠️ Set either ChatClient or Agent, not both.

Path A vs Path B — feature matrix

Feature	ChatClient (Path A)	AIAgent (Path B)
L1 actions	✅	✅
L2 Handoff agents	✅	❌ requires IChatClient
L3 Group Chat teams	✅	❌ requires IChatClient
Safety check	✅	❌ skipped automatically
Session history reduction	✅ configurable	✅ configured in the agent
Custom ChatHistoryProvider	✅ via options	⚠️ must be set in the pre-built agent

When using AIAgent (Path B), ChatHistoryProvider cannot be added after construction — configure it directly in the agent you pass to options.Agent.

---

The three-level agent model

BlazorMentor organizes AI capabilities in three progressive levels of complexity.

Level 1 — Actions on a service

The simplest level. Decorate C# methods with [Description] (standard .NET, zero dependencies) or [MentorAction] (adds confirmation, roles, navigation, hints).

// Register the service in DI as usual
builder.Services.AddScoped<OrderService>();

public class OrderService
{
	// Simple — [Description] from System.ComponentModel, zero dependencies
	[Description("Returns the list of active orders")]
	public async Task<List<Order>> GetActiveOrdersAsync() { ... }

	// Advanced — full [MentorAction] with all parameters
	[MentorAction(
		Description          = "Cancels an existing order",
		Category             = "Orders",             // groups actions in proactive suggestions
		RequiresConfirmation = true,                 // shows confirmation banner before executing
		RequiredRoles        = ["Manager"],          // only users with this role can trigger it
		ProactiveHint        = "Suggest checking active orders first", // hint injected into AI prompt
		NavigateTo           = "/orders")]           // AI navigates here automatically after success
	public async Task<bool> CancelOrderAsync(int orderId, string reason) { ... }
}

BlazorMentor discovers the service via ScanAssemblies and exposes its methods as AI tools automatically. The AI calls the right method based on the user's natural language request.

[MentorAction] parameters summary:

Parameter	Description
Description	Natural language description used as the AI tool description
Category	Groups actions in proactive suggestion chips
RequiresConfirmation	Shows a confirmation banner before executing. Use for destructive or irreversible operations
RequiredRoles	ASP.NET Core identity roles required to invoke the action. Empty = accessible to all
ProactiveHint	Hint injected into the AI prompt to guide proactive behaviour
NavigateTo	URL the AI navigates to automatically after successful execution

---

Level 2 — Specialized agent with Handoff

Decorate a class with [MentorAgent] to create a dedicated AI agent connected to the Main Coordinator via a Handoff Workflow. The coordinator hands off the conversation to the right agent based on the request.

[MentorAgent(
	Name        = "OrderAgent",
	Description = "Handles everything related to orders: creation, tracking, cancellation",
	HandoffTo   = ["CustomerAgent", "InvoiceAgent"]  // can hand off further
)]
public class OrderAgent : IMentorAgent
{
	private readonly OrderService _orders;
	public OrderAgent(OrderService orders) => _orders = orders;

	[Description("Creates a new order for a customer")]
	public async Task<Order> CreateOrderAsync(int customerId, List<string> products) { ... }

	[Description("Retrieves the status of an order")]
	public async Task<OrderStatus> GetOrderStatusAsync(int orderId) { ... }
}

Register the agent in DI:

builder.Services.AddScoped<OrderAgent>();

BlazorMentor builds a ChatClientAgent from the class, wires it into the Handoff graph, and generates the system prompt from Name and Description (or you can supply a custom Instructions).

Implementing IMentorAgent is optional but recommended — it gives compile-time safety, enables injecting the agent in tests, and ensures the DI container validates its registration.

⚠️ Important: agent names in HandoffTo must match exactly the Name in the target [MentorAgent] attribute (case-insensitive). A mismatch produces a warning in the logs at startup and silently skips that handoff edge.

---

Level 3 — Collaborative team (Group Chat)

Use [MentorTeam] to define a Group Chat where multiple AI agents collaborate — debating, analyzing, and approving — before a result is returned to the user or handed off to an L2 agent for execution.

[MentorTeam(
	Name          = "BusinessAnalysisTeam",
	Description   = "Analyzes business data and produces an approved action plan",
	MaxIterations = 8,                                      // forced termination after 8 turns
	TriggerOn     = ["analysis", "business plan", "budget"], // keywords that activate this team
	HandoffTo     = ["OrderAgent", "CustomerAgent"])]
public class BusinessAnalysisTeam : IMentorTeam            // IMentorTeam is optional, recommended
{
	[TeamMember(
		Role         = "DataAnalyst",
		Tools        = [typeof(ReportTools), typeof(OrderTools)],
		Instructions = "Analyze the data and propose solutions with numbers.")]
	public object? Analyst { get; set; }

	[TeamMember(
		Role         = "BusinessApprover",
		Instructions = "Review the analyst's proposal. Reply APPROVED or REJECTED with reasons.")]
	public object? Approver { get; set; }

	[TeamTerminationCondition]
	public bool ShouldTerminate(string lastMessage, string lastSpeaker)
		=> lastSpeaker == "BusinessApprover" &&
		   (lastMessage.Contains("APPROVED") || lastMessage.Contains("REJECTED"));
}

BlazorMentor builds a GroupChatWorkflow from this declaration and connects it to the main Handoff graph.

• [TeamTerminationCondition] is required when you need custom exit logic. Without it, the team runs for MaxIterations turns with round-robin turn-taking and stops automatically.
• TriggerOn keywords are injected into the Coordinator's prompt to help it decide when to activate the team — they are hints, not hard rules.
• [TeamMember] tools should be read-only (queries, reports). Write operations should be delegated to L2 agents via HandoffTo.
• Implementing IMentorTeam is optional but recommended for the same reasons as IMentorAgent.

---

Page navigation

Decorate Blazor pages with [MentorPage] to let the AI navigate to them on user request.

@* Simple page — navigation only *@
@attribute [MentorPage("/orders", "Orders")]

@* Page with UI actions — waits for SignalReady() after navigation *@
@attribute [MentorPage("/orders-interactive", "Interactive Orders",
	HasUIActions = true,
	ReadyTimeout = 3000,
	Description  = "Order management with inline editing and filtering")]

Pages are discovered at startup from ScanAssemblies — they don't need to be visited first. When HasUIActions = true, the AI waits for the page to call PageContext.SignalReady() before executing UI actions, ensuring the component is fully mounted.

---

Page context and UI actions

IMentorPageContext is a scoped service injectable in any Blazor page. It has two responsibilities:

1. Share visible data — key/value pairs serialized live into the AI system prompt before every call (filter state, selected item, visible row count, etc.).
2. Register UI actions — C# lambdas the AI can invoke directly on the current page without going through a business service (highlight a row, open a modal, pre-fill a form).

@inject IMentorPageContext PageContext
@implements IDisposable

protected override void OnInitialized()
{
	PageContext
		.SetPageName("Orders")
		// Share current UI state with the AI
		.Set("ActiveFilter",   "Pending")
		.Set("VisibleRows",    _orders.Count)
		.Set("SelectedOrder",  _selectedOrder)
		// Register actions the AI can invoke directly on the UI
		.RegisterUIAction(
			"highlight_row",
			"Highlights an order row by its ID",
			id => HighlightRow((int)(long)id!))
		.RegisterUIAction(
			"open_create_modal",
			"Opens the new order creation dialog",
			_ => OpenCreateModal())
		.RegisterUIAction(
			"prefill_form",
			"Pre-fills the order form with the provided data",
			data => {
				_form = JsonSerializer.Deserialize<OrderModel>(data!.ToString()!);
				StateHasChanged();
			});

	// Signal the AI that the page is ready (required when HasUIActions = true)
	PageContext.SignalReady();
}

// Always clear in Dispose to remove context and actions from the AI's view
public void Dispose() => PageContext.Clear();

The AI automatically receives the full page context (current URL, page name, registered data, and available UI actions) injected into its system prompt on every call — with no extra configuration required.

---

Contextual memory

Enable the Mentor's ability to remember preferences and past actions across sessions:

options.UseMemoryContext  = true;
options.MemoryContextCount = 10; // last N memories injected into the system prompt

By default, memories are stored in RAM (InMemoryMentorMemoryStore). For real persistence, register your own store before AddBlazorMentor():

// Redis
builder.Services.AddSingleton<IMentorMemoryStore, RedisMemoryStore>();

// EF Core
builder.Services.AddScoped<IMentorMemoryStore, EfCoreMemoryStore>();

// MongoDB
builder.Services.AddSingleton<IMentorMemoryStore, MongoMemoryStore>();

builder.Services.AddBlazorMentor(options => {
	options.UseMemoryContext = true;
	...
});

⚠️ User isolation: With authentication configured, each user has their own memory (keyed by ClaimTypes.NameIdentifier). Without authentication, all users share the "anonymous" key — suitable only for single-user apps or development.

How automatic memory works

When UseMemoryContext = true, the Coordinator's system prompt includes explicit instructions to call the remember tool immediately and silently whenever the user reveals a preference, name, role, or goal — without asking for confirmation. The developer does not need to do anything: the AI handles it automatically.

Examples of what the AI saves automatically:

User says	AI saves
"My name is Antonio"	remember("user_name", "Antonio")
"I work in the sales team"	remember("user_role", "sales team")
"Always show me Pending orders first"	remember("preference_filter", "Pending")

At the start of each session, memories are injected into the prompt so the AI can greet the user by name or honour their preferences immediately.

InMemoryMentorMemoryStore — production limitations

The default store has two hard limitations:

• Data is lost on app restart — memories do not survive deployments.
• Does not scale across multiple instances — in a load-balanced environment each server has its own isolated dictionary.

For any production deployment with more than one server instance, or where persistence across restarts is required, register a custom IMentorMemoryStore implementation.

---

Blazor Server vs Blazor WASM — service lifetime

BlazorMentor registers its core services as Scoped, which behaves differently depending on the hosting model:

Service	Blazor Server	Blazor WASM
MentorOrchestrator	One per circuit (user connection)	One per browser tab
IMentorSessionManager	One per circuit	One per browser tab
IMentorPageContext	One per circuit	One per browser tab
MentorMemoryService	One per circuit	One per browser tab
IMentorMemoryStore	Singleton (shared)	Singleton (shared)
MentorDiscoveryService	Singleton (shared)	Singleton (shared)
MentorRateLimiter	Singleton (shared)	Singleton (shared)

In Blazor Server, each user has a completely isolated session — there is no shared state between users for scoped services. The rate limiter and discovery service are shared across all users, as expected.

In Blazor WASM, all services live in the browser tab — sessions are naturally isolated between tabs.

---

Persistent conversation history

By default, conversation history lives in memory and is lost on app restart.

// CosmosDB
options.ChatHistoryProvider = new CosmosChatHistoryProvider(cosmosClient, "my-db", "conversations");

// Custom (implement ChatHistoryProvider from Microsoft Agent Framework)
options.ChatHistoryProvider = new MyRedisChatHistoryProvider(redisConnection);

See the Agent Framework documentation for available providers.

---

Built-in AI tools

BlazorMentor automatically adds four internal tools to the Coordinator. The developer does not declare or register them — they are always available.

Tool	When it is used	Notes
navigate_to	User asks to go to a page, or an agent needs to navigate before executing UI actions	Discovers pages from [MentorPage] at startup; waits for SignalReady() if HasUIActions = true
invoke_ui_action	AI invokes an action registered via PageContext.RegisterUIAction()	Passes an optional JsonElement parameter to the handler
remember	AI decides to save a preference or fact for the user	Only active when UseMemoryContext = true
forget_all	User explicitly asks to reset their memory	Only active when UseMemoryContext = true

---

Streaming responses

All AI responses are streamed token by token — no waiting for the full response. This is handled automatically by the Orchestrator via RunStreamingAsync. The developer does not need to configure anything.

Response chunks flow through IMentorStateService.OnStreamingChunk → ChatWidget → UI thread-safe update via InvokeAsync(StateHasChanged). When voice output is enabled, the full response is read aloud after streaming completes.

---

Session serialize and restore

IMentorSessionManager exposes two methods for saving and resuming the conversation state (e.g. across page reloads or server restarts):

@inject IMentorSessionManager SessionManager

// Serialize the current session to a JsonElement (e.g. save to localStorage or DB)
JsonElement? snapshot = await SessionManager.SerializeCurrentSessionAsync(agent);

// Restore a previously saved session
if (snapshot.HasValue)
    await SessionManager.RestoreSessionAsync(agent, snapshot.Value);

The widget's reset button (inside the chat header) calls ResetSessionAsync() and clears the message list — starting a brand new conversation.

---

Security

Input safety check

options.EnableSafetyCheck = true; // adds ~200-500ms per message

Before processing each message, the AI evaluates whether it is a prompt injection, jailbreak attempt, or sensitive data extraction. Works in any language automatically.

Rate limiting

options.RateLimitPerUser    = 20;  // max 20 messages...
options.RateLimitWindowSecs = 60;  // ...per minute, per user

Role-based actions

[MentorAction(Description = "Approves a budget request", RequiredRoles = ["Finance", "Admin"])]
public async Task<bool> ApproveBudgetAsync(int requestId) { ... }

Roles are verified against the current user's ClaimTypes.Role claim via AuthenticationStateProvider.

Confirmation dialogs

[MentorAction(Description = "Deletes all orders for a customer", RequiresConfirmation = true)]
public async Task<bool> DeleteAllOrdersAsync(int customerId) { ... }

The widget shows a confirmation banner before executing the action. Disable globally with options.RequireConfirmation = false.

---

Widget customization

Themes

Value	Description
MentorTheme.Default	Light with blue accents (--mentor-primary: #2563EB). Suits most apps.
MentorTheme.Dark	Dark background (#1E1E2E). Auto-adapts to dark-mode apps.
MentorTheme.Minimal	No shadows, thin borders. Ideal for flat/clean designs.
MentorTheme.Custom	No theme applied at all. You define every CSS variable manually in your own stylesheet — full control.

When using MentorTheme.Custom, override these CSS variables in your stylesheet:

:root {
    --bm-bg-base:       #ffffff;
    --bm-bg-panel:      rgba(255,255,255,0.97);
    --bm-bg-surface:    #f8fafc;
    --bm-bg-elevated:   #f1f5f9;
    --bm-bg-hover:      #e2e8f0;
    --bm-text-primary:  #0f172a;
    --bm-text-secondary:#475569;
    --bm-text-muted:    #94a3b8;
    --bm-accent:        #2563EB;   /* primary accent color */
    --bm-accent-dark:   #1d4ed8;
    --bm-accent-glow:   rgba(37,99,235,.35);
    --bm-border:        rgba(0,0,0,.1);
    --bm-border-accent: rgba(37,99,235,.3);
    --bm-shadow-panel:  0 8px 40px rgba(0,0,0,.15);
    --bm-shadow-fab:    0 8px 32px rgba(37,99,235,.4);
}

Mentorship level

Controls the AI's verbosity and proactivity:

Value	Behaviour
MentorshipLevel.Minimal	Executes silently. No unsolicited explanations or suggestions. Best for expert users.
MentorshipLevel.Standard	Balanced. Full responses with contextual suggestions when relevant. (default)
MentorshipLevel.Proactive	Guides the user: explains what it did and why, suggests next steps, warns of risks, proposes alternatives. Best for onboarding or less-experienced users.

Full example

options.Theme              = MentorTheme.Dark;
options.Position           = ChatPosition.BottomRight; // BottomLeft, TopRight, TopLeft, SideRight, SideLeft
options.PrimaryColor       = "#2563EB";                // overrides theme accent color
options.BotName            = "Aria";
options.AvatarUrl          = "/images/aria-avatar.png";
options.WelcomeMessage     = "Hi! I'm Aria, your assistant. How can I help?";
options.InputPlaceholder   = "Ask me anything...";
options.MentorshipLevel    = MentorshipLevel.Proactive;
options.EnableSuggestions   = true;   // proactive suggestion chips below the input
options.EnableActionFeedback = true;  // "Executing..." visual feedback during tool calls
options.EnableVoiceInput    = true;   // microphone — Chrome/Edge only, requires HTTPS in production
options.EnableVoiceOutput   = true;   // text-to-speech — all modern browsers

Built-in widget features (always active, no configuration needed)

Feature	Description
Unread badge	When the widget is closed and the AI responds, a numeric badge appears on the FAB button (capped at 9+)
Typing indicator	Animated dots shown while the AI is processing and no streaming text has arrived yet
Action bar	While a tool is executing, a pulsing bar shows the tool display name
Reset button	Button in the widget header that clears the message list and starts a new AgentSession
Voice toggle	When EnableVoiceOutput = true and the browser supports Speech Synthesis, a speaker toggle button appears in the header

---

All configuration options

Property	Type	Default	Description
AppName	string	(required)	Application name injected into the system prompt
AppDescription	string	""	Domain description for richer AI context
Language	MentorLanguage	English	Language for AI responses and widget UI
MentorshipLevel	MentorshipLevel	Standard	Proactivity level of the AI
ChatClient	IChatClient?	null	AI provider via IChatClient (Azure OpenAI, OpenAI, Ollama…)
Agent	AIAgent?	null	Pre-built AIAgent (Foundry, Anthropic…)
ScanAssemblies	Assembly[]	(required)	Assemblies to scan for agents, actions, and pages
Theme	MentorTheme	Default	Widget visual theme
Position	ChatPosition	BottomRight	Widget position
PrimaryColor	string?	null	Custom hex color
BotName	string	"Mentor AI"	Bot name in widget header
AvatarUrl	string?	null	Bot avatar image URL
WelcomeMessage	string?	null	Initial welcome message
InputPlaceholder	string	"Type a message..."	Input box placeholder
EnableSuggestions	bool	true	Proactive suggestion chips
EnableActionFeedback	bool	true	Visual feedback during tool calls
UseMemoryContext	bool	false	Contextual memory across sessions
MemoryContextCount	int	10	Number of recent memories in the prompt
MaxSessionMessages	int	50	Max messages in session history
ChatHistoryProvider	ChatHistoryProvider?	null	Persistent conversation history provider
EnableSafetyCheck	bool	false	AI-based prompt injection detection
MaxMessageLength	int	4000	Max message length in characters (0 = unlimited)
RateLimitPerUser	int	0	Max messages per user per window (0 = disabled)
RateLimitWindowSecs	int	60	Rate limiting window in seconds
RequireConfirmation	bool	true	Global on/off for confirmation dialogs
EnableVoiceInput	bool	false	Microphone via browser Speech Recognition API
EnableVoiceOutput	bool	false	Text-to-speech via browser Speech Synthesis API
IncludeWorkflowExceptionDetails	bool	false	When true, exception stack traces from L2/L3 workflow agents are included in the agent's response text. Never enable in production — exposes internal implementation details to users

---

Extensibility

Extension point	How
Custom memory store	Implement IMentorMemoryStore, register before AddBlazorMentor()
Custom history provider	Set options.ChatHistoryProvider
Custom AI provider	Set options.ChatClient or options.Agent
Custom agent instructions	Set Instructions on [MentorAgent] or [TeamMember]

---

Requirements

Requirement	Version
.NET	10.0
Blazor	Server, WebAssembly, or Hybrid (MAUI)
Microsoft.Agents.AI	1.6.1
Microsoft.Agents.AI.Workflows	1.6.1
Microsoft.Extensions.AI	10.6.0

---

License

MIT — see LICENSE for details.