Fix character_id mismatch in savedata

app.py

@@ -249,12 +249,18 @@ def save_conversation_fn(char_id: str, persona: dict, request: gr.Request):
     try:
         path = export_save(char_id, persona, session_id)
         logger.info(f"[App] Save successful → {path}")
-        return gr.update(value=path, visible=True), "*✓ Save file ready — click to download.*"
+        name = load_character(char_id).get("name", char_id)
+        return gr.update(value=path, visible=True), f"*✓ Save file ready for {name} — click to download.*"
     except Exception as e:
         logger.error(f"[App] Save failed: {e}", exc_info=True)
         return gr.update(visible=False), f"*❌ Save failed: {e}*"
 
 
+def invalidate_save_fn():
+    """A download is a snapshot; hide it once the conversation context changes."""
+    return gr.update(value=None, visible=False), ""
+
+
 def load_conversation_fn(file_path, current_char_id: str, request: gr.Request):
     """
     Read an uploaded save file, restore memory, and refresh the UI.
@@ -588,6 +594,15 @@ with gr.Blocks(title=f"Chat with {char_name}") as demo:
         outputs=[save_file, save_status],
     )
 
+    gr.on(
+        triggers=[char_selector.input, load_upload.change,
+                  chatbot.chatbot_state.change, persona_state.change],
+        fn=invalidate_save_fn,
+        inputs=[],
+        outputs=[save_file, save_status],
+        queue=False,
+    )
+
     load_event = load_upload.change(
         fn=load_conversation_fn,
         cancels=chatbot.generation_events,
@@ -622,4 +637,4 @@ with gr.Blocks(title=f"Chat with {char_name}") as demo:
 
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

tests/test_app.py

@@ -12,6 +12,7 @@ from gradio.state_holder import SessionState
 import app
 from engine import memory
 from engine.saveload import export_save
+from engine.saveload import import_save
 from test_conversations import Client, CHAR, OTHER
 
 
@@ -29,6 +30,72 @@ class AppTests(unittest.TestCase):
         self.assertFalse(app.use_translator_state.value)
         self.assertFalse(app.translator_toggle.value)
 
+    def test_session_states_are_registered_in_browser_config(self):
+        component_ids = {c['id'] for c in app.demo.get_config_file()['components']}
+        for state in (app.char_id_state, app.persona_state, app.language_state,
+                      app.model_state, app.use_translator_state):
+            with self.subTest(state=state._id):
+                self.assertIn(state._id, component_ids)
+
+    def test_stale_save_download_is_cleared_when_context_changes(self):
+        fn = next(f for f in app.demo.fns.values() if f.name == 'invalidate_save_fn')
+        self.assertEqual([app.save_file, app.save_status], fn.outputs)
+        self.assertTrue({(app.char_selector._id, 'input'),
+                         (app.load_upload._id, 'change'),
+                         (app.chatbot.chatbot_state._id, 'change'),
+                         (app.persona_state._id, 'change')}.issubset(set(fn.targets)))
+        update, status = app.invalidate_save_fn()
+        self.assertIsNone(update['value'])
+        self.assertFalse(update['visible'])
+        self.assertEqual('', status)
+
+    def test_haley_save_load_and_continue_uses_same_character(self):
+        async def dispatch(name, inputs, state):
+            fn_id = next(i for i, f in app.demo.fns.items() if f.name == name)
+            return await app.demo.process_api(fn_id, inputs, state=state,
+                request=self.request, session_hash=self.request.session_hash)
+
+        async def run():
+            haley = 'haley_dunphy'
+            state = SessionState(app.demo)
+            await dispatch('on_character_change', [haley], state)
+            history = memory.load_conversation(self.session, haley)['recent_messages']
+            history.extend([{'role': 'user', 'content': 'Remember our trip?'},
+                            {'role': 'assistant', 'content': 'Of course!'}])
+            app.persist_visible_history(history, haley, self.request)
+            saved = await dispatch('save_conversation_fn', [None, None], state)
+            path = Path(saved['data'][0]['value']['path'])
+            self.assertEqual(haley, import_save(path)['character_id'])
+            self.assertIn('Haley Dunphy', saved['data'][1])
+            await dispatch('on_character_change', [CHAR], state)
+            with tempfile.TemporaryDirectory(dir=gr.utils.get_upload_folder()) as directory:
+                uploaded = Path(directory) / 'haley.json'
+                uploaded.write_bytes(path.read_bytes())
+                loaded = await dispatch('load_conversation_fn',
+                    [{'path': str(uploaded), 'meta': {'_type': 'gradio.FileData'}}, None], state)
+            self.assertEqual(haley, state[app.char_id_state._id])
+            self.assertEqual(haley, loaded['data'][11]['value'])
+            self.assertEqual('## Haley Dunphy', loaded['data'][8])
+            self.assertEqual(history, memory.normalize_history(loaded['data'][7]['value']))
+            await dispatch('on_character_change', [CHAR], state)
+            await dispatch('on_character_change', [haley], state)
+            self.assertEqual(history, memory.normalize_history(state[app.chatbot.chatbot_state._id]))
+            client = Client()
+            with patch.object(app, 'HF_TOKEN', 'test'), patch.object(app, 'InferenceClient', return_value=client):
+                result = await dispatch('respond', ['What happened next?', None, 100, .7, .95,
+                                                   None, None, None, None, None], state)
+                fn_id = next(i for i, f in app.demo.fns.items() if f.name == 'respond')
+                while result['is_generating']:
+                    result = await app.demo.process_api(fn_id, [], state=state,
+                        request=self.request, session_hash=self.request.session_hash,
+                        iterator=result['iterator'])
+            self.assertIn('Haley', client.calls[0][0][0]['content'])
+            self.assertEqual(history, memory.load_conversation(self.session, haley)['recent_messages'][:-2])
+            self.assertEqual(1, len(memory.load_conversation(self.session, CHAR)['recent_messages']))
+
+        Path(gr.utils.get_upload_folder()).mkdir(parents=True, exist_ok=True)
+        asyncio.run(run())
+
     def test_character_switch_restores_visible_and_internal_history(self):
         state = memory.load_conversation(self.session, CHAR)
         state['recent_messages'].extend([{'role': 'user', 'content': 'Remember me'},