Client identity metadata for shared WebUI and mobile app setups

[promptclickrun]

I’d like to propose first-class support for passing client or user identity from mobile/WebUI clients into the WebUI backend and agent context.

The problem

A single WebUI server can be shared by multiple people or devices, but the agent has no reliable way to know who is sending a message.

Example setup:

• Person A uses the mobile app
• Person B uses the mobile app
• Both talk to the same WebUI server and the same agent instance (think family assistant scenarios)
• The agent needs to know which person is speaking for memory scope, reminders, calendar behavior, privacy boundaries, and personalization

Without identity metadata, the agent has to guess or assume one default user. That gets awkward fast in household, family, team, or shared workspace scenarios.

Proposed solution

Support optional client identity metadata on every chat request.

For headers:

X-Hermes-Client-Name: Person A
X-Hermes-Client-Id: person-a-ios
X-Hermes-Session-Key: household:person-a:ios

Or equivalent JSON in the request body:

{
  "client_identity": {
    "name": "Person A",
    "id": "person-a-ios",
    "session_key": "household:person-a:ios"
  }
}

The WebUI backend could inject this into hidden runtime context for the agent:

Current WebUI sender identity: Person A
Current WebUI sender session key: household:person-a:ios

This should not appear as a visible fake user message. It should be internal context for that turn.

Mobile app support

The mobile app could expose this per saved server or connection, or pass the existing Display Name field forward:

• Display name
• Stable client ID
• Optional session key
• Optional custom headers

Then every chat request includes the identity metadata automatically.

WebUI behavior

Suggested behavior:

1. Accept identity from trusted headers and/or request body.
2. Sanitize values, strip control characters, and cap length.
3. Add identity to hidden system/runtime context.
4. Keep the visible transcript clean.
5. Optionally expose a debug view showing whether identity metadata was received, with values redacted.
6. Treat identity as context metadata, not authentication, unless paired with the WebUI auth system.

Why this matters

This would support:

• Shared family or household agents
• Team agents
• Multiple people using one backend
• Different memory scopes per person
• Safer routing for calendars, reminders, messages, and private data
• Better mobile app support
• Less need to clone full backend profiles just to distinguish users

Profiles are useful when people need real isolation. But for many setups, the desired behavior is one shared assistant that simply knows who is speaking.

Minimal version

The smallest useful implementation would be:

• Mobile app sends X-Hermes-Client-Name and X-Hermes-Session-Key
• WebUI reads those headers on /api/chat/start
• WebUI passes them into hidden agent context for that turn

That would unlock the core multi-user use case without changing the visible chat model or requiring separate backend profiles.