@agentscope-ai/chat 1.2.0-beta.1788158364708 → 1.2.0-beta.1788233261358

package/components/AgentScopeRuntimeWebUI/core/Context/ChatAnywhereSessionsContext.tsx

@@ -12,6 +12,7 @@ import {
   collectSessionIdentityAliases,
   isSameLoadedSession,
 } from './sessionIdentity';
+import { activateCachedSessionMessages } from './sessionMessageActivation';
 import { useChatAnywhereCommandDispatcher } from './useChatAnywhereEventEmitter';
 
 const hasOwn = Object.prototype.hasOwnProperty;
@@ -179,6 +180,14 @@ export const useChatAnywhereSessionLoader = () => {
         undefined,
         getSessions(),
       );
+      // `createSession` already seeded this session's message cache, so no
+      // backend load is necessary. We still need to promote that cached list
+      // to the active view after React has applied the new session id;
+      // otherwise the previous conversation remains visible until another
+      // interaction triggers a render or session load.
+      ReactDOM.flushSync(() => {
+        activateCachedSessionMessages(currentSessionId, setSessionMessages);
+      });
       await dispatch('handleSessionLoaded', {
         session_id: currentSessionId,
         generating: false,

package/components/AgentScopeRuntimeWebUI/core/Context/__tests__/sessionMessageActivation.test.ts

@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { IAgentScopeRuntimeWebUIMessage } from '../../types/IMessages';
+import { activateCachedSessionMessages } from '../sessionMessageActivation';
+
+const oldMessages: IAgentScopeRuntimeWebUIMessage[] = [
+  { id: 'old-message', role: 'user' },
+];
+
+test('activates the cached message list for a newly created session', () => {
+  const messagesBySession: Record<
+    string,
+    IAgentScopeRuntimeWebUIMessage[]
+  > = {
+    old: oldMessages,
+    fresh: [],
+  };
+  let visibleMessages = oldMessages;
+
+  activateCachedSessionMessages('fresh', (sessionId, updater) => {
+    const previous = messagesBySession[sessionId] || [];
+    const next =
+      typeof updater === 'function' ? updater(previous) : updater;
+    messagesBySession[sessionId] = next;
+    visibleMessages = next;
+  });
+
+  assert.deepEqual(visibleMessages, []);
+  assert.equal(messagesBySession.old, oldMessages);
+});

package/components/AgentScopeRuntimeWebUI/core/Context/sessionMessageActivation.ts

@@ -0,0 +1,15 @@
+import type { IAgentScopeRuntimeWebUIMessagesContext } from '../types/IMessages';
+
+/**
+ * Promote a session's already-cached messages to the active message view.
+ *
+ * The messages context decides whether a write targets the visible session
+ * from the current session identity, so replaying the cached value after the
+ * identity render is enough to switch views without refetching the session.
+ */
+export function activateCachedSessionMessages(
+  sessionId: string,
+  setSessionMessages: IAgentScopeRuntimeWebUIMessagesContext['setSessionMessages'],
+) {
+  setSessionMessages(sessionId, (messages) => messages);
+}

package/lib/AgentScopeRuntimeWebUI/core/Chat/Input/useMentions.d.ts

@@ -10,5 +10,5 @@ export default function useMentions(options: IAgentScopeRuntimeWebUISenderMentio
     header: import("react/jsx-runtime").JSX.Element;
     mentions: IAgentScopeRuntimeWebUISenderMentionItem[];
     open: boolean;
-    wrapInput: (node: React.ReactNode) => string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode>;
+    wrapInput: (node: React.ReactNode) => string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element;
 };

package/lib/AgentScopeRuntimeWebUI/core/Context/ChatAnywhereSessionsContext.js

@@ -24,6 +24,7 @@ import { createContext, useContextSelector } from 'use-context-selector';
 import { ChatAnywhereMessagesContext } from "./ChatAnywhereMessagesContext";
 import { useChatAnywhereOptions } from "./ChatAnywhereOptionsContext";
 import { collectSessionIdentityAliases, isSameLoadedSession } from "./sessionIdentity";
+import { activateCachedSessionMessages } from "./sessionMessageActivation";
 import { useChatAnywhereCommandDispatcher } from "./useChatAnywhereEventEmitter";
 import { jsx as _jsx } from "react/jsx-runtime";
 var hasOwn = Object.prototype.hasOwnProperty;
@@ -157,60 +158,68 @@ export var useChatAnywhereSessionLoader = function useChatAnywhereSessionLoader(
           return _context.abrupt("return");
         case 6:
           if (!((skipNextSessionLoadIdRef === null || skipNextSessionLoadIdRef === void 0 ? void 0 : skipNextSessionLoadIdRef.current) === currentSessionId)) {
-            _context.next = 12;
+            _context.next = 13;
             break;
           }
           skipNextSessionLoadIdRef.current = undefined;
           loadedSessionAliasesRef.current = collectSessionIdentityAliases(currentSessionId, undefined, getSessions());
-          _context.next = 11;
+          // `createSession` already seeded this session's message cache, so no
+          // backend load is necessary. We still need to promote that cached list
+          // to the active view after React has applied the new session id;
+          // otherwise the previous conversation remains visible until another
+          // interaction triggers a render or session load.
+          ReactDOM.flushSync(function () {
+            activateCachedSessionMessages(currentSessionId, setSessionMessages);
+          });
+          _context.next = 12;
           return dispatch('handleSessionLoaded', {
             session_id: currentSessionId,
             generating: false
           });
-        case 11:
-          return _context.abrupt("return");
         case 12:
+          return _context.abrupt("return");
+        case 13:
           existingSessions = getSessions();
           sameLoadedSession = isSameLoadedSession(currentSessionId, loadedSessionAliasesRef.current, existingSessions);
           if (!sameLoadedSession) {
-            _context.next = 17;
+            _context.next = 18;
             break;
           }
           loadedSessionAliasesRef.current = new Set([].concat(_toConsumableArray(loadedSessionAliasesRef.current), _toConsumableArray(collectSessionIdentityAliases(currentSessionId, undefined, existingSessions))));
           return _context.abrupt("return");
-        case 17:
+        case 18:
           ReactDOM.flushSync(function () {
             setSessionMessages(currentSessionId, []);
           });
-          _context.prev = 18;
-          _context.next = 21;
+          _context.prev = 19;
+          _context.next = 22;
           return options.api.getSession(currentSessionId);
-        case 21:
+        case 22:
           session = _context.sent;
-          _context.next = 31;
+          _context.next = 32;
           break;
-        case 24:
-          _context.prev = 24;
-          _context.t0 = _context["catch"](18);
+        case 25:
+          _context.prev = 25;
+          _context.t0 = _context["catch"](19);
           if (!isLatestLoad()) {
-            _context.next = 30;
+            _context.next = 31;
             break;
           }
           console.error('get session failed:', _context.t0);
-          _context.next = 30;
+          _context.next = 31;
           return dispatch('handleSessionLoaded', {
             session_id: currentSessionId,
             generating: false
           });
-        case 30:
-          return _context.abrupt("return");
         case 31:
+          return _context.abrupt("return");
+        case 32:
           if (isLatestLoad()) {
-            _context.next = 33;
+            _context.next = 34;
             break;
           }
           return _context.abrupt("return");
-        case 33:
+        case 34:
           loadedSessionAliasesRef.current = collectSessionIdentityAliases(currentSessionId, session, getSessions());
           messages = ((_session = session) === null || _session === void 0 ? void 0 : _session.messages) || [];
           setSessionMessages(currentSessionId, messages.map(function (item) {
@@ -218,25 +227,25 @@ export var useChatAnywhereSessionLoader = function useChatAnywhereSessionLoader(
               history: true
             });
           }));
-          _context.next = 38;
+          _context.next = 39;
           return dispatch('handleSessionLoaded', {
             session_id: currentSessionId,
             generating: !!((_session2 = session) !== null && _session2 !== void 0 && _session2.generating)
           });
-        case 38:
+        case 39:
           if (!((_session3 = session) !== null && _session3 !== void 0 && _session3.generating)) {
-            _context.next = 41;
+            _context.next = 42;
             break;
           }
-          _context.next = 41;
+          _context.next = 42;
           return dispatch('handleReconnect', {
             session_id: currentSessionId
           });
-        case 41:
+        case 42:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[18, 24]]);
+    }, _callee, null, [[19, 25]]);
   })), [currentSessionId, dispatch, getSessions, options.api, setMessages, setSessionMessages, skipNextSessionLoadIdRef]);
 };
 

package/lib/AgentScopeRuntimeWebUI/core/Context/sessionMessageActivation.d.ts

@@ -0,0 +1,9 @@
+import type { IAgentScopeRuntimeWebUIMessagesContext } from '../types/IMessages';
+/**
+ * Promote a session's already-cached messages to the active message view.
+ *
+ * The messages context decides whether a write targets the visible session
+ * from the current session identity, so replaying the cached value after the
+ * identity render is enough to switch views without refetching the session.
+ */
+export declare function activateCachedSessionMessages(sessionId: string, setSessionMessages: IAgentScopeRuntimeWebUIMessagesContext['setSessionMessages']): void;

package/lib/AgentScopeRuntimeWebUI/core/Context/sessionMessageActivation.js

@@ -0,0 +1,12 @@
+/**
+ * Promote a session's already-cached messages to the active message view.
+ *
+ * The messages context decides whether a write targets the visible session
+ * from the current session identity, so replaying the cached value after the
+ * identity render is enough to switch views without refetching the session.
+ */
+export function activateCachedSessionMessages(sessionId, setSessionMessages) {
+  setSessionMessages(sessionId, function (messages) {
+    return messages;
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentscope-ai/chat",
-  "version": "1.2.0-beta.1788158364708",
+  "version": "1.2.0-beta.1788233261358",
   "description": "a free and open-source chat framework for building excellent LLM-powered chat experiences",
   "license": "Apache-2.0",
   "sideEffects": [