@kaltura-sdk/avatars 1.16.0 → 1.16.2

package/index.esm.js

@@ -6386,7 +6386,7 @@ const textCommunicationState = {
         }) => ({
           message: event.text
         })
-      }, 'appendUserTextEntry']
+      }, 'trackInternalAskEcho']
     }
   },
   states: {
@@ -20623,32 +20623,9 @@ const appendAvatarChatEntry = assign$1(({
   context,
   event
 }) => {
-  var _a, _b;
   assertEvent(event, AvatarConnectionMachineEventTypes.AvatarChatEntryReceived);
-  // The avatar's FINAL segment responding means the human phase for this
-  // turn is done - a pendingTextInput still anchored to this turnId (see
-  // appendUserChatEntry) has nothing left to merge into; clear it so the
-  // next askViaText starts a fresh entry instead of merging into a turn
-  // that's already been answered. A non-final segment (avatar-filler,
-  // spoken ahead of the main answer during a tool call) must NOT clear it
-  // - the real turn is still open server-side and more sends can still
-  // legitimately merge into it; closing early here caused a real bug: a
-  // later send got a fresh local entry, but the server's own confirmation
-  // for it still carried the still-open turn's turnId, landing two chat
-  // entries on the same id - every later merge (by id) then grew both.
-  //
-  // Compares against `turnId`, NOT `id` - a real capture showed the
-  // server can reuse the same turnId across multiple, already-answered
-  // exchanges (e.g. repeated ambiguous input like "="), so `id` alone is
-  // not a safe proxy for "this is the turn that's still open" once it's
-  // also being used as a collision-safe chatLog entry id (see
-  // on-chat-log.ts / appendUserChatEntry).
-  const isFinalSegment = (_a = event.isFinalSegment) !== null && _a !== void 0 ? _a : true;
-  const pendingTurnId = (_b = context.pendingTextInput) === null || _b === void 0 ? void 0 : _b.turnId;
-  const pendingTextInput = isFinalSegment && pendingTurnId != null && pendingTurnId === event.entry.turnId ? null : context.pendingTextInput;
   return {
-    chatLog: [...context.chatLog, event.entry],
-    pendingTextInput
+    chatLog: [...context.chatLog, event.entry]
   };
 });
 
@@ -20671,133 +20648,44 @@ const removeStaleChatEntriesForRetry = assign$1(({
   };
 });
 
+// Upserts by id - a resend superseding a still-open turn keeps that turn's
+// original entry id (see on-chat-log.ts openTurnEntryIds), so this replaces
+// the entry in place instead of duplicating it.
 const appendUserChatEntry = assign$1(({
   context,
   event
 }) => {
-  var _a;
   assertEvent(event, AvatarConnectionMachineEventTypes.UserVoiceTurnReceived);
-  const pending = context.pendingTextInput;
-  if (!pending) {
+  if (context.awaitingInternalAskEcho) {
+    // Invisible kickoff prompt's own echo - consume without surfacing it.
+    return {
+      awaitingInternalAskEcho: false
+    };
+  }
+  const existingIndex = context.chatLog.findIndex(entry => entry.id === event.entry.id);
+  if (existingIndex === -1) {
     return {
       chatLog: [...context.chatLog, event.entry]
     };
   }
-  // Only one send can be in flight at a time - appendUserTextEntry merges
-  // any further sends into it instead of starting a second one - so this
-  // turn is unambiguously that pending entry's confirmation. The server is
-  // authoritative for what actually gets saved as message history, so its
-  // entry always wins here, whether or not our locally-accumulated text
-  // happens to match it exactly.
-  const chatLog = pending.id ? context.chatLog.map(entry => entry.id === pending.id ? event.entry : entry) : [...context.chatLog, event.entry];
-  // Stay anchored to this turn via its now-confirmed id instead of
-  // clearing to null - the server re-sends this same "human" echo once per
-  // rapid send under one still-open turnId, each carrying the full
-  // cumulative text (see on-chat-log.ts), so a further send before the
-  // avatar responds must keep merging into this same entry. What actually
-  // closes this out is the avatar responding - see appendAvatarChatEntry.
-  // `turnId` is tracked alongside `id` (not derived from it) - a real
-  // capture showed the server can reuse the same turnId across multiple,
-  // already-answered exchanges, so `event.entry.id` must stay collision-safe
-  // (see on-chat-log.ts) while `turnId` is what appendAvatarChatEntry
-  // actually compares against to decide its turn just closed.
+  const chatLog = [...context.chatLog];
+  chatLog[existingIndex] = event.entry;
   return {
-    chatLog,
-    pendingTextInput: {
-      id: event.entry.id,
-      turnId: (_a = event.entry.turnId) !== null && _a !== void 0 ? _a : null,
-      text: event.entry.text
-    }
+    chatLog
   };
 });
 
-const appendUserTextEntry = assign$1(({
+// No optimistic entry for askViaText - chat log only reflects the server's
+// echoed `human` text (see on-chat-log.ts). The internal kickoff prompt
+// goes through that same echo, so its next one must be suppressed.
+const trackInternalAskEcho = assign$1(({
   context,
   event
 }) => {
   assertEvent(event, AvatarConnectionMachineEventTypes.AskViaText);
-  const {
-    text,
-    internal
-  } = event;
-  if (context.pendingTextInput) {
-    // A send while the previous turn is still open mirrors the server's
-    // own behavior: it merges rapid back-to-back input into one turn, so
-    // append into the same pending message instead of starting a new one.
-    // The server re-confirms this same turn once per send (see
-    // appendUserChatEntry) rather than clearing pendingTextInput, so
-    // further sends keep landing here until the avatar actually answers
-    // (see appendAvatarChatEntry, which is what closes it out) or the turn
-    // is interrupted.
-    const {
-      id,
-      turnId,
-      text: pendingText
-    } = context.pendingTextInput;
-    const mergedText = `${pendingText} ${text}`;
-    if (id) {
-      return {
-        pendingTextInput: {
-          id,
-          turnId,
-          text: mergedText
-        },
-        chatLog: context.chatLog.map(entry => entry.id === id ? Object.assign(Object.assign({}, entry), {
-          text: mergedText
-        }) : entry)
-      };
-    }
-    if (internal) {
-      // Still an internal-only accumulation - stays out of the chat log.
-      return {
-        pendingTextInput: {
-          id: null,
-          turnId: null,
-          text: mergedText
-        }
-      };
-    }
-    // The pending message so far was internal (invisible) but this
-    // follow-up isn't - it becomes visible now, under a fresh entry.
-    const _entry = {
-      id: crypto.randomUUID(),
-      role: 'user',
-      text: mergedText
-    };
-    return {
-      chatLog: [...context.chatLog, _entry],
-      pendingTextInput: {
-        id: _entry.id,
-        turnId: null,
-        text: mergedText
-      }
-    };
-  }
-  // raiseAskViaTextKickoff marks its auto-sent ask `internal` — it's a bootstrap prompt,
-  // not something the user said, so keep it out of the visible chat log. Still tracked
-  // in pendingTextInput so the server's turn echo is deduped the same way. No chatLog
-  // entry backs it, so `id: null`.
-  if (internal) {
-    return {
-      pendingTextInput: {
-        id: null,
-        turnId: null,
-        text
-      }
-    };
-  }
-  const entry = {
-    id: crypto.randomUUID(),
-    role: 'user',
-    text
-  };
+  if (!event.internal) return {};
   return {
-    chatLog: [...context.chatLog, entry],
-    pendingTextInput: {
-      id: entry.id,
-      turnId: null,
-      text
-    }
+    awaitingInternalAskEcho: true
   };
 });
 
@@ -20860,35 +20748,32 @@ const source$a = createTinyPubsubEventsSource(websocketMessage, {
 // Builds alternating user/avatar chat log from agent_raw_text, keyed by turnId.
 //
 // delta.type:
-//   - 'think' with `human` — user's turn text, one-shot on the bootstrap
-//     "preparing to answer..." segment (precedes the turn's avatar segments).
-//     No `human` field = real thinking tokens, ignored (like 'tool'/'share').
-//     Deduped per turnId:speechId. Entry id is that composite, not bare
-//     turnId — server can reuse one turnId across several already-answered
-//     exchanges (e.g. repeated "="), so speechId keeps entries from colliding.
+//   - 'think' with `human` — user's turn text. A resend while the turnId's
+//     exchange is still unanswered cancels it server-side with no signal to
+//     the client (conversation-manager's AgentAdapter.invalidateTask), gets
+//     its own real messageId, and supersedes it in place client-side via
+//     openTurnEntryIds below. A LATER, already-answered exchange reusing
+//     the same turnId is unrelated and gets a fresh entry instead.
 //   - 'avatar' / 'avatar-filler' — chat text, chunked by speechId, closed by
-//     segmentEnd=true. Filler is spoken content too (e.g. tool-call "let me
-//     check..." lines).
-//   - 'user-interruption' — turn aborted server-side (no literal 'abort'
-//     type exists). Flushes whatever partial avatar text accumulated and
-//     evicts that turnId:speechId buffer only.
+//     segmentEnd=true. Filler is spoken content too (tool-call ack lines).
+//   - 'user-interruption' — turn aborted server-side. Flushes accumulated
+//     avatar text and evicts that turnId:speechId buffer only.
 //
-// A retry reuses the same turnId under a new speechId; each speechId's
-// segmentEnd/user-interruption is tracked/flushed independently.
+// A retry reuses the turnId under a new speechId, tracked independently.
 //
-// Every entry carries `messageId` (parsed.messageId) — constant for every
-// segment of one exchange, unique across exchanges even when turnId repeats
-// (confirmed against kaltura_agent_executer.py). remove-stale-chat-entries-
-// for-retry.ts matches on it to drop exactly one exchange on retry.
+// `messageId` is constant per exchange, unique across exchanges even when
+// turnId repeats (confirmed against kaltura_agent_executer.py) —
+// remove-stale-chat-entries-for-retry.ts matches on it for retry cleanup.
+//
+// `speechId` is set on every entry too — unlike messageId, it stays constant
+// across a filler segment and its later tool-call answer, so group-chat-log.ts keys on it.
 //
 // Opening phrase (resumed thread, avatar speaks first): never sent as a
-// normal turnId-keyed segment. Server sends it via `init_response` (too
-// early — fires before this actor's setHandler(), so it's dropped by the
-// pubsub queue reset) and a mirrored `generatingSpeech` event, which we use
-// as the text source instead. `agentTurnToTalk` (userTranscription === '')
-// is the flush trigger — nothing else marks "greeting done, no real user
-// turn happened first". BLANK_TEXT_MARKER is the server's "no opening
-// phrase configured" sentinel, skipped.
+// normal turnId-keyed segment — `init_response` fires too early (before
+// this actor's setHandler(), dropped by the pubsub queue reset), so
+// `generatingSpeech` is the text source instead, flushed by
+// `agentTurnToTalk` (userTranscription === ''). BLANK_TEXT_MARKER is the
+// server's "no opening phrase configured" sentinel, skipped.
 const onChatLog = fromCallback(({
   input,
   sendBack
@@ -20896,8 +20781,10 @@ const onChatLog = fromCallback(({
   // Accumulate avatar text by `${turnId}:${speechId}` — each speechId
   // closes independently (e.g. a filler segment vs the main answer).
   const pending = new Map();
-  const seenHumanTurnKeys = new Set();
   let avatarEntrySequence = 0;
+  // turnId -> entry id of its current unanswered exchange - reused across
+  // superseding resends, cleared on a real answer (see top-of-file comment).
+  const openTurnEntryIds = new Map();
   const createAvatarEntryId = (messageId, speechId) => {
     avatarEntrySequence += 1;
     return `${messageId}:${speechId}:${avatarEntrySequence}`;
@@ -20911,7 +20798,7 @@ const onChatLog = fromCallback(({
     logger: input.logger,
     handlers: {
       agent_raw_text: payload => {
-        var _a, _b;
+        var _a, _b, _c;
         try {
           const delta = JSON.parse(payload.delta);
           const result = agentRawTextDeltaSchema.safeParse(delta);
@@ -20919,22 +20806,25 @@ const onChatLog = fromCallback(({
           const parsed = result.data;
           const key = `${payload.turnId}:${payload.speechId}`;
           if (parsed.type === 'think') {
-            if (parsed.human && !seenHumanTurnKeys.has(key)) {
-              seenHumanTurnKeys.add(key);
+            if (parsed.human) {
+              const id = (_a = openTurnEntryIds.get(payload.turnId)) !== null && _a !== void 0 ? _a : parsed.messageId;
+              openTurnEntryIds.set(payload.turnId, id);
               sendBack({
                 type: AvatarConnectionMachineEventTypes.UserVoiceTurnReceived,
                 entry: {
-                  id: key,
+                  id,
                   role: 'user',
                   text: parsed.human,
                   turnId: payload.turnId,
-                  messageId: parsed.messageId
+                  messageId: parsed.messageId,
+                  speechId: payload.speechId
                 }
               });
             }
             return;
           }
           if (parsed.type === 'user-interruption') {
+            openTurnEntryIds.delete(payload.turnId);
             const text = pending.get(key);
             pending.delete(key);
             if (text) {
@@ -20945,7 +20835,8 @@ const onChatLog = fromCallback(({
                   role: 'avatar',
                   text,
                   turnId: payload.turnId,
-                  messageId: parsed.messageId
+                  messageId: parsed.messageId,
+                  speechId: payload.speechId
                 }
               });
             }
@@ -20953,12 +20844,17 @@ const onChatLog = fromCallback(({
           }
           if (parsed.type !== 'avatar' && parsed.type !== 'avatar-filler') return;
           if (typeof parsed.content === 'string' && parsed.content) {
-            pending.set(key, ((_a = pending.get(key)) !== null && _a !== void 0 ? _a : '') + parsed.content);
+            pending.set(key, ((_b = pending.get(key)) !== null && _b !== void 0 ? _b : '') + parsed.content);
           }
           if (parsed.segmentEnd) {
-            const text = (_b = pending.get(key)) !== null && _b !== void 0 ? _b : '';
+            const text = (_c = pending.get(key)) !== null && _c !== void 0 ? _c : '';
             pending.delete(key);
             if (!text) return;
+            // Real answer closes the exchange - a later reuse of this
+            // turnId (e.g. repeated "=") must get a fresh entry, not this one.
+            if (parsed.type === 'avatar') {
+              openTurnEntryIds.delete(payload.turnId);
+            }
             sendBack({
               type: AvatarConnectionMachineEventTypes.AvatarChatEntryReceived,
               entry: {
@@ -20966,13 +20862,12 @@ const onChatLog = fromCallback(({
                 role: 'avatar',
                 text,
                 turnId: payload.turnId,
-                messageId: parsed.messageId
-              },
-              // Filler doesn't close an open pendingTextInput (see append-avatar-chat-entry.ts).
-              isFinalSegment: parsed.type !== 'avatar-filler'
+                messageId: parsed.messageId,
+                speechId: payload.speechId
+              }
             });
           }
-        } catch (_c) {
+        } catch (_d) {
           // invalid JSON delta — ignore
         }
       },
@@ -20997,7 +20892,8 @@ const onChatLog = fromCallback(({
             id: openingPhraseSpeechId !== null && openingPhraseSpeechId !== void 0 ? openingPhraseSpeechId : 'init_response',
             role: 'avatar',
             text: openingPhraseText,
-            turnId: 'init_response'
+            turnId: 'init_response',
+            speechId: openingPhraseSpeechId !== null && openingPhraseSpeechId !== void 0 ? openingPhraseSpeechId : undefined
           }
         });
       }
@@ -23323,7 +23219,7 @@ const avatarConnectionMachine = setup({
     appendAvatarChatEntry,
     removeStaleChatEntriesForRetry,
     appendUserChatEntry,
-    appendUserTextEntry,
+    trackInternalAskEcho,
     setScreenShareActive,
     setScreenShareStream,
     showScreenShareErrorNotification,
@@ -23495,7 +23391,7 @@ const avatarConnectionMachine = setup({
       content: null,
       chatLog: [],
       clientToolCallLog: [],
-      pendingTextInput: null,
+      awaitingInternalAskEcho: false,
       userAgent: '',
       userAgentHints: null,
       kalturaAnalyticsService: input.kalturaAnalyticsService,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaltura-sdk/avatars",
-  "version": "1.16.0",
+  "version": "1.16.2",
   "author": "kaltura",
   "license": "AGPL-3.0",
   "repository": {
@@ -9,11 +9,11 @@
   },
   "types": "./src/index.d.ts",
   "dependencies": {
-    "@kaltura-sdk/rtc-avatar": "^1.32.34",
-    "@kaltura-sdk/rtc-core": "^1.25.21",
+    "@kaltura-sdk/rtc-avatar": "^1.33.1",
+    "@kaltura-sdk/rtc-core": "^1.26.1",
     "@local/genie-shared-utils": "^1.0.0",
     "@unisphere/core": "^1.99.0",
-    "@unisphere/genie-types": "^1.39.3",
+    "@unisphere/genie-types": "^1.39.6",
     "@unisphere/notifications-core": "^1.25.0",
     "@unisphere/runtime": "^1.98.0",
     "@unisphere/runtime-js": "^1.96.0",

package/src/lib/avatar-client-manager/machines/avatar-connection/actions/context/track-internal-ask-echo.d.ts

@@ -0,0 +1,2 @@
+import { AvatarConnectionMachineAction } from '../../types';
+export declare const trackInternalAskEcho: AvatarConnectionMachineAction;

package/src/lib/avatar-client-manager/machines/avatar-connection/avatar-connection-machine.d.ts

@@ -398,7 +398,7 @@ export declare const avatarConnectionMachine: import("xstate").StateMachine<Avat
     type: "appendUserChatEntry";
     params: unknown;
 } | {
-    type: "appendUserTextEntry";
+    type: "trackInternalAskEcho";
     params: unknown;
 } | {
     type: "setScreenShareActive";

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-state.d.ts

@@ -96,7 +96,7 @@ export declare const connectedState: {
             initial: string;
             on: {
                 AskViaText: {
-                    actions: ("appendUserTextEntry" | {
+                    actions: ("trackInternalAskEcho" | {
                         type: "sendAskViaText";
                         params: ({ event }: {
                             event: import("../types").AskViaTextEvent;

package/src/lib/avatar-client-manager/machines/avatar-connection/states/connected-states/text-communication-state.d.ts

@@ -4,7 +4,7 @@ export declare const textCommunicationState: {
     initial: string;
     on: {
         AskViaText: {
-            actions: ("appendUserTextEntry" | {
+            actions: ("trackInternalAskEcho" | {
                 type: "sendAskViaText";
                 params: ({ event }: {
                     event: AskViaTextEvent;

package/src/lib/avatar-client-manager/machines/avatar-connection/types/context.d.ts

@@ -66,11 +66,7 @@ export interface AvatarConnectionMachineContext {
     content: UnisphereChatBlock | null;
     chatLog: ChatEntry[];
     clientToolCallLog: ClientToolCallLogEntry[];
-    pendingTextInput: {
-        id: string | null;
-        turnId: string | null;
-        text: string;
-    } | null;
+    awaitingInternalAskEcho: boolean;
     isAgentTalking: boolean;
     userAgent: string;
     userAgentHints: Record<string, string> | null;

package/src/lib/avatar-client-manager/machines/avatar-connection/types/events.d.ts

@@ -164,7 +164,6 @@ export type AgentStartSpeechReceivedEvent = {
 export type AvatarChatEntryReceivedEvent = {
     type: AvatarConnectionMachineEventTypes.AvatarChatEntryReceived;
     entry: ChatEntry;
-    isFinalSegment?: boolean;
 };
 export type UserVoiceTurnReceivedEvent = {
     type: AvatarConnectionMachineEventTypes.UserVoiceTurnReceived;

package/src/lib/avatar-client-manager/machines/avatar-connection/actions/context/append-user-text-entry.d.ts

@@ -1,2 +0,0 @@
-import { AvatarConnectionMachineAction } from '../../types';
-export declare const appendUserTextEntry: AvatarConnectionMachineAction;