@jupyter-ai/persona-manager 0.2.0-a2 → 0.2.0-a4

package/lib/index.js

@@ -76,9 +76,17 @@ const toolbarPlugin = {
     provides: IInputToolbarRegistryFactory,
     requires: [IPersonaControlRegistry, IPersonaSessionRegistry],
     activate: (app, controlRegistry, sessionRegistry) => {
-        // Wrap the persona controls to inject the control + session registries,
-        // which the generic toolbar-item props don't carry.
-        const PersonaControlsItem = (itemProps) => PersonaControls({ ...itemProps, controlRegistry, sessionRegistry });
+        // The event bus front-end; `PersonaControls` uses it to emit
+        // `persona_selected` on selection.
+        const events = app.serviceManager.events;
+        // Wrap the persona controls to inject the control + session registries and
+        // the event manager, which the generic toolbar-item props don't carry.
+        const PersonaControlsItem = (itemProps) => PersonaControls({
+            ...itemProps,
+            controlRegistry,
+            sessionRegistry,
+            events
+        });
         return {
             create: () => {
                 // Start with the default toolbar (Send, Attach, Cancel, SaveEdit)

package/lib/persona-controls.d.ts

@@ -1,3 +1,4 @@
+import { Event } from '@jupyterlab/services';
 import { InputToolbarRegistry } from '@jupyter/chat';
 import { PersonaOption, Usage } from './awareness';
 import { PersonaSessionRegistry, PersonaSessionState } from './persona-events';
@@ -177,5 +178,10 @@ export declare function PersonaControls(props: InputToolbarRegistry.IToolbarItem
      * Optional so the component still works without it (renders nothing).
      */
     sessionRegistry?: PersonaSessionRegistry;
+    /**
+     * The event bus front-end, used to emit a `persona_selected` event when the
+     * user picks a persona so the server prepares it eagerly.
+     */
+    events?: Event.IManager;
 }): JSX.Element | null;
 export {};

package/lib/persona-controls.js

@@ -6,6 +6,7 @@ import MoreHorizIcon from '@mui/icons-material/MoreHoriz';
 import { PageConfig } from '@jupyterlab/coreutils';
 import { EMPTY_USAGE } from './awareness';
 import { buildMessageMetadata, emptyPersonaSettings } from './metadata';
+import { PERSONA_SELECTED_EVENT_SCHEMA_ID } from './persona-events';
 const SELECTOR_CLASS = 'jp-jai-personaControls';
 const MENU_CLASS = 'jp-jai-controlMenu';
 const USAGE_CLASS = 'jp-jai-usage';
@@ -635,12 +636,31 @@ export function UsageChip(props) {
  */
 export function PersonaControls(props) {
     var _a, _b, _c, _d, _e, _f;
-    const { chatModel, model, controlRegistry, sessionRegistry } = props;
-    // The chat's server-root-relative path scopes persona events to this chat.
-    const path = (_a = chatModel === null || chatModel === void 0 ? void 0 : chatModel.name) !== null && _a !== void 0 ? _a : null;
+    const { chatModel, model, controlRegistry, sessionRegistry, events } = props;
+    // The chat's stable id scopes persona events to this chat. It is assigned
+    // asynchronously (once the model is `ready`: the WS connection frame arrives,
+    // or the RTC document syncs), so track it in state and update it when the
+    // model becomes ready. Reading it synchronously would capture `undefined`
+    // forever, since `id` is a plain accessor with no change signal.
+    const [chatId, setChatId] = useState((_a = chatModel === null || chatModel === void 0 ? void 0 : chatModel.id) !== null && _a !== void 0 ? _a : null);
+    useEffect(() => {
+        if (!chatModel) {
+            setChatId(null);
+            return;
+        }
+        let cancelled = false;
+        void chatModel.ready.then(id => {
+            if (!cancelled) {
+                setChatId(id !== null && id !== void 0 ? id : null);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [chatModel]);
     // The per-chat persona session state, built from persona events and shared
     // via the registry. Created on demand; discarded when the chat closes.
-    const managerState = useMemo(() => (sessionRegistry && path ? sessionRegistry.get(path) : null), [sessionRegistry, path]);
+    const managerState = useMemo(() => (sessionRegistry && chatId ? sessionRegistry.get(chatId) : null), [sessionRegistry, chatId]);
     const [personas, setPersonas] = useState([]);
     // Whether a persona list has been received for this chat yet. Before that, an
     // empty list means "still loading", not "this chat has no personas".
@@ -712,15 +732,15 @@ export function PersonaControls(props) {
     // Discard this chat's session state when the chat model is disposed (chat
     // closed), freeing its memory.
     useEffect(() => {
-        if (!sessionRegistry || !path || !chatModel) {
+        if (!sessionRegistry || !chatId || !chatModel) {
             return;
         }
-        const onDisposed = () => sessionRegistry.discard(path);
+        const onDisposed = () => sessionRegistry.discard(chatId);
         chatModel.disposed.connect(onDisposed);
         return () => {
             chatModel.disposed.disconnect(onDisposed);
         };
-    }, [sessionRegistry, path, chatModel]);
+    }, [sessionRegistry, chatId, chatModel]);
     // Stamp the current persona + its settings onto the input model's metadata,
     // so it rides out with the next message and the PersonaManager routes and
     // applies it. Keyed on a signature so we only write when it changes.
@@ -729,6 +749,21 @@ export function PersonaControls(props) {
         model.clearMetadata();
         model.updateMetadata(buildMessageMetadata(selectedId, settings));
     }, [model, metadataSignature]);
+    // On selection, tell the server to prepare the persona by
+    // emitting `persona_selected` over the event bus, so its controls appear
+    // before the first message. Skips "No one"; idempotent server-side.
+    useEffect(() => {
+        if (!events || !chatId || !selectedId) {
+            return;
+        }
+        void events
+            .emit({
+            schema_id: PERSONA_SELECTED_EVENT_SCHEMA_ID,
+            version: '1',
+            data: { chat_id: chatId, persona_id: selectedId }
+        })
+            .catch(e => console.warn('Error emitting persona_selected event: ', e));
+    }, [events, chatId, selectedId]);
     // No personas yet. While the manager's slot or its first list read is still
     // pending, show a loading placeholder (on slow networks this takes seconds);
     // once ready with no personas, show nothing.

package/lib/persona-events.d.ts

@@ -5,9 +5,10 @@ import { ISignal } from '@lumino/signaling';
 import { CommandOption, ModelConfiguration, PersonaOption, SettingConfiguration, Usage } from './awareness';
 export declare const PERSONAS_EVENT_SCHEMA_ID = "https://schema.jupyter.org/jupyter_ai_persona_manager/personas/v1";
 export declare const PERSONA_STATE_EVENT_SCHEMA_ID = "https://schema.jupyter.org/jupyter_ai_persona_manager/persona_state/v1";
+export declare const PERSONA_SELECTED_EVENT_SCHEMA_ID = "https://schema.jupyter.org/jupyter_ai_persona_manager/persona_selected/v1";
 /** The wire shape of a `persona_state` event. */
 type PersonaStatePayload = {
-    path?: string;
+    chat_id?: string;
     persona_id?: string;
     model?: ModelConfiguration;
     settings?: SettingConfiguration[];
@@ -33,8 +34,8 @@ export declare class PersonaSessionState {
  * or any persona's state updates, so React components re-render.
  */
 export declare class PersonaManagerSessionState implements IDisposable {
-    readonly path: string;
-    constructor(path: string);
+    readonly chatId: string;
+    constructor(chatId: string);
     /** Emits whenever the persona list or a persona's state changes. */
     get changed(): ISignal<this, void>;
     /** Whether a `personas` event has been received for this chat yet. */
@@ -65,20 +66,20 @@ export declare class PersonaManagerSessionState implements IDisposable {
 export declare class PersonaSessionRegistry {
     constructor(eventListener: IEventListener);
     /**
-     * Get (or create) the manager session state for a chat path. Components call
-     * this with their chat's `IChatModel.name`.
+     * Get (or create) the manager session state for a chat. Components call this
+     * with their chat's stable id (`IChatModel.id` / `IChatContext.id`).
      */
-    get(path: string): PersonaManagerSessionState;
-    /** Whether a manager session state exists for `path` (without creating one). */
-    has(path: string): boolean;
+    get(chatId: string): PersonaManagerSessionState;
+    /** Whether a manager session state exists for `chatId` (without creating one). */
+    has(chatId: string): boolean;
     /**
      * Discard a chat's session state and free its memory. Called when the client
      * closes the chat (wired to the chat model's `disposed` signal).
      */
-    discard(path: string): void;
+    discard(chatId: string): void;
     private _onPersonasEvent;
     private _onPersonaStateEvent;
-    private _byPath;
+    private _byChatId;
 }
 /**
  * Plugin token for the shared `PersonaSessionRegistry`. Consumed by the toolbar

package/lib/persona-events.js

@@ -3,6 +3,7 @@ import { Signal } from '@lumino/signaling';
 import { EMPTY_MODEL_CONFIGURATION, EMPTY_USAGE } from './awareness';
 export const PERSONAS_EVENT_SCHEMA_ID = 'https://schema.jupyter.org/jupyter_ai_persona_manager/personas/v1';
 export const PERSONA_STATE_EVENT_SCHEMA_ID = 'https://schema.jupyter.org/jupyter_ai_persona_manager/persona_state/v1';
+export const PERSONA_SELECTED_EVENT_SCHEMA_ID = 'https://schema.jupyter.org/jupyter_ai_persona_manager/persona_selected/v1';
 /**
  * One persona's live session state, built from a `persona_state` event.
  * Immutable: each update produces a new instance, so React consumers see a new
@@ -24,8 +25,8 @@ export class PersonaSessionState {
  * or any persona's state updates, so React components re-render.
  */
 export class PersonaManagerSessionState {
-    constructor(path) {
-        this.path = path;
+    constructor(chatId) {
+        this.chatId = chatId;
         this._personasReceived = false;
         this._personas = [];
         this._states = new Map();
@@ -82,47 +83,47 @@ export class PersonaSessionRegistry {
     constructor(eventListener) {
         this._onPersonasEvent = async (_manager, _schemaId, event) => {
             const data = event;
-            if (!data.path) {
+            if (!data.chat_id) {
                 return;
             }
-            this.get(data.path).updatePersonas(Array.isArray(data.personas) ? data.personas : []);
+            this.get(data.chat_id).updatePersonas(Array.isArray(data.personas) ? data.personas : []);
         };
         this._onPersonaStateEvent = async (_manager, _schemaId, event) => {
             const data = event;
-            if (!data.path || !data.persona_id) {
+            if (!data.chat_id || !data.persona_id) {
                 return;
             }
-            this.get(data.path).updatePersonaState(data.persona_id, data);
+            this.get(data.chat_id).updatePersonaState(data.persona_id, data);
         };
-        this._byPath = new Map();
+        this._byChatId = new Map();
         eventListener.addListener(PERSONAS_EVENT_SCHEMA_ID, this._onPersonasEvent);
         eventListener.addListener(PERSONA_STATE_EVENT_SCHEMA_ID, this._onPersonaStateEvent);
     }
     /**
-     * Get (or create) the manager session state for a chat path. Components call
-     * this with their chat's `IChatModel.name`.
+     * Get (or create) the manager session state for a chat. Components call this
+     * with their chat's stable id (`IChatModel.id` / `IChatContext.id`).
      */
-    get(path) {
-        let state = this._byPath.get(path);
+    get(chatId) {
+        let state = this._byChatId.get(chatId);
         if (!state) {
-            state = new PersonaManagerSessionState(path);
-            this._byPath.set(path, state);
+            state = new PersonaManagerSessionState(chatId);
+            this._byChatId.set(chatId, state);
         }
         return state;
     }
-    /** Whether a manager session state exists for `path` (without creating one). */
-    has(path) {
-        return this._byPath.has(path);
+    /** Whether a manager session state exists for `chatId` (without creating one). */
+    has(chatId) {
+        return this._byChatId.has(chatId);
     }
     /**
      * Discard a chat's session state and free its memory. Called when the client
      * closes the chat (wired to the chat model's `disposed` signal).
      */
-    discard(path) {
-        const state = this._byPath.get(path);
+    discard(chatId) {
+        const state = this._byChatId.get(chatId);
         if (state) {
             state.dispose();
-            this._byPath.delete(path);
+            this._byChatId.delete(chatId);
         }
     }
 }

package/lib/request.d.ts

@@ -12,4 +12,4 @@ export declare function requestAPI<T>(namespace: string, endPoint?: string, init
  * via the cancel endpoint. Backend-agnostic: each persona's
  * `cancel_response()` decides what stopping means.
  */
-export declare function cancelResponse(chatPath: string): Promise<void>;
+export declare function cancelResponse(chatId: string): Promise<void>;

package/lib/request.js

@@ -38,9 +38,9 @@ export async function requestAPI(namespace, endPoint = '', init = {}) {
  * via the cancel endpoint. Backend-agnostic: each persona's
  * `cancel_response()` decides what stopping means.
  */
-export async function cancelResponse(chatPath) {
+export async function cancelResponse(chatId) {
     try {
-        await requestAPI('api/ai', `personas/cancel?chat_path=${encodeURIComponent(chatPath)}`, { method: 'POST' });
+        await requestAPI('api/ai', `personas/cancel?chat_id=${encodeURIComponent(chatId)}`, { method: 'POST' });
     }
     catch (e) {
         console.warn('Error cancelling response: ', e);

package/lib/slash-commands.js

@@ -34,15 +34,15 @@ export class SlashCommandProvider {
         if (!currentWord.startsWith('/')) {
             return [];
         }
-        const path = (_b = (_a = inputModel.chatContext) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : null;
-        if (!path) {
+        const chatId = (_b = (_a = inputModel.chatContext) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null;
+        if (!chatId) {
             return [];
         }
         const personaId = (_d = (_c = inputModel.getMetadata) === null || _c === void 0 ? void 0 : _c.call(inputModel).to_persona) !== null && _d !== void 0 ? _d : null;
         if (!personaId) {
             return [];
         }
-        const persona = this._registry.get(path).getPersona(personaId);
+        const persona = this._registry.get(chatId).getPersona(personaId);
         if (!persona) {
             return [];
         }

package/lib/stop-button.js

@@ -31,12 +31,12 @@ export function StopButton(props) {
         };
     }, [chatModel]);
     async function handleStop() {
-        if (!chatModel) {
+        if (!(chatModel === null || chatModel === void 0 ? void 0 : chatModel.id)) {
             return;
         }
         setInFlight(true);
         try {
-            await cancelResponse(chatModel.name);
+            await cancelResponse(chatModel.id);
         }
         finally {
             setInFlight(false);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jupyter-ai/persona-manager",
-    "version": "0.2.0-a2",
+    "version": "0.2.0-a4",
     "description": "The core manager & registry for AI personas in Jupyter AI",
     "keywords": [
         "jupyter",
@@ -58,7 +58,7 @@
         "watch:labextension": "jupyter labextension watch ."
     },
     "dependencies": {
-        "@jupyter/chat": "^0.23.0-alpha.4",
+        "@jupyter/chat": "^0.25.0-alpha.5",
         "@jupyterlab/application": "^4.0.0",
         "@jupyterlab/coreutils": "^6.0.0",
         "@jupyterlab/services": "^7.0.0",

package/src/__tests__/persona-events.spec.ts

@@ -41,10 +41,10 @@ function makeRegistry(): {
 }
 
 describe('PersonaSessionRegistry', () => {
-  it('routes a personas event to the matching chat by path', async () => {
+  it('routes a personas event to the matching chat by id', async () => {
     const { registry, events } = makeRegistry();
     await events.emit(PERSONAS_EVENT_SCHEMA_ID, {
-      path: 'a.chat',
+      chat_id: 'a.chat',
       personas: [{ id: 'p1', name: 'One', avatar_url: null }]
     });
     expect(registry.get('a.chat').personas.map(p => p.id)).toEqual(['p1']);
@@ -56,7 +56,7 @@ describe('PersonaSessionRegistry', () => {
   it('routes persona_state events and builds PersonaSessionState', async () => {
     const { registry, events } = makeRegistry();
     await events.emit(PERSONA_STATE_EVENT_SCHEMA_ID, {
-      path: 'a.chat',
+      chat_id: 'a.chat',
       persona_id: 'p1',
       model: { current: 'm1', options: [], settings: [] },
       usage: { input_tokens: 5 }
@@ -74,11 +74,11 @@ describe('PersonaSessionRegistry', () => {
       fired += 1;
     });
     await events.emit(PERSONAS_EVENT_SCHEMA_ID, {
-      path: 'a.chat',
+      chat_id: 'a.chat',
       personas: []
     });
     await events.emit(PERSONA_STATE_EVENT_SCHEMA_ID, {
-      path: 'a.chat',
+      chat_id: 'a.chat',
       persona_id: 'p1'
     });
     expect(fired).toBe(2);
@@ -87,7 +87,7 @@ describe('PersonaSessionRegistry', () => {
   it('discards a chat session state on close, freeing memory', async () => {
     const { registry, events } = makeRegistry();
     await events.emit(PERSONAS_EVENT_SCHEMA_ID, {
-      path: 'a.chat',
+      chat_id: 'a.chat',
       personas: [{ id: 'p1', name: 'One', avatar_url: null }]
     });
     const state = registry.get('a.chat');

package/src/index.ts

@@ -119,11 +119,20 @@ const toolbarPlugin: JupyterFrontEndPlugin<IInputToolbarRegistryFactory> = {
     controlRegistry: IPersonaControlRegistry,
     sessionRegistry: PersonaSessionRegistry
   ): IInputToolbarRegistryFactory => {
-    // Wrap the persona controls to inject the control + session registries,
-    // which the generic toolbar-item props don't carry.
+    // The event bus front-end; `PersonaControls` uses it to emit
+    // `persona_selected` on selection.
+    const events = app.serviceManager.events;
+    // Wrap the persona controls to inject the control + session registries and
+    // the event manager, which the generic toolbar-item props don't carry.
     const PersonaControlsItem = (
       itemProps: InputToolbarRegistry.IToolbarItemProps
-    ) => PersonaControls({ ...itemProps, controlRegistry, sessionRegistry });
+    ) =>
+      PersonaControls({
+        ...itemProps,
+        controlRegistry,
+        sessionRegistry,
+        events
+      });
     return {
       create: () => {
         // Start with the default toolbar (Send, Attach, Cancel, SaveEdit)

package/src/persona-controls.tsx

@@ -21,6 +21,7 @@ import ArrowDropDownIcon from '@mui/icons-material/ArrowDropDown';
 import CheckIcon from '@mui/icons-material/Check';
 import MoreHorizIcon from '@mui/icons-material/MoreHoriz';
 import { PageConfig } from '@jupyterlab/coreutils';
+import { Event } from '@jupyterlab/services';
 import { InputToolbarRegistry } from '@jupyter/chat';
 import {
   EMPTY_USAGE,
@@ -35,6 +36,7 @@ import {
   emptyPersonaSettings
 } from './metadata';
 import { IPersonaControlRegistry } from './persona-control-registry';
+import { PERSONA_SELECTED_EVENT_SCHEMA_ID } from './persona-events';
 
 const SELECTOR_CLASS = 'jp-jai-personaControls';
 const MENU_CLASS = 'jp-jai-controlMenu';
@@ -1072,17 +1074,41 @@ export function PersonaControls(
      * Optional so the component still works without it (renders nothing).
      */
     sessionRegistry?: PersonaSessionRegistry;
+    /**
+     * The event bus front-end, used to emit a `persona_selected` event when the
+     * user picks a persona so the server prepares it eagerly.
+     */
+    events?: Event.IManager;
   }
 ): JSX.Element | null {
-  const { chatModel, model, controlRegistry, sessionRegistry } = props;
-  // The chat's server-root-relative path scopes persona events to this chat.
-  const path = chatModel?.name ?? null;
+  const { chatModel, model, controlRegistry, sessionRegistry, events } = props;
+  // The chat's stable id scopes persona events to this chat. It is assigned
+  // asynchronously (once the model is `ready`: the WS connection frame arrives,
+  // or the RTC document syncs), so track it in state and update it when the
+  // model becomes ready. Reading it synchronously would capture `undefined`
+  // forever, since `id` is a plain accessor with no change signal.
+  const [chatId, setChatId] = useState<string | null>(chatModel?.id ?? null);
+  useEffect(() => {
+    if (!chatModel) {
+      setChatId(null);
+      return;
+    }
+    let cancelled = false;
+    void chatModel.ready.then(id => {
+      if (!cancelled) {
+        setChatId(id ?? null);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [chatModel]);
 
   // The per-chat persona session state, built from persona events and shared
   // via the registry. Created on demand; discarded when the chat closes.
   const managerState = useMemo(
-    () => (sessionRegistry && path ? sessionRegistry.get(path) : null),
-    [sessionRegistry, path]
+    () => (sessionRegistry && chatId ? sessionRegistry.get(chatId) : null),
+    [sessionRegistry, chatId]
   );
 
   const [personas, setPersonas] = useState<PersonaOption[]>([]);
@@ -1169,15 +1195,15 @@ export function PersonaControls(
   // Discard this chat's session state when the chat model is disposed (chat
   // closed), freeing its memory.
   useEffect(() => {
-    if (!sessionRegistry || !path || !chatModel) {
+    if (!sessionRegistry || !chatId || !chatModel) {
       return;
     }
-    const onDisposed = () => sessionRegistry.discard(path);
+    const onDisposed = () => sessionRegistry.discard(chatId);
     chatModel.disposed.connect(onDisposed);
     return () => {
       chatModel.disposed.disconnect(onDisposed);
     };
-  }, [sessionRegistry, path, chatModel]);
+  }, [sessionRegistry, chatId, chatModel]);
 
   // Stamp the current persona + its settings onto the input model's metadata,
   // so it rides out with the next message and the PersonaManager routes and
@@ -1188,6 +1214,22 @@ export function PersonaControls(
     model.updateMetadata(buildMessageMetadata(selectedId, settings));
   }, [model, metadataSignature]);
 
+  // On selection, tell the server to prepare the persona by
+  // emitting `persona_selected` over the event bus, so its controls appear
+  // before the first message. Skips "No one"; idempotent server-side.
+  useEffect(() => {
+    if (!events || !chatId || !selectedId) {
+      return;
+    }
+    void events
+      .emit({
+        schema_id: PERSONA_SELECTED_EVENT_SCHEMA_ID,
+        version: '1',
+        data: { chat_id: chatId, persona_id: selectedId }
+      })
+      .catch(e => console.warn('Error emitting persona_selected event: ', e));
+  }, [events, chatId, selectedId]);
+
   // No personas yet. While the manager's slot or its first list read is still
   // pending, show a loading placeholder (on slow networks this takes seconds);
   // once ready with no personas, show nothing.

package/src/persona-events.ts

@@ -3,8 +3,8 @@
  * `jupyterlab-eventlistener`), replacing the previous Yjs-awareness channel.
  *
  * Flow: the server emits `personas` / `persona_state` events (each carrying the
- * chat's `path`); the `PersonaSessionRegistry` routes them to the per-chat
- * `PersonaManagerSessionState`, which holds the persona list and a
+ * chat's stable `chat_id`); the `PersonaSessionRegistry` routes them to the
+ * per-chat `PersonaManagerSessionState`, which holds the persona list and a
  * `PersonaSessionState` per persona and fires a Lumino `changed` signal. React
  * components listen to that signal. When a chat closes, its state is discarded.
  *
@@ -31,10 +31,12 @@ export const PERSONAS_EVENT_SCHEMA_ID =
   'https://schema.jupyter.org/jupyter_ai_persona_manager/personas/v1';
 export const PERSONA_STATE_EVENT_SCHEMA_ID =
   'https://schema.jupyter.org/jupyter_ai_persona_manager/persona_state/v1';
+export const PERSONA_SELECTED_EVENT_SCHEMA_ID =
+  'https://schema.jupyter.org/jupyter_ai_persona_manager/persona_selected/v1';
 
 /** The wire shape of a `persona_state` event. */
 type PersonaStatePayload = {
-  path?: string;
+  chat_id?: string;
   persona_id?: string;
   model?: ModelConfiguration;
   settings?: SettingConfiguration[];
@@ -44,7 +46,7 @@ type PersonaStatePayload = {
 
 /** The wire shape of a `personas` event. */
 type PersonasPayload = {
-  path?: string;
+  chat_id?: string;
   personas?: PersonaOption[];
 };
 
@@ -76,7 +78,7 @@ export class PersonaSessionState {
  * or any persona's state updates, so React components re-render.
  */
 export class PersonaManagerSessionState implements IDisposable {
-  constructor(public readonly path: string) {}
+  constructor(public readonly chatId: string) {}
 
   /** Emits whenever the persona list or a persona's state changes. */
   get changed(): ISignal<this, void> {
@@ -151,32 +153,32 @@ export class PersonaSessionRegistry {
   }
 
   /**
-   * Get (or create) the manager session state for a chat path. Components call
-   * this with their chat's `IChatModel.name`.
+   * Get (or create) the manager session state for a chat. Components call this
+   * with their chat's stable id (`IChatModel.id` / `IChatContext.id`).
    */
-  get(path: string): PersonaManagerSessionState {
-    let state = this._byPath.get(path);
+  get(chatId: string): PersonaManagerSessionState {
+    let state = this._byChatId.get(chatId);
     if (!state) {
-      state = new PersonaManagerSessionState(path);
-      this._byPath.set(path, state);
+      state = new PersonaManagerSessionState(chatId);
+      this._byChatId.set(chatId, state);
     }
     return state;
   }
 
-  /** Whether a manager session state exists for `path` (without creating one). */
-  has(path: string): boolean {
-    return this._byPath.has(path);
+  /** Whether a manager session state exists for `chatId` (without creating one). */
+  has(chatId: string): boolean {
+    return this._byChatId.has(chatId);
   }
 
   /**
    * Discard a chat's session state and free its memory. Called when the client
    * closes the chat (wired to the chat model's `disposed` signal).
    */
-  discard(path: string): void {
-    const state = this._byPath.get(path);
+  discard(chatId: string): void {
+    const state = this._byChatId.get(chatId);
     if (state) {
       state.dispose();
-      this._byPath.delete(path);
+      this._byChatId.delete(chatId);
     }
   }
 
@@ -186,10 +188,10 @@ export class PersonaSessionRegistry {
     event: Event.Emission
   ): Promise<void> => {
     const data = event as PersonasPayload;
-    if (!data.path) {
+    if (!data.chat_id) {
       return;
     }
-    this.get(data.path).updatePersonas(
+    this.get(data.chat_id).updatePersonas(
       Array.isArray(data.personas) ? data.personas : []
     );
   };
@@ -200,13 +202,13 @@ export class PersonaSessionRegistry {
     event: Event.Emission
   ): Promise<void> => {
     const data = event as PersonaStatePayload;
-    if (!data.path || !data.persona_id) {
+    if (!data.chat_id || !data.persona_id) {
       return;
     }
-    this.get(data.path).updatePersonaState(data.persona_id, data);
+    this.get(data.chat_id).updatePersonaState(data.persona_id, data);
   };
 
-  private _byPath = new Map<string, PersonaManagerSessionState>();
+  private _byChatId = new Map<string, PersonaManagerSessionState>();
 }
 
 /**

package/src/request.ts

@@ -48,11 +48,11 @@ export async function requestAPI<T>(
  * via the cancel endpoint. Backend-agnostic: each persona's
  * `cancel_response()` decides what stopping means.
  */
-export async function cancelResponse(chatPath: string): Promise<void> {
+export async function cancelResponse(chatId: string): Promise<void> {
   try {
     await requestAPI(
       'api/ai',
-      `personas/cancel?chat_path=${encodeURIComponent(chatPath)}`,
+      `personas/cancel?chat_id=${encodeURIComponent(chatId)}`,
       { method: 'POST' }
     );
   } catch (e) {

package/src/slash-commands.ts

@@ -43,8 +43,8 @@ export class SlashCommandProvider implements IChatCommandProvider {
       return [];
     }
 
-    const path = inputModel.chatContext?.name ?? null;
-    if (!path) {
+    const chatId = inputModel.chatContext?.id ?? null;
+    if (!chatId) {
       return [];
     }
 
@@ -53,7 +53,7 @@ export class SlashCommandProvider implements IChatCommandProvider {
       return [];
     }
 
-    const persona = this._registry.get(path).getPersona(personaId);
+    const persona = this._registry.get(chatId).getPersona(personaId);
     if (!persona) {
       return [];
     }

package/src/stop-button.tsx

@@ -38,13 +38,13 @@ export function StopButton(
   }, [chatModel]);
 
   async function handleStop() {
-    if (!chatModel) {
+    if (!chatModel?.id) {
       return;
     }
 
     setInFlight(true);
     try {
-      await cancelResponse(chatModel.name);
+      await cancelResponse(chatModel.id);
     } finally {
       setInFlight(false);
     }