@newheap/platform-ai-chat 0.4.0 → 0.6.0

package/fesm2022/newheap-platform-ai-chat-testing.mjs

@@ -1,6 +1,7 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, signal, Injectable, makeEnvironmentProviders } from '@angular/core';
-import { NH_ASSISTANT_CONFIG, normalizeNhAssistantClientContext, applyNhAssistantApprovalDecision, applyNhAssistantEvent, NH_ASSISTANT_FETCH } from '@newheap/platform-ai-chat';
+import { InjectionToken, inject, signal, Injectable, DestroyRef, makeEnvironmentProviders } from '@angular/core';
+import { NH_ASSISTANT_CONFIG, applyNhAssistantEvent, normalizeNhAssistantClientContext, applyNhAssistantApprovalDecision, NH_ASSISTANT_FETCH, NhAssistantLiveService } from '@newheap/platform-ai-chat';
+import { Subject } from 'rxjs';
 
 const dashCase = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const styles = ['default', 'direct', 'personal', 'detailed'];
@@ -484,7 +485,10 @@ function hashText(text) {
 }
 
 const NH_ASSISTANT_MOCK_SCENARIO = new InjectionToken('NH_ASSISTANT_MOCK_SCENARIO');
+/** Path the mock reports as hub; the mock live service answers it in memory. */
+const NH_ASSISTANT_MOCK_HUB_PATH = '/hub/assistant-mock';
 const defaultLimits = { maxMessageChars: 4_000, maxToolCallsPerTurn: 8 };
+const defaultUser = { actorId: 'mock-user', displayName: 'You' };
 class RunStopped extends Error {
 }
 /**
@@ -504,11 +508,20 @@ class NhAssistantMockBackend {
         this.enabledState = signal(this.scenario.enabled ?? true, ...(ngDevMode ? [{ debugName: "enabledState" }] : []));
         this.admin = new NhAssistantMockAdmin(this.scenario, () => new Date().toISOString());
         this.canAdministerState = signal(this.admin.administers, ...(ngDevMode ? [{ debugName: "canAdministerState" }] : []));
+        this.currentUser = this.scenario.collaboration?.currentUser ?? defaultUser;
+        this.members = new Map();
+        this.readPositions = new Map();
+        this.shareTokens = new Map();
+        this.activeActors = new Map();
+        this.liveSubject = new Subject();
+        this.pushEnabled = true;
         this.sequence = 0;
         /** Requests received so far, oldest first. */
         this.requests = [];
         this.enabled = this.enabledState.asReadonly();
         this.canAdminister = this.canAdministerState.asReadonly();
+        /** Live updates for the mock live service, in the order the hub would send them. */
+        this.live$ = this.liveSubject.asObservable();
         /** A `fetch` implementation that answers the assistant endpoints below `apiBaseUrl`. */
         this.fetch = async (input, init) => {
             const method = (init.method ?? 'GET').toUpperCase();
@@ -526,9 +539,49 @@ class NhAssistantMockBackend {
             return this.route(method, path, url.searchParams, body);
         };
         for (const conversation of this.scenario.conversations ?? []) {
-            this.conversations.set(conversation.id, structuredClone(conversation));
+            const copy = withSequences(structuredClone(conversation));
+            this.conversations.set(copy.id, copy);
+            this.readPositions.set(copy.id, lastSequence(copy));
         }
     }
+    /**
+     * Plays a scripted turn as another person in the conversation, as if a colleague with an
+     * invitation sent a message: the conversation becomes shared, and the message and the
+     * answer arrive as live updates. Resolves when the turn ends.
+     */
+    async simulateParticipantTurn(conversationId, person, text) {
+        const conversation = this.conversations.get(conversationId);
+        if (!conversation || conversation.status !== 'idle') {
+            return;
+        }
+        this.addMember(conversationId, person, 'participant');
+        const userMessage = {
+            id: this.nextId(),
+            role: 'user',
+            createdAt: new Date().toISOString(),
+            parts: [{ type: 'text', text }],
+            authorActorId: person.actorId
+        };
+        this.activeActors.set(conversationId, person.actorId);
+        this.update(conversationId, current => ({ ...current, status: 'running', messages: [...current.messages, userMessage] }));
+        const stored = this.conversations.get(conversationId).messages.find(message => message.id === userMessage.id);
+        this.emitLive({ kind: 'event', data: { conversationId, actorId: person.actorId, type: 'message.created', data: stored } });
+        const timing = this.scenario.timing ?? {};
+        const assistantMessageId = this.nextId();
+        const emit = async (event) => {
+            await delay(timing.eventDelayMs ?? 40);
+            this.update(conversationId, current => applyNhAssistantEvent(current, event));
+            if (event.type === 'turn.completed' && event.data.status !== 'waiting-for-approval') {
+                this.activeActors.delete(conversationId);
+                this.emitChanged(conversationId);
+            }
+            this.emitLive({ kind: 'event', data: { conversationId, actorId: person.actorId, type: event.type, data: event.data } });
+        };
+        await delay(timing.firstEventDelayMs ?? 200);
+        await emit({ type: 'turn.started', data: { turnId: this.nextId(), userMessageId: userMessage.id, assistantMessageId } });
+        const turn = this.findTurn(text, conversation.agentId, null);
+        await this.playSteps(conversationId, assistantMessageId, turn?.steps ?? [], emit);
+    }
     /** Switches the simulated `NewHeap:AI:Assistant:Enabled` flag. */
     setEnabled(enabled) {
         this.enabledState.set(enabled);
@@ -546,8 +599,14 @@ class NhAssistantMockBackend {
         const segments = path.split('/').map(segment => decodeURIComponent(segment));
         if (method === 'GET' && path === 'status') {
             const limits = { ...defaultLimits, ...this.scenario.limits };
+            const collaboration = {
+                directory: (this.scenario.collaboration?.directory?.length ?? 0) > 0,
+                hubPath: NH_ASSISTANT_MOCK_HUB_PATH,
+                push: false,
+                maxParticipants: this.maxParticipants()
+            };
             return this.json(200, this.enabledState()
-                ? { enabled: true, agents: this.admin.chatAgents(), limits, canAdminister: this.admin.administers }
+                ? { enabled: true, agents: this.admin.chatAgents(), limits, canAdminister: this.admin.administers, collaboration }
                 : { enabled: false, agents: [], limits, canAdminister: false });
         }
         if (!this.enabledState()) {
@@ -559,6 +618,15 @@ class NhAssistantMockBackend {
         if (path === 'preferences') {
             return this.result(this.admin.handlePreferences(method, body));
         }
+        if (path === 'notifications') {
+            if (method === 'PUT') {
+                this.pushEnabled = body?.pushEnabled === true;
+            }
+            return this.json(200, { pushEnabled: this.pushEnabled, pushAvailable: false, publicKey: null });
+        }
+        if (path === 'notifications/push-subscription') {
+            return this.error(404, 'assistant-push-unavailable');
+        }
         if (segments[0] === 'admin') {
             return this.result(this.admin.handleAdmin(method, segments, body));
         }
@@ -580,15 +648,46 @@ class NhAssistantMockBackend {
         }
         if (segments.length === 2) {
             if (method === 'GET') {
-                return this.json(200, conversation);
+                return this.json(200, this.view(conversation));
             }
             if (method === 'DELETE') {
                 this.conversations.delete(conversation.id);
                 this.pendingApprovals.delete(conversation.id);
+                this.emitLive({ kind: 'removed', data: { conversationId: conversation.id } });
                 return this.empty(204);
             }
             return this.empty(405);
         }
+        if (method === 'POST' && segments.length === 3 && segments[2] === 'read') {
+            return this.markRead(conversation, body?.sequence);
+        }
+        if (segments.length === 3 && segments[2] === 'share-link') {
+            if (method === 'POST') {
+                const token = this.nextId().replace(/-/g, '');
+                this.shareTokens.set(conversation.id, token);
+                return this.json(200, { token });
+            }
+            if (method === 'DELETE') {
+                this.shareTokens.delete(conversation.id);
+                return this.empty(204);
+            }
+        }
+        if (method === 'POST' && segments.length === 3 && segments[2] === 'join') {
+            const token = body?.token;
+            return token && this.shareTokens.get(conversation.id) === token
+                ? this.json(200, this.view(conversation))
+                : this.error(404, 'assistant-share-link-invalid');
+        }
+        if (method === 'GET' && segments.length === 3 && segments[2] === 'participant-candidates') {
+            return this.candidates(conversation, query.get('query') ?? '');
+        }
+        if (method === 'POST' && segments.length === 3 && segments[2] === 'participants') {
+            return this.invite(conversation, body?.actorId);
+        }
+        if (method === 'DELETE' && segments.length === 4 && segments[2] === 'participants') {
+            const removed = this.removeMember(conversation.id, segments[3]);
+            return removed ? this.empty(204) : this.error(404, 'assistant-participant-not-found');
+        }
         if (method === 'POST' && segments.length === 3 && segments[2] === 'messages') {
             return this.sendMessage(conversation, body);
         }
@@ -605,7 +704,7 @@ class NhAssistantMockBackend {
         const itemsPerPage = Math.max(1, Number(query.get('itemsPerPage') ?? 20));
         const all = [...this.conversations.values()]
             .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
-            .map(({ id, agentId, title, status, createdAt, updatedAt }) => ({ id, agentId, title, status, createdAt, updatedAt }));
+            .map(conversation => this.summary(conversation));
         return { items: all.slice((page - 1) * itemsPerPage, page * itemsPerPage), total: all.length };
     }
     create(request) {
@@ -626,7 +725,8 @@ class NhAssistantMockBackend {
             pendingApproval: null
         };
         this.conversations.set(conversation.id, conversation);
-        return this.json(201, conversation);
+        this.readPositions.set(conversation.id, 0);
+        return this.json(201, this.view(conversation));
     }
     sendMessage(conversation, request) {
         const text = request?.text?.trim() ?? '';
@@ -643,12 +743,18 @@ class NhAssistantMockBackend {
         const turn = this.findTurn(text, conversation.agentId, pageContext);
         const userMessageId = this.nextId();
         const assistantMessageId = this.nextId();
+        this.activeActors.set(conversation.id, this.currentUser.actorId);
         this.update(conversation.id, current => ({
             ...current,
             title: current.title ?? text.slice(0, 60),
             status: 'running',
-            messages: [...current.messages, { id: userMessageId, role: 'user', createdAt: new Date().toISOString(), parts: [{ type: 'text', text }] }]
+            messages: [
+                ...current.messages,
+                { id: userMessageId, role: 'user', createdAt: new Date().toISOString(), parts: [{ type: 'text', text }], authorActorId: this.currentUser.actorId }
+            ]
         }));
+        // The sender has read their own message.
+        this.readPositions.set(conversation.id, lastSequence(this.conversations.get(conversation.id)));
         return this.stream(conversation.id, async (emit) => {
             await emit({ type: 'turn.started', data: { turnId: this.nextId(), userMessageId, assistantMessageId } });
             await this.playSteps(conversation.id, assistantMessageId, turn?.steps ?? [], emit);
@@ -659,6 +765,10 @@ class NhAssistantMockBackend {
         if (!pending || pending.approval.approvalId !== approvalId) {
             return this.empty(404);
         }
+        const decider = this.activeActors.get(conversation.id);
+        if (decider && decider !== this.currentUser.actorId) {
+            return this.error(403, 'assistant-approval-forbidden');
+        }
         if (request?.expectedProposalHash !== pending.approval.proposalHash) {
             return this.empty(409);
         }
@@ -857,10 +967,133 @@ class NhAssistantMockBackend {
     }
     update(conversationId, change) {
         const conversation = this.conversations.get(conversationId);
-        if (conversation) {
-            this.conversations.set(conversationId, { ...change(conversation), updatedAt: new Date().toISOString() });
+        if (!conversation) {
+            return;
+        }
+        const updated = withSequences({ ...change(conversation), updatedAt: new Date().toISOString() });
+        if (updated.status !== 'running' && updated.status !== 'waiting-for-approval') {
+            this.activeActors.delete(conversationId);
+        }
+        this.conversations.set(conversationId, updated);
+        if (updated.status !== conversation.status || updated.title !== conversation.title) {
+            this.emitChanged(conversationId);
         }
     }
+    /** The conversation as the signed-in user sees it. */
+    view(conversation) {
+        const members = this.members.get(conversation.id) ?? [];
+        return {
+            ...conversation,
+            ...this.summary(conversation),
+            members,
+            shareToken: this.shareTokens.get(conversation.id) ?? null,
+            currentActorId: this.currentUser.actorId
+        };
+    }
+    summary(conversation) {
+        const latest = lastSequence(conversation);
+        const members = this.members.get(conversation.id) ?? [];
+        return {
+            id: conversation.id,
+            agentId: conversation.agentId,
+            title: conversation.title,
+            status: conversation.status,
+            createdAt: conversation.createdAt,
+            updatedAt: conversation.updatedAt,
+            role: 'owner',
+            participantCount: Math.max(0, members.length - 1),
+            lastMessageSequence: latest,
+            lastReadSequence: Math.min(this.readPositions.get(conversation.id) ?? latest, latest),
+            activeActorId: this.activeActors.get(conversation.id) ?? null
+        };
+    }
+    markRead(conversation, sequence) {
+        const latest = lastSequence(conversation);
+        const target = Math.min(sequence ?? latest, latest);
+        if (target > (this.readPositions.get(conversation.id) ?? 0)) {
+            this.readPositions.set(conversation.id, target);
+            this.emitLive({ kind: 'read', data: { conversationId: conversation.id, lastReadSequence: target } });
+        }
+        return this.empty(204);
+    }
+    candidates(conversation, query) {
+        const directory = this.scenario.collaboration?.directory ?? [];
+        if (directory.length === 0) {
+            return this.error(404, 'assistant-directory-unavailable');
+        }
+        const text = query.trim().toLowerCase();
+        if (text.length < 2) {
+            return this.error(400, 'assistant-validation');
+        }
+        const members = new Set((this.members.get(conversation.id) ?? []).map(member => member.actorId));
+        return this.json(200, directory
+            .filter(person => person.actorId !== this.currentUser.actorId && !members.has(person.actorId))
+            .filter(person => person.displayName.toLowerCase().includes(text))
+            .map(person => ({ actorId: person.actorId, displayName: person.displayName, detail: person.detail ?? null })));
+    }
+    invite(conversation, actorId) {
+        const person = (this.scenario.collaboration?.directory ?? []).find(item => item.actorId === actorId);
+        if (!person) {
+            return this.error(404, 'assistant-participant-not-found');
+        }
+        const participants = (this.members.get(conversation.id) ?? []).filter(member => member.role === 'participant');
+        if (participants.length >= this.maxParticipants()) {
+            return this.error(409, 'assistant-participant-limit-reached');
+        }
+        this.addMember(conversation.id, person, 'participant');
+        return this.empty(204);
+    }
+    addMember(conversationId, person, role) {
+        const members = this.members.get(conversationId) ?? [];
+        if (members.some(member => member.actorId === person.actorId)) {
+            return;
+        }
+        const joinedAt = new Date().toISOString();
+        const owner = members.length === 0
+            ? [{ actorId: this.currentUser.actorId, displayName: this.currentUser.displayName, role: 'owner', joinedAt }]
+            : [];
+        this.members.set(conversationId, [...members, ...owner, { actorId: person.actorId, displayName: person.displayName, role, joinedAt }]);
+        this.emitChanged(conversationId);
+    }
+    removeMember(conversationId, actorId) {
+        const members = this.members.get(conversationId) ?? [];
+        if (!members.some(member => member.actorId === actorId && member.role === 'participant')) {
+            return false;
+        }
+        const remaining = members.filter(member => member.actorId !== actorId);
+        this.members.set(conversationId, remaining.length > 1 ? remaining : []);
+        this.emitChanged(conversationId);
+        return true;
+    }
+    emitChanged(conversationId) {
+        const conversation = this.conversations.get(conversationId);
+        if (!conversation) {
+            return;
+        }
+        const summary = this.summary(conversation);
+        this.emitLive({
+            kind: 'changed',
+            data: {
+                conversationId,
+                status: summary.status,
+                title: summary.title,
+                updatedAt: summary.updatedAt,
+                activeActorId: summary.activeActorId ?? null,
+                lastMessageSequence: summary.lastMessageSequence ?? 0,
+                participantCount: summary.participantCount ?? 0
+            }
+        });
+    }
+    emitLive(message) {
+        // Delivered after the current request, as a hub message would arrive.
+        queueMicrotask(() => this.liveSubject.next(message));
+    }
+    maxParticipants() {
+        return this.scenario.collaboration?.maxParticipants ?? 20;
+    }
+    error(status, code) {
+        return this.json(status, { code, messageKey: `nh-assistant.errors.${code}` });
+    }
     nextId() {
         this.sequence++;
         const suffix = this.sequence.toString(16).padStart(12, '0');
@@ -875,28 +1108,100 @@ class NhAssistantMockBackend {
     empty(status) {
         return new Response(null, { status });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: NhAssistantMockBackend, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: NhAssistantMockBackend }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.33", ngImport: i0, type: NhAssistantMockBackend, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.33", ngImport: i0, type: NhAssistantMockBackend }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: NhAssistantMockBackend, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.33", ngImport: i0, type: NhAssistantMockBackend, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 function delay(milliseconds) {
     return new Promise(resolve => setTimeout(resolve, milliseconds));
 }
+/** Numbers messages in order, as the server does, keeping numbers that are already set. */
+function withSequences(conversation) {
+    let next = lastSequence(conversation);
+    if (conversation.messages.every(message => message.sequence !== undefined)) {
+        return conversation;
+    }
+    return {
+        ...conversation,
+        messages: conversation.messages.map(message => message.sequence === undefined ? { ...message, sequence: ++next } : message)
+    };
+}
+function lastSequence(conversation) {
+    return conversation.messages.reduce((maximum, message) => Math.max(maximum, message.sequence ?? 0), 0);
+}
+
+/**
+ * Stands in for the SignalR live service: it delivers the mock back-end's live updates in
+ * memory, so shared conversations, other tabs and parallel turns behave as with a real hub.
+ */
+class NhAssistantMockLiveService {
+    constructor() {
+        this.backend = inject(NhAssistantMockBackend);
+        this.changedSubject = new Subject();
+        this.readSubject = new Subject();
+        this.removedSubject = new Subject();
+        this.eventSubject = new Subject();
+        this.resyncSubject = new Subject();
+        this.stateSignal = signal('off', ...(ngDevMode ? [{ debugName: "stateSignal" }] : []));
+        this.changed$ = this.changedSubject.asObservable();
+        this.read$ = this.readSubject.asObservable();
+        this.removed$ = this.removedSubject.asObservable();
+        this.events$ = this.eventSubject.asObservable();
+        this.resync$ = this.resyncSubject.asObservable();
+        this.state = this.stateSignal.asReadonly();
+        inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
+    }
+    async connect(hubPath) {
+        await this.stop();
+        if (!hubPath) {
+            return;
+        }
+        this.subscription = this.backend.live$.subscribe(message => {
+            switch (message.kind) {
+                case 'changed':
+                    this.changedSubject.next(message.data);
+                    break;
+                case 'read':
+                    this.readSubject.next(message.data);
+                    break;
+                case 'removed':
+                    this.removedSubject.next(message.data);
+                    break;
+                case 'event':
+                    this.eventSubject.next(message.data);
+                    break;
+            }
+        });
+        this.stateSignal.set('connected');
+        this.resyncSubject.next();
+    }
+    async stop() {
+        this.subscription?.unsubscribe();
+        this.subscription = undefined;
+        this.stateSignal.set('off');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.33", ngImport: i0, type: NhAssistantMockLiveService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.33", ngImport: i0, type: NhAssistantMockLiveService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.33", ngImport: i0, type: NhAssistantMockLiveService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
 
 /**
  * Replaces the assistant transport with an in-memory back-end that plays `script`.
  * Register it after `provideNhAssistant(...)` in the same injector. Every client feature
- * (status, agents, conversations, streamed turns, approvals, cancellation) then works
- * without a server. Inject `NhAssistantMockBackend` to switch the feature flag or to
- * inspect the received requests.
+ * (status, agents, conversations, streamed turns, approvals, cancellation, sharing, read
+ * state and live updates) then works without a server. Inject `NhAssistantMockBackend` to
+ * switch the feature flag, simulate a colleague or inspect the received requests.
  */
 function provideNhAssistantMockApi(script) {
     return makeEnvironmentProviders([
         { provide: NH_ASSISTANT_MOCK_SCENARIO, useValue: script },
         NhAssistantMockBackend,
-        { provide: NH_ASSISTANT_FETCH, useFactory: () => inject(NhAssistantMockBackend).fetch }
+        { provide: NH_ASSISTANT_FETCH, useFactory: () => inject(NhAssistantMockBackend).fetch },
+        { provide: NhAssistantLiveService, useClass: NhAssistantMockLiveService }
     ]);
 }
 
@@ -908,5 +1213,5 @@ function provideNhAssistantMockApi(script) {
  * Generated bundle index. Do not edit.
  */
 
-export { NH_ASSISTANT_MOCK_SCENARIO, NhAssistantMockBackend, provideNhAssistantMockApi };
+export { NH_ASSISTANT_MOCK_HUB_PATH, NH_ASSISTANT_MOCK_SCENARIO, NhAssistantMockBackend, NhAssistantMockLiveService, provideNhAssistantMockApi };
 //# sourceMappingURL=newheap-platform-ai-chat-testing.mjs.map