@newheap/platform-ai-chat 0.5.0 → 0.6.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@newheap/platform-ai-chat",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "peerDependencies": {
     "@angular/cdk": "^20.2.14",
     "@angular/common": "^20.3.28",
     "@angular/core": "^20.3.28",
     "@angular/router": "^20.3.28",
+    "@microsoft/signalr": "^10.0.11",
     "@ngx-translate/core": "^17.0.0",
     "dompurify": "^3.4.0",
     "marked": "^18.0.0",
@@ -19,6 +20,9 @@
     "./i18n/*.json": {
       "default": "./i18n/*.json"
     },
+    "./push/*": {
+      "default": "./push/*"
+    },
     "./package.json": {
       "default": "./package.json"
     },

package/push/nh-assistant-push-worker.js

@@ -0,0 +1,70 @@
+/*
+ * Web Push worker of @newheap/platform-ai-chat.
+ *
+ * Copy this file into the application's assets, for example to /nh-assistant/, and set
+ * `push.serviceWorkerUrl` in `provideNhAssistant`. The assistant registers it with its own
+ * scope, so it never controls pages and does not conflict with an application service worker.
+ *
+ * It shows a notification only when no window of the application is focused; otherwise it
+ * forwards the message to the open windows, which already show the conversation live. A click
+ * focuses an open window and opens the conversation there, or opens `app` with the conversation
+ * in the URL fragment. Notifications carry a conversation id and short texts only.
+ */
+const settings = new URL(self.location.href).searchParams;
+const appUrl = settings.get('app') || '/';
+const iconUrl = settings.get('icon') || undefined;
+
+self.addEventListener('install', () => self.skipWaiting());
+self.addEventListener('activate', event => event.waitUntil(self.clients.claim()));
+
+self.addEventListener('push', event => {
+  let payload = null;
+  try {
+    payload = event.data ? event.data.json() : null;
+  } catch {
+    payload = null;
+  }
+  if (!payload || payload.type !== 'nh-assistant' || typeof payload.conversationId !== 'string') {
+    return;
+  }
+
+  event.waitUntil((async () => {
+    const windows = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
+    if (windows.some(client => client.focused && client.visibilityState === 'visible')) {
+      for (const client of windows) {
+        client.postMessage({ type: 'nh-assistant.push', kind: payload.kind, conversationId: payload.conversationId });
+      }
+      return;
+    }
+
+    await self.registration.showNotification(String(payload.title || ''), {
+      body: String(payload.body || ''),
+      tag: String(payload.tag || `nh-assistant:${payload.conversationId}`),
+      renotify: true,
+      icon: iconUrl,
+      data: { conversationId: payload.conversationId }
+    });
+  })());
+});
+
+self.addEventListener('notificationclick', event => {
+  event.notification.close();
+  const conversationId = event.notification.data && event.notification.data.conversationId;
+  if (typeof conversationId !== 'string') {
+    return;
+  }
+
+  event.waitUntil((async () => {
+    const windows = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
+    const target = windows.find(client => client.focused) || windows[0];
+    if (target) {
+      await target.focus();
+      target.postMessage({ type: 'nh-assistant.open-conversation', conversationId });
+      return;
+    }
+
+    const url = new URL(appUrl, self.location.origin);
+    url.hash = `nh-assistant-conversation=${encodeURIComponent(conversationId)}`;
+    await self.clients.openWindow(url.href);
+  })());
+});

package/testing/index.d.ts

@@ -1,6 +1,7 @@
-import { AssistantStatus, AgentSummary, Conversation, ClientContext, AssistantPreferences, ToolCatalogEntry, AdminAgentInput, McpServerInput } from '@newheap/platform-ai-chat';
-import * as _angular_core from '@angular/core';
+import { AssistantStatus, AgentSummary, Conversation, ClientContext, AssistantPreferences, ToolCatalogEntry, AdminAgentInput, McpServerInput, LiveConversationChanged, LiveConversationRead, LiveConversationRemoved, LiveConversationEvent, NhAssistantLiveService, NhAssistantLiveState } from '@newheap/platform-ai-chat';
+import * as i0 from '@angular/core';
 import { InjectionToken, EnvironmentProviders } from '@angular/core';
+import { Observable } from 'rxjs';
 
 /** Streams text as `message.delta` events, split into word-sized pieces. */
 interface NhAssistantMockTextStep {
@@ -112,6 +113,25 @@ interface NhAssistantMockAdminScenario {
     /** Hosts that may receive the user's token (`forward-user-token`). Default: none. */
     forwardUserTokenHosts?: string[];
 }
+/** A person in the simulated organization. */
+interface NhAssistantMockPerson {
+    actorId: string;
+    displayName: string;
+    /** Short distinguishing text the directory shows, such as a department. */
+    detail?: string;
+}
+/**
+ * Sharing, live updates and notifications of the mock. The mock always offers invitation links
+ * and live updates; with `directory` it also offers direct invitations.
+ */
+interface NhAssistantMockCollaboration {
+    /** The signed-in user. Default `{ actorId: 'mock-user', displayName: 'You' }`. */
+    currentUser?: NhAssistantMockPerson;
+    /** Colleagues the directory finds; enables direct invitations. */
+    directory?: NhAssistantMockPerson[];
+    /** Default 20. */
+    maxParticipants?: number;
+}
 /** The scenario the mock API plays without a back-end. */
 interface NhAssistantMockScenario {
     /** Default `true`. */
@@ -126,6 +146,7 @@ interface NhAssistantMockScenario {
     /** Stored preferences of the caller. Default: default style, informal, normal length. */
     preferences?: AssistantPreferences;
     admin?: NhAssistantMockAdminScenario;
+    collaboration?: NhAssistantMockCollaboration;
 }
 /** One request the mock API received, for assertions in tests. */
 interface NhAssistantMockRequest {
@@ -136,6 +157,22 @@ interface NhAssistantMockRequest {
 }
 
 declare const NH_ASSISTANT_MOCK_SCENARIO: InjectionToken<NhAssistantMockScenario>;
+/** Path the mock reports as hub; the mock live service answers it in memory. */
+declare const NH_ASSISTANT_MOCK_HUB_PATH = "/hub/assistant-mock";
+/** One live update of the mock, as the assistant hub would send it. */
+type NhAssistantMockLiveMessage = {
+    kind: 'changed';
+    data: LiveConversationChanged;
+} | {
+    kind: 'read';
+    data: LiveConversationRead;
+} | {
+    kind: 'removed';
+    data: LiveConversationRemoved;
+} | {
+    kind: 'event';
+    data: LiveConversationEvent;
+};
 /**
  * In-memory implementation of the assistant HTTP API and its event streams. It keeps
  * conversations, plays scripted turns as contract events through a real
@@ -152,12 +189,27 @@ declare class NhAssistantMockBackend {
     private readonly enabledState;
     private readonly admin;
     private readonly canAdministerState;
+    private readonly currentUser;
+    private readonly members;
+    private readonly readPositions;
+    private readonly shareTokens;
+    private readonly activeActors;
+    private readonly liveSubject;
+    private pushEnabled;
     private sequence;
     /** Requests received so far, oldest first. */
     readonly requests: NhAssistantMockRequest[];
-    readonly enabled: _angular_core.Signal<boolean>;
-    readonly canAdminister: _angular_core.Signal<boolean>;
+    readonly enabled: i0.Signal<boolean>;
+    readonly canAdminister: i0.Signal<boolean>;
+    /** Live updates for the mock live service, in the order the hub would send them. */
+    readonly live$: Observable<NhAssistantMockLiveMessage>;
     constructor();
+    /**
+     * 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.
+     */
+    simulateParticipantTurn(conversationId: string, person: NhAssistantMockPerson, text: string): Promise<void>;
     /** Switches the simulated `NewHeap:AI:Assistant:Enabled` flag. */
     setEnabled(enabled: boolean): void;
     /** Switches whether the caller passes the admin policy (`canAdminister`, `admin/*`). */
@@ -177,22 +229,61 @@ declare class NhAssistantMockBackend {
     private stream;
     private findTurn;
     private update;
+    /** The conversation as the signed-in user sees it. */
+    private view;
+    private summary;
+    private markRead;
+    private candidates;
+    private invite;
+    private addMember;
+    private removeMember;
+    private emitChanged;
+    private emitLive;
+    private maxParticipants;
+    private error;
     private nextId;
     private result;
     private json;
     private empty;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantMockBackend, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantMockBackend>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhAssistantMockBackend, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhAssistantMockBackend>;
+}
+
+type NhAssistantLiveSurface = Pick<NhAssistantLiveService, 'changed$' | 'read$' | 'removed$' | 'events$' | 'resync$' | 'state' | 'connect' | 'stop'>;
+/**
+ * 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.
+ */
+declare class NhAssistantMockLiveService implements NhAssistantLiveSurface {
+    private readonly backend;
+    private readonly changedSubject;
+    private readonly readSubject;
+    private readonly removedSubject;
+    private readonly eventSubject;
+    private readonly resyncSubject;
+    private readonly stateSignal;
+    private subscription?;
+    readonly changed$: Observable<LiveConversationChanged>;
+    readonly read$: Observable<LiveConversationRead>;
+    readonly removed$: Observable<LiveConversationRemoved>;
+    readonly events$: Observable<LiveConversationEvent>;
+    readonly resync$: Observable<void>;
+    readonly state: i0.Signal<NhAssistantLiveState>;
+    constructor();
+    connect(hubPath: string | null): Promise<void>;
+    stop(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NhAssistantMockLiveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NhAssistantMockLiveService>;
 }
 
 /**
  * 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.
  */
 declare function provideNhAssistantMockApi(script: NhAssistantMockScenario): EnvironmentProviders;
 
-export { NH_ASSISTANT_MOCK_SCENARIO, NhAssistantMockBackend, provideNhAssistantMockApi };
-export type { NhAssistantMockAdminAgent, NhAssistantMockAdminScenario, NhAssistantMockApprovalStep, NhAssistantMockErrorStep, NhAssistantMockFailStep, NhAssistantMockMcpServer, NhAssistantMockRemoteTool, NhAssistantMockRequest, NhAssistantMockScenario, NhAssistantMockStep, NhAssistantMockTextStep, NhAssistantMockTiming, NhAssistantMockToolStep, NhAssistantMockTurn };
+export { NH_ASSISTANT_MOCK_HUB_PATH, NH_ASSISTANT_MOCK_SCENARIO, NhAssistantMockBackend, NhAssistantMockLiveService, provideNhAssistantMockApi };
+export type { NhAssistantMockAdminAgent, NhAssistantMockAdminScenario, NhAssistantMockApprovalStep, NhAssistantMockCollaboration, NhAssistantMockErrorStep, NhAssistantMockFailStep, NhAssistantMockLiveMessage, NhAssistantMockMcpServer, NhAssistantMockPerson, NhAssistantMockRemoteTool, NhAssistantMockRequest, NhAssistantMockScenario, NhAssistantMockStep, NhAssistantMockTextStep, NhAssistantMockTiming, NhAssistantMockToolStep, NhAssistantMockTurn };