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

package/lib/persona-controls.js

@@ -636,11 +636,30 @@ 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;
+    // 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 +731,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.

package/lib/persona-events.d.ts

@@ -7,7 +7,7 @@ export declare const PERSONAS_EVENT_SCHEMA_ID = "https://schema.jupyter.org/jupy
 export declare const PERSONA_STATE_EVENT_SCHEMA_ID = "https://schema.jupyter.org/jupyter_ai_persona_manager/persona_state/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 +33,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 +65,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

@@ -24,8 +24,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 +82,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-a3",
     "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/persona-controls.tsx

@@ -1075,14 +1075,33 @@ export function PersonaControls(
   }
 ): 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;
+  // 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 +1188,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

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.
  *
@@ -34,7 +34,7 @@ export const PERSONA_STATE_EVENT_SCHEMA_ID =
 
 /** The wire shape of a `persona_state` event. */
 type PersonaStatePayload = {
-  path?: string;
+  chat_id?: string;
   persona_id?: string;
   model?: ModelConfiguration;
   settings?: SettingConfiguration[];
@@ -44,7 +44,7 @@ type PersonaStatePayload = {
 
 /** The wire shape of a `personas` event. */
 type PersonasPayload = {
-  path?: string;
+  chat_id?: string;
   personas?: PersonaOption[];
 };
 
@@ -76,7 +76,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 +151,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 +186,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 +200,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);
     }