@beanx/cathygo-web-core 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,30 @@
+# @beanx/cathygo-web-core
+
+Shared CathyGO Web UI and state package.
+
+Current active upgrade plan:
+
+- [`../../docs/session-runtime-vnext-upgrade-plan.md`](../../docs/session-runtime-vnext-upgrade-plan.md)
+
+## vNext Role
+
+This package owns the selected-session view model for:
+
+- single-session transcript rendering
+- session event reduction
+- optimistic user input reconciliation by `client_input_id`
+- session-scoped stop state
+- replay-safe hydration after refresh or reconnect
+- selectors used by local Web and `beanx-home`
+
+Host applications still own account routing, agent selection, transport setup,
+selected session id, lightweight session lists, and product-specific shell UI.
+They should not own a second session execution runtime.
+
+## First vNext Deliverables
+
+- Keep the current single-session `ChatState` reducer exported.
+- Add `SessionViewState`, session event reducer, and current-session selectors.
+- Add reducer tests for interrupt, replay, stop, and optimistic reconciliation.
+- Prove the implementation in `cathygo-agent/web` before publishing
+  `@beanx/cathygo-web-core@0.2.0`.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { Dispatch, RefObject } from 'react';
-import { AgentActivity, LearningTurnEvent, ConversationSummary, GatewayModelStatus } from '@beanx/cathygo-protocol';
+import { AgentActivity, SessionRuntimeSnapshot, LearningTurnEvent, ConversationSummary, GatewayModelStatus } from '@beanx/cathygo-protocol';
 
 type AgentIdentityStatus = {
     agent_id?: string | null;
@@ -73,6 +73,12 @@ type ChatAttachment = {
     width?: number | null;
     height?: number | null;
     created_at?: string | null;
+    thumbnail?: {
+        mime_type: string;
+        data_base64: string;
+        width?: number | null;
+        height?: number | null;
+    } | null;
 };
 type ChatMessagePart = {
     type: 'text';
@@ -88,6 +94,8 @@ type ChatMessage$1 = {
     content: string;
     parts?: ChatMessagePart[];
     turnId?: string;
+    clientInputId?: string;
+    clientTurnId?: string;
     status?: 'streaming' | 'done' | 'error';
 };
 type ChatState = {
@@ -96,6 +104,7 @@ type ChatState = {
     messages: ChatMessage$1[];
     activitiesByTurnId: Record<string, AgentActivity[]>;
     progressByTurnId: Record<string, AgentRunProgress>;
+    runtime?: SessionRuntimeSnapshot;
     status: string;
     contextMessageCount?: number;
     error?: string;
@@ -131,6 +140,7 @@ type ChatAction = {
     sessionId: string;
     messages: ChatMessage$1[];
     activities?: AgentActivity[];
+    runtime?: SessionRuntimeSnapshot;
 } | {
     type: 'session.load.failed';
     sessionId: string;
@@ -141,10 +151,15 @@ type ChatAction = {
     id: string;
     content: string;
     parts?: ChatMessagePart[];
+    clientInputId?: string;
+    clientTurnId?: string;
 } | {
-    type: 'turn.accepted';
+    type: 'session.input.accepted';
     sessionId: string;
     turnId: string;
+    clientInputId?: string;
+    clientTurnId?: string;
+    idempotentReplay?: boolean;
 } | {
     type: 'send.failed';
     id: string;
@@ -204,7 +219,7 @@ type UseCathyGOChatResult = {
     dispatchChat: Dispatch<ChatAction>;
     resetChat: () => void;
     createSession: (sessionId: string) => void;
-    loadSession: (sessionId: string, messages: ChatMessage$1[], activities?: ChatState['activitiesByTurnId'][string]) => void;
+    loadSession: (sessionId: string, messages: ChatMessage$1[], activities?: ChatState['activitiesByTurnId'][string], runtime?: SessionRuntimeSnapshot) => void;
     applyTurnEvent: (event: LearningTurnEvent) => void;
 };
 declare function useCathyGOChat(initialState?: ChatState): UseCathyGOChatResult;

package/dist/index.js

@@ -1459,7 +1459,7 @@ function ChatMessage({ message }) {
               "img",
               {
                 alt: part.attachment.original_name ?? "Attached image",
-                src: part.attachment.uri
+                src: attachmentImageSrc(part.attachment)
               },
               part.attachment_id
             ) : null
@@ -1481,6 +1481,18 @@ function ChatMessage({ message }) {
     }
   );
 }
+function attachmentImageSrc(attachment) {
+  if (isRenderableUri(attachment.uri)) return attachment.uri;
+  const thumbnail = attachment.thumbnail;
+  if (thumbnail?.mime_type && thumbnail.data_base64) {
+    return `data:${thumbnail.mime_type};base64,${thumbnail.data_base64}`;
+  }
+  return attachment.uri;
+}
+function isRenderableUri(uri) {
+  if (!uri) return false;
+  return uri.startsWith("blob:") || uri.startsWith("data:") || uri.startsWith("http://") || uri.startsWith("https://");
+}
 
 // src/chat-ui/components/ScrollToBottomButton.tsx
 import { useEffect as useEffect3, useState as useState5 } from "react";
@@ -1668,7 +1680,7 @@ function ChatView({
   onSettingsOpen
 }) {
   const loadingSession = chat.status === "Loading";
-  const busy = Boolean(chat.activeTurnId) || Boolean(externalBusy) || loadingSession;
+  const busy = Boolean(externalBusy) || loadingSession;
   const ready = Boolean(chat.sessionId) && !loadingSession;
   const usingMock = model?.provider === "mock";
   const modelLabel = model ? model.model || model.display_name || model.provider : "loading model status";
@@ -1715,7 +1727,7 @@ function ChatView({
           activitiesByTurnId: chat.activitiesByTurnId,
           progressByTurnId: chat.progressByTurnId,
           messages: chat.messages,
-          onSuggest: ready && !busy ? onSuggest : void 0
+          onSuggest: ready && !busy && !chat.activeTurnId ? onSuggest : void 0
         }
       ),
       !loadingSession && chat.status === "Error" && chat.error ? /* @__PURE__ */ jsx13("p", { className: "chat-session-error", children: chat.error }) : null,
@@ -1875,14 +1887,18 @@ function reduceChat(state, action) {
     };
   }
   if (action.type === "session.loaded") {
+    const runtime = action.runtime;
+    const activeTurnId = optionalString(runtime?.active_turn_id);
+    const messages = reconcileLoadedMessages(state, action.sessionId, action.messages);
     return {
       ...state,
       sessionId: action.sessionId,
-      activeTurnId: void 0,
-      messages: action.messages,
+      activeTurnId,
+      messages,
       activitiesByTurnId: groupActivitiesByTurn(action.activities ?? []),
-      progressByTurnId: {},
-      status: "Ready",
+      progressByTurnId: activeTurnId ? setProgress({}, runtimeProgressFromSnapshot(runtime, activeTurnId)) : {},
+      runtime,
+      status: statusFromRuntime(runtime),
       error: void 0,
       errorCode: void 0
     };
@@ -1908,6 +1924,8 @@ function reduceChat(state, action) {
           role: "user",
           content: action.content,
           parts: action.parts,
+          clientInputId: action.clientInputId,
+          clientTurnId: action.clientTurnId,
           status: "done"
         }
       ],
@@ -1929,11 +1947,24 @@ function reduceChat(state, action) {
       errorCode: action.code
     };
   }
-  if (action.type === "turn.accepted") {
+  if (action.type === "session.input.accepted") {
+    const messages = attachClientIdsToPendingUser(state.messages, {
+      clientInputId: action.clientInputId,
+      clientTurnId: action.clientTurnId
+    });
     return {
       ...state,
       sessionId: action.sessionId,
       activeTurnId: action.turnId,
+      messages,
+      runtime: {
+        ...state.runtime ?? emptyRuntimeSnapshot(),
+        status: "running",
+        active_turn_id: action.turnId,
+        active_turn_ids: [action.turnId],
+        active_client_input_id: action.clientInputId ?? null,
+        active_client_turn_id: action.clientTurnId ?? null
+      },
       progressByTurnId: setProgress(state.progressByTurnId, {
         turnId: action.turnId,
         phase: "queued",
@@ -1949,12 +1980,65 @@ function reduceChat(state, action) {
   }
   const event = action.event;
   const payload = event.payload;
+  if (isDuplicateEvent(state.runtime, event)) {
+    return state;
+  }
   const next = {
     ...state,
     eventCount: state.eventCount + 1,
     sessionId: payload.session_id ?? state.sessionId,
-    activeTurnId: payload.turn_id ?? state.activeTurnId
+    activeTurnId: payload.turn_id ?? state.activeTurnId,
+    runtime: runtimeFromEvent(state.runtime, event)
   };
+  if (event.event === "session.created") {
+    return {
+      ...next,
+      status: "Ready",
+      error: void 0,
+      errorCode: void 0
+    };
+  }
+  if (event.event === "session.deleted") {
+    return {
+      ...next,
+      activeTurnId: void 0,
+      progressByTurnId: {},
+      status: "Archived"
+    };
+  }
+  if (event.event === "session.input.accepted") {
+    const turnId = optionalString(payload.turn_id);
+    if (!turnId) return next;
+    return {
+      ...next,
+      activeTurnId: turnId,
+      progressByTurnId: setProgress(next.progressByTurnId, {
+        turnId,
+        phase: "queued",
+        status: "running",
+        summary: "\u6B63\u5728\u63D0\u4EA4\u95EE\u9898",
+        detail: "\u7B49\u5F85 CathyGO \u5F00\u59CB\u5904\u7406",
+        startedAt: nowIso()
+      }),
+      status: "Thinking",
+      error: void 0,
+      errorCode: void 0
+    };
+  }
+  if (event.event === "session.stop.requested") {
+    return {
+      ...next,
+      status: "Stopping"
+    };
+  }
+  if (event.event === "user.message.created") {
+    const message = userMessageFromEvent(event);
+    if (!message) return next;
+    return {
+      ...next,
+      messages: dedupeMessages([...next.messages, message])
+    };
+  }
   if (event.event === "agent.progress.delta") {
     return {
       ...next,
@@ -2020,7 +2104,8 @@ function reduceChat(state, action) {
         next.messages,
         payload.message_id,
         finalMessage,
-        payload.turn_id
+        payload.turn_id,
+        optionalString(payload.persisted_message_id)
       )
     };
   }
@@ -2029,6 +2114,7 @@ function reduceChat(state, action) {
       ...next,
       activeTurnId: void 0,
       progressByTurnId: removeProgress(next.progressByTurnId, payload.turn_id),
+      runtime: markRuntimeIdle(next.runtime),
       status: "Ready"
     };
   }
@@ -2037,6 +2123,7 @@ function reduceChat(state, action) {
       ...next,
       activeTurnId: void 0,
       progressByTurnId: removeProgress(next.progressByTurnId, payload.turn_id),
+      runtime: markRuntimeIdle(next.runtime),
       status: "Ready"
     };
   }
@@ -2046,6 +2133,7 @@ function reduceChat(state, action) {
       ...next,
       activeTurnId: void 0,
       progressByTurnId: removeProgress(next.progressByTurnId, payload.turn_id),
+      runtime: markRuntimeIdle(next.runtime),
       status: "Error",
       error: error?.message ?? "CathyGO turn failed",
       errorCode: error?.code
@@ -2068,6 +2156,10 @@ function appendAssistantDelta(messages, messageId, delta, turnId) {
       }
     ];
   }
+  const existing = messages[index];
+  if (existing?.role === "assistant" && existing.status === "done" && existing.content) {
+    return messages;
+  }
   return messages.map(
     (message, itemIndex) => itemIndex === index ? {
       ...message,
@@ -2077,20 +2169,34 @@ function appendAssistantDelta(messages, messageId, delta, turnId) {
     } : message
   );
 }
-function finalizeAssistantMessage(messages, messageId, finalMessage, turnId) {
+function finalizeAssistantMessage(messages, messageId, finalMessage, turnId, persistedMessageId) {
   const id = String(messageId || "");
   const resolvedTurnId = optionalString(turnId);
+  const existingTurnAssistantIndex = resolvedTurnId ? messages.findIndex(
+    (message) => message.role === "assistant" && message.turnId === resolvedTurnId && message.status === "done" && Boolean(message.content)
+  ) : -1;
   if (!id && !finalMessage) {
     return messages.map(
       (message) => message.role === "assistant" && message.status === "streaming" ? { ...message, turnId: message.turnId ?? resolvedTurnId, status: "done" } : message
     );
   }
   const index = messages.findIndex((message) => message.id === id);
+  if (index === -1 && existingTurnAssistantIndex !== -1) {
+    return messages.map(
+      (message, itemIndex) => itemIndex === existingTurnAssistantIndex ? {
+        ...message,
+        id: persistedMessageId ?? (id || message.id),
+        content: finalMessage || message.content,
+        turnId: message.turnId ?? resolvedTurnId,
+        status: "done"
+      } : message
+    );
+  }
   if (index === -1 && finalMessage) {
     return [
       ...messages,
       {
-        id: id || `msg_done_${messages.length}`,
+        id: persistedMessageId ?? (id || `msg_done_${messages.length}`),
         role: "assistant",
         content: finalMessage,
         turnId: resolvedTurnId,
@@ -2101,12 +2207,212 @@ function finalizeAssistantMessage(messages, messageId, finalMessage, turnId) {
   return messages.map(
     (message, itemIndex) => itemIndex === index || message.role === "assistant" && message.status === "streaming" ? {
       ...message,
+      id: itemIndex === index && persistedMessageId && message.id === id ? persistedMessageId : message.id,
       content: message.content || finalMessage,
       turnId: message.turnId ?? resolvedTurnId,
       status: "done"
     } : message
   );
 }
+function reconcileLoadedMessages(state, sessionId, loadedMessages) {
+  if (state.sessionId !== sessionId || state.messages.length === 0) {
+    return dedupeMessages(loadedMessages);
+  }
+  const localMessagesByClientId = /* @__PURE__ */ new Map();
+  for (const message of state.messages) {
+    if (message.role !== "user") continue;
+    for (const key of messageClientKeys(message)) {
+      localMessagesByClientId.set(key, message);
+    }
+  }
+  const reconciled = loadedMessages.map((message) => {
+    if (message.role !== "user") return message;
+    const local = messageClientKeys(message).map((key) => localMessagesByClientId.get(key)).find((item) => Boolean(item));
+    if (!local) return message;
+    return mergeLoadedUserMessage(local, message);
+  });
+  const loadedClientKeys = new Set(reconciled.flatMap(messageClientKeys));
+  const pendingLocalMessages = state.messages.filter((message) => {
+    if (message.role !== "user" || message.status === "error") return false;
+    const keys = messageClientKeys(message);
+    return keys.length > 0 && keys.every((key) => !loadedClientKeys.has(key));
+  });
+  return dedupeMessages([...reconciled, ...pendingLocalMessages]);
+}
+function mergeLoadedUserMessage(local, loaded) {
+  return {
+    ...loaded,
+    content: loaded.content || local.content,
+    parts: mergeMessageParts(local.parts, loaded.parts),
+    clientInputId: loaded.clientInputId ?? local.clientInputId,
+    clientTurnId: loaded.clientTurnId ?? local.clientTurnId,
+    status: loaded.status ?? "done"
+  };
+}
+function mergeMessageParts(localParts, loadedParts) {
+  if (!loadedParts?.length) return localParts;
+  if (!localParts?.length) return loadedParts;
+  return loadedParts.map((part) => {
+    if (part.type !== "image") return part;
+    const local = localParts.find(
+      (item) => item.type === "image" && item.attachment_id === part.attachment_id
+    );
+    if (!local) return part;
+    if (isLocalAttachmentPreview(local.attachment.uri) && !isReachableAttachmentUri(part.attachment.uri)) {
+      return {
+        ...part,
+        attachment: {
+          ...part.attachment,
+          uri: local.attachment.uri
+        }
+      };
+    }
+    return part;
+  });
+}
+function userMessageFromEvent(event) {
+  const payload = event.payload;
+  const messageId = optionalString(payload.message_id);
+  if (!messageId) return void 0;
+  const metadata = plainRecord(payload.metadata);
+  return {
+    id: messageId,
+    role: "user",
+    content: optionalString(payload.message) ?? "",
+    parts: chatPartsFromPayload(payload.parts),
+    turnId: optionalString(payload.turn_id),
+    clientInputId: optionalString(payload.client_input_id) ?? metadataString(metadata, "client_input_id"),
+    clientTurnId: optionalString(payload.client_turn_id) ?? metadataString(metadata, "client_turn_id"),
+    status: "done"
+  };
+}
+function chatPartsFromPayload(parts) {
+  if (!Array.isArray(parts)) return void 0;
+  const normalized = parts.map((part) => {
+    const raw = plainRecord(part);
+    if (!raw) return void 0;
+    const type = optionalString(raw.type);
+    if (type === "text") {
+      const text = optionalString(raw.text);
+      return text ? { type: "text", text } : void 0;
+    }
+    if (type === "image") {
+      const attachmentId = optionalString(raw.attachment_id);
+      const attachment = chatAttachmentFromPayload(raw.attachment, attachmentId);
+      if (!attachmentId || !attachment) return void 0;
+      return {
+        type: "image",
+        attachment_id: attachmentId,
+        attachment
+      };
+    }
+    return void 0;
+  }).filter((part) => Boolean(part));
+  return normalized.length ? normalized : void 0;
+}
+function chatAttachmentFromPayload(value, attachmentId) {
+  const raw = plainRecord(value);
+  if (!raw && !attachmentId) return void 0;
+  return {
+    id: optionalString(raw?.id) ?? attachmentId ?? "",
+    kind: "image",
+    uri: optionalString(raw?.uri) ?? "",
+    original_name: optionalString(raw?.original_name) ?? null,
+    mime_type: optionalString(raw?.mime_type) ?? null,
+    size_bytes: optionalNumber(raw?.size_bytes),
+    sha256: optionalString(raw?.sha256) ?? null,
+    width: optionalNumber(raw?.width),
+    height: optionalNumber(raw?.height),
+    created_at: optionalString(raw?.created_at) ?? null,
+    thumbnail: thumbnailFromPayload(raw?.thumbnail)
+  };
+}
+function thumbnailFromPayload(value) {
+  const raw = plainRecord(value);
+  if (!raw) return null;
+  const mimeType = optionalString(raw.mime_type);
+  const dataBase64 = optionalString(raw.data_base64);
+  if (!mimeType || !dataBase64) return null;
+  return {
+    mime_type: mimeType,
+    data_base64: dataBase64,
+    width: optionalNumber(raw.width),
+    height: optionalNumber(raw.height)
+  };
+}
+function dedupeMessages(messages) {
+  const next = [];
+  for (const message of messages) {
+    const duplicateIndex = next.findIndex((item) => messagesMatch(item, message));
+    if (duplicateIndex === -1) {
+      next.push(message);
+      continue;
+    }
+    next[duplicateIndex] = mergeDuplicateMessage(next[duplicateIndex], message);
+  }
+  return next;
+}
+function messagesMatch(left, right) {
+  if (left.id === right.id) return true;
+  if (left.role !== right.role) return false;
+  if (left.role === "assistant" && left.turnId && left.turnId === right.turnId) return true;
+  const leftKeys = new Set(messageClientKeys(left));
+  return messageClientKeys(right).some((key) => leftKeys.has(key));
+}
+function mergeDuplicateMessage(base, update) {
+  const preferUpdate = base.id.startsWith("user_") && !update.id.startsWith("user_") || base.id.startsWith("msg_") && !update.id.startsWith("msg_") || update.status === "done";
+  const primary = preferUpdate ? update : base;
+  const secondary = preferUpdate ? base : update;
+  return {
+    ...primary,
+    content: primary.content || secondary.content,
+    parts: mergeMessageParts(secondary.parts, primary.parts),
+    turnId: primary.turnId ?? secondary.turnId,
+    clientInputId: primary.clientInputId ?? secondary.clientInputId,
+    clientTurnId: primary.clientTurnId ?? secondary.clientTurnId,
+    status: primary.status ?? secondary.status
+  };
+}
+function attachClientIdsToPendingUser(messages, ids) {
+  if (!ids.clientInputId && !ids.clientTurnId) return messages;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.role !== "user") continue;
+    if (message.clientInputId || message.clientTurnId) return messages;
+    return messages.map(
+      (item, itemIndex) => itemIndex === index ? {
+        ...item,
+        clientInputId: ids.clientInputId,
+        clientTurnId: ids.clientTurnId
+      } : item
+    );
+  }
+  return messages;
+}
+function messageClientKeys(message) {
+  return [message.clientInputId, message.clientTurnId].map((value) => optionalString(value)).filter((value) => Boolean(value));
+}
+function metadataString(metadata, key) {
+  return optionalString(metadata?.[key]);
+}
+function isDuplicateEvent(runtime, event) {
+  if (!event.seq || event.seq <= 0) return false;
+  return event.seq <= (runtime?.last_event_seq ?? 0);
+}
+function plainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isLocalAttachmentPreview(uri) {
+  return Boolean(uri?.startsWith("blob:") || uri?.startsWith("data:"));
+}
+function isReachableAttachmentUri(uri) {
+  if (!uri) return false;
+  return uri.startsWith("blob:") || uri.startsWith("data:") || uri.startsWith("http://") || uri.startsWith("https://");
+}
 function isAgentActivityEvent(event) {
   return event.event.startsWith("agent.activity.");
 }
@@ -2217,6 +2523,78 @@ function progressFromActivity(progressByTurnId, activity, turnActivities, messag
   }
   return progressByTurnId;
 }
+function runtimeProgressFromSnapshot(runtime, turnId) {
+  return {
+    turnId,
+    phase: runtime?.status === "stopping" ? "model" : "queued",
+    status: "running",
+    summary: runtime?.status === "stopping" ? "\u6B63\u5728\u505C\u6B62" : "\u6B63\u5728\u6062\u590D\u4F1A\u8BDD\u72B6\u6001",
+    detail: runtime?.active_client_input_id ? `client_input_id=${runtime.active_client_input_id}` : void 0,
+    startedAt: nowIso()
+  };
+}
+function runtimeFromEvent(current, event) {
+  const payload = event.payload;
+  const turnId = optionalString(payload.turn_id);
+  const turnIds = eventTurnIds(payload, turnId);
+  const base = {
+    ...current ?? emptyRuntimeSnapshot(),
+    last_event_seq: Math.max(current?.last_event_seq ?? 0, event.seq)
+  };
+  if (event.event === "session.input.accepted" || event.event === "turn.started") {
+    return {
+      ...base,
+      status: "running",
+      active_turn_id: turnId ?? base.active_turn_id ?? null,
+      active_turn_ids: turnIds.length > 0 ? turnIds : base.active_turn_ids ?? [],
+      active_client_input_id: optionalString(payload.client_input_id) ?? base.active_client_input_id ?? null,
+      active_client_turn_id: optionalString(payload.client_turn_id) ?? base.active_client_turn_id ?? null
+    };
+  }
+  if (event.event === "session.stop.requested") {
+    return {
+      ...base,
+      status: "stopping",
+      active_turn_id: turnId ?? base.active_turn_id ?? null,
+      active_turn_ids: turnIds.length > 0 ? turnIds : base.active_turn_ids ?? []
+    };
+  }
+  if (event.event === "turn.completed" || event.event === "turn.cancelled" || event.event === "turn.failed" || event.event === "session.deleted") {
+    return markRuntimeIdle(base);
+  }
+  return base;
+}
+function eventTurnIds(payload, turnId) {
+  if (Array.isArray(payload.turn_ids)) {
+    return payload.turn_ids.map((value) => optionalString(value)).filter((value) => Boolean(value));
+  }
+  return turnId ? [turnId] : [];
+}
+function emptyRuntimeSnapshot() {
+  return {
+    status: "idle",
+    active_turn_id: null,
+    active_turn_ids: [],
+    active_client_input_id: null,
+    active_client_turn_id: null,
+    last_event_seq: 0
+  };
+}
+function markRuntimeIdle(runtime) {
+  return {
+    ...runtime ?? emptyRuntimeSnapshot(),
+    status: "idle",
+    active_turn_id: null,
+    active_turn_ids: [],
+    active_client_input_id: null,
+    active_client_turn_id: null
+  };
+}
+function statusFromRuntime(runtime) {
+  if (runtime?.status === "running") return "Thinking";
+  if (runtime?.status === "stopping") return "Stopping";
+  return "Ready";
+}
 function setProgress(progressByTurnId, progress) {
   return {
     ...progressByTurnId,
@@ -2314,8 +2692,8 @@ function useCathyGOChat(initialState = initialChatState) {
     dispatchChat({ type: "session.created", sessionId });
   }, []);
   const loadSession = useCallback(
-    (sessionId, messages, activities) => {
-      dispatchChat({ type: "session.loaded", sessionId, messages, activities });
+    (sessionId, messages, activities, runtime) => {
+      dispatchChat({ type: "session.loaded", sessionId, messages, activities, runtime });
     },
     []
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beanx/cathygo-web-core",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "files": [
     "dist"
@@ -16,7 +16,7 @@
     "./styles.css": "./dist/styles.css"
   },
   "dependencies": {
-    "@beanx/cathygo-protocol": "0.1.0",
+    "@beanx/cathygo-protocol": "0.1.2",
     "@streamdown/math": "^1.0.2",
     "katex": "^0.16.47",
     "streamdown": "^2.5.0"