@aleph-alpha/chat-kit 1.1.0 → 1.2.0

package/dist/{useConversations-Ca242D2P.js → useConversationSessions-ulFhtpQr.js}

@@ -1,5 +1,6 @@
-import { g as generateId } from "./generateId-BHf0W4Rq.js";
+import { g as generateId, u as useMessageHandler } from "./useMessageHandler-BmBdu2EW.js";
 import { ref, shallowRef, computed, readonly } from "vue";
+import "./purify.es-md74IFlY.js";
 function secondsToDate(seconds) {
   return new Date(seconds * 1e3);
 }
@@ -189,7 +190,54 @@ function makePlaceholder(title) {
     updatedAt: now
   };
 }
+function useConversationSessions() {
+  const sessions = /* @__PURE__ */ new Map();
+  const focusedId = ref(null);
+  function createSession(conversationId) {
+    const existing = sessions.get(conversationId);
+    if (existing) return existing;
+    const session = {
+      id: conversationId,
+      messageHandler: useMessageHandler()
+    };
+    sessions.set(conversationId, session);
+    return session;
+  }
+  function getSession(conversationId) {
+    return sessions.get(conversationId);
+  }
+  function setActiveConversation(conversationId) {
+    if (conversationId === null) {
+      focusedId.value = null;
+      return;
+    }
+    createSession(conversationId);
+    focusedId.value = conversationId;
+  }
+  function removeSession(conversationId) {
+    sessions.delete(conversationId);
+    if (focusedId.value === conversationId) {
+      focusedId.value = null;
+    }
+  }
+  const activeSession = computed(() => {
+    const id = focusedId.value;
+    return id !== null ? sessions.get(id) ?? null : null;
+  });
+  const messageHandler = computed(
+    () => activeSession.value?.messageHandler ?? null
+  );
+  return {
+    activeSession,
+    messageHandler,
+    createSession,
+    getSession,
+    setActiveConversation,
+    removeSession
+  };
+}
 export {
-  useConversations as a,
+  useConversationSessions as a,
+  useConversations as b,
   useChat as u
 };

package/dist/{useMessageHandler-uLHNac39.js → useMessageHandler-BmBdu2EW.js}

@@ -1,4 +1,3 @@
-import { g as generateId } from "./generateId-BHf0W4Rq.js";
 import { reactive, ref, computed, readonly } from "vue";
 function createEmptyTree() {
   return { nodes: {}, rootId: null };
@@ -78,6 +77,9 @@ function navigate(tree, targetId) {
   if (idx === -1) return;
   parent.activeChildIndex = idx;
 }
+function generateId() {
+  return typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : String(Date.now());
+}
 const useMessageHandler = () => {
   const tree = reactive(createEmptyTree());
   const currentUserMessage = ref("");
@@ -178,5 +180,6 @@ const useMessageHandler = () => {
   };
 };
 export {
+  generateId as g,
   useMessageHandler as u
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aleph-alpha/chat-kit",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Chat kit package for building chat interfaces with Vue",
   "type": "module",
   "main": "./dist/index.js",

package/src/composables/index.ts

@@ -6,4 +6,10 @@ export type {
   UseConversationsOptions,
   UseConversationsReturn,
 } from './useConversations';
+export { useConversationSessions } from './useConversationSessions';
+export type {
+  ConversationSession,
+  MessageHandler,
+  UseConversationSessionsReturn,
+} from './useConversationSessions';
 export type { ChatActions, ChatState, UseChatReturn } from './types';

package/src/composables/useConversationSessions.spec.ts

@@ -0,0 +1,86 @@
+import { nextTick } from 'vue';
+import { useConversationSessions } from './useConversationSessions';
+
+describe('useConversationSessions', () => {
+  it('starts with no active session', () => {
+    const sessions = useConversationSessions();
+
+    expect(sessions.activeSession.value).toBeNull();
+    expect(sessions.messageHandler.value).toBeNull();
+    expect(sessions.messageHandler.value?.messages.value ?? []).toEqual([]);
+  });
+
+  it('createSession is idempotent', () => {
+    const sessions = useConversationSessions();
+    const a = sessions.createSession('c1');
+    const b = sessions.createSession('c1');
+
+    expect(a).toBe(b);
+    expect(sessions.getSession('c1')).toBe(a);
+  });
+
+  it('isolates message trees per session', () => {
+    const sessions = useConversationSessions();
+    const sa = sessions.createSession('a');
+    const sb = sessions.createSession('b');
+
+    expect(sa.messageHandler).not.toBe(sb.messageHandler);
+
+    sa.messageHandler.setCurrentUserMessage('from A');
+    sa.messageHandler.commitUserMessage();
+
+    expect(sa.messageHandler.messages.value).toHaveLength(1);
+    expect(sb.messageHandler.messages.value).toHaveLength(0);
+  });
+
+  it('activeSession tracks the focused conversation handler', async () => {
+    const sessions = useConversationSessions();
+    sessions.createSession('a');
+    sessions.createSession('b');
+    sessions.setActiveConversation('a');
+
+    sessions.activeSession.value?.messageHandler.setCurrentUserMessage('hi');
+    sessions.activeSession.value?.messageHandler.commitUserMessage();
+
+    expect(
+      sessions.activeSession.value?.messageHandler.messages.value,
+    ).toHaveLength(1);
+    expect(
+      sessions.getSession('b')?.messageHandler.messages.value,
+    ).toHaveLength(0);
+
+    sessions.setActiveConversation('b');
+    await nextTick();
+
+    expect(sessions.messageHandler.value).toBe(
+      sessions.getSession('b')?.messageHandler,
+    );
+    expect(sessions.messageHandler.value?.messages.value).toHaveLength(0);
+  });
+
+  it('updating a background session does not change the focused handler messages', async () => {
+    const sessions = useConversationSessions();
+    const sa = sessions.createSession('a');
+    sessions.createSession('b');
+    sessions.setActiveConversation('b');
+
+    sa.messageHandler.setCurrentUserMessage('background');
+    sa.messageHandler.commitUserMessage();
+
+    await nextTick();
+    expect(sessions.messageHandler.value?.messages.value ?? []).toEqual([]);
+    expect(sa.messageHandler.messages.value).toHaveLength(1);
+  });
+
+  it('removeSession clears focus when that session was active', () => {
+    const sessions = useConversationSessions();
+    sessions.createSession('x');
+    sessions.setActiveConversation('x');
+
+    sessions.removeSession('x');
+
+    expect(sessions.getSession('x')).toBeUndefined();
+    expect(sessions.activeSession.value).toBeNull();
+    expect(sessions.messageHandler.value).toBeNull();
+  });
+});

package/src/composables/useConversationSessions.ts

@@ -0,0 +1,85 @@
+import { useMessageHandler } from '../handlers';
+import { computed, ref, type ComputedRef, type Ref } from 'vue';
+
+export type MessageHandler = ReturnType<typeof useMessageHandler>;
+
+/** One conversation’s runtime message tree (`useMessageHandler` per id). */
+export interface ConversationSession {
+  readonly id: string;
+  readonly messageHandler: MessageHandler;
+}
+
+/**
+ * Per-conversation `useMessageHandler` instances; `setActiveConversation` picks
+ * which session is exposed as `activeSession` / `messageHandler`.
+ */
+export interface UseConversationSessionsReturn {
+  /** Focused session, or `null`. */
+  activeSession: ComputedRef<ConversationSession | null>;
+  /** `activeSession?.messageHandler`, or `null`. */
+  messageHandler: ComputedRef<MessageHandler | null>;
+  /** Get or create a session for `conversationId` (idempotent). */
+  createSession: (conversationId: string) => ConversationSession;
+  /** Session if it exists; does not create. */
+  getSession: (conversationId: string) => ConversationSession | undefined;
+  /** Focus `conversationId` (creates session if needed), or `null` to unfocus. */
+  setActiveConversation: (conversationId: string | null) => void;
+  /** Remove session; clears focus if it was active. */
+  removeSession: (conversationId: string) => void;
+}
+
+/** Registry of sessions by id (plain `Map` so nested refs stay valid). */
+export function useConversationSessions(): UseConversationSessionsReturn {
+  const sessions = new Map<string, ConversationSession>();
+  const focusedId: Ref<string | null> = ref(null);
+
+  function createSession(conversationId: string): ConversationSession {
+    const existing = sessions.get(conversationId);
+    if (existing) return existing;
+
+    const session: ConversationSession = {
+      id: conversationId,
+      messageHandler: useMessageHandler(),
+    };
+    sessions.set(conversationId, session);
+    return session;
+  }
+
+  function getSession(conversationId: string): ConversationSession | undefined {
+    return sessions.get(conversationId);
+  }
+
+  function setActiveConversation(conversationId: string | null): void {
+    if (conversationId === null) {
+      focusedId.value = null;
+      return;
+    }
+    createSession(conversationId);
+    focusedId.value = conversationId;
+  }
+
+  function removeSession(conversationId: string): void {
+    sessions.delete(conversationId);
+    if (focusedId.value === conversationId) {
+      focusedId.value = null;
+    }
+  }
+
+  const activeSession = computed<ConversationSession | null>(() => {
+    const id = focusedId.value;
+    return id !== null ? (sessions.get(id) ?? null) : null;
+  });
+
+  const messageHandler = computed<MessageHandler | null>(
+    () => activeSession.value?.messageHandler ?? null,
+  );
+
+  return {
+    activeSession,
+    messageHandler,
+    createSession,
+    getSession,
+    setActiveConversation,
+    removeSession,
+  };
+}

package/src/index.ts

@@ -24,13 +24,20 @@ export {
 export type { ChatKitLabels } from './handlers';
 
 // Composables
-export { useChat, useConversations } from './composables';
+export {
+  useChat,
+  useConversationSessions,
+  useConversations,
+} from './composables';
 export type {
   ChatActions,
   ChatState,
+  ConversationSession,
   CreateConversationInput,
+  MessageHandler,
   MutationOptions,
   UseChatReturn,
+  UseConversationSessionsReturn,
   UseConversationsOptions,
   UseConversationsReturn,
 } from './composables';

package/dist/generateId-BHf0W4Rq.js

@@ -1,6 +0,0 @@
-function generateId() {
-  return typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : String(Date.now());
-}
-export {
-  generateId as g
-};