@ephia/dova-sdk 1.0.0

package/src/core/transcript/client-transcript.reducer.ts

@@ -0,0 +1,366 @@
+import type {
+  EphiaAudioEvent,
+  TranscriptFinalEvent,
+  TranscriptPreviewEvent,
+  TranscriptPreviewStableEvent,
+  TranscriptSegmentCommittedEvent,
+  TranscriptSegmentReadyEvent,
+  DocumentPatchEvent,
+} from "ephia-protocol";
+import type { TranscriptState, TranscriptSegment } from "./client-transcript.state";
+import { initialTranscriptState } from "./client-transcript.state";
+import { joinWithSpacing } from "./transcript.assembler";
+import { pickEffectiveText } from "../../shared/effective-text";
+
+export function eventReducer(
+  state: TranscriptState,
+  event: EphiaAudioEvent
+): TranscriptState {
+  switch (event.type) {
+    case "transcript.preview":
+      return handlePartial(state, event);
+    case "transcript.preview.stable":
+      return handleStable(state, event);
+    case "transcript.final":
+      return handleFinal(state, event);
+    case "transcript.segment.ready":
+      return handleChunkFinalized(state, event);
+    case "transcript.segment.committed":
+      return handleChunkCommitted(state, event);
+    case "session.context.reset":
+      return handleSessionContextReset(state, event);
+    case "document.patch":
+      return handleDocumentPatch(state, event);
+    case "segment.absorbed": {
+      const absorbedId = event.payload.segmentId;
+      const absorbedInto = event.payload.absorbedInto;
+      const newSegments = state.segments.map((s: TranscriptSegment) =>
+        s.segmentId === absorbedId
+          ? {
+              ...s,
+              isCommitted: true,
+              committedText: null,
+              partialText: null,
+              finalText: null,
+              mergedWith: absorbedInto,
+            }
+          : s
+      );
+      return { ...state, segments: newSegments };
+    }
+    default:
+      return state;
+  }
+}
+
+function handlePartial(
+  state: TranscriptState,
+  event: TranscriptPreviewEvent
+): TranscriptState {
+  const existing = state.segments.find(
+    (s: TranscriptSegment) => s.segmentId === event.payload.segmentId
+  );
+
+  if (existing) {
+    if (existing.isCommitted) {
+      return state;
+    }
+    // Fix 2.1 — bloquer seulement si texte identique ET révision identique
+    if (
+      event.payload.revision < existing.revision ||
+      (event.payload.revision === existing.revision &&
+        event.payload.text === existing.partialText)
+    ) {
+      return state;
+    }
+    return {
+      ...state,
+      segments: state.segments.map((s: TranscriptSegment) =>
+        s.segmentId === event.payload.segmentId
+          ? {
+              ...s,
+              partialText: event.payload.text,
+              revision: event.payload.revision,
+              stable: (event.payload as { stable?: boolean }).stable ?? false,
+            }
+          : s
+      ),
+    };
+  }
+
+  // Nouveau segment
+  return {
+    ...state,
+    currentSegmentId: event.payload.segmentId,
+    segments: [
+      ...state.segments,
+      {
+        segmentId: event.payload.segmentId,
+        segmentSeq: event.payload.segmentSeq,
+        partialText: event.payload.text,
+        finalText: null,
+        committedText: null,
+        isFinalized: false,
+        isCommitted: false,
+        revision: event.payload.revision,
+        stable: (event.payload as { stable?: boolean }).stable ?? false,
+        source: null,
+        mergedWith: null,
+      },
+    ],
+  };
+}
+
+function handleStable(
+  state: TranscriptState,
+  event: TranscriptPreviewStableEvent
+): TranscriptState {
+  return {
+    ...state,
+    segments: state.segments.map((s: TranscriptSegment) =>
+      s.segmentId === event.payload.segmentId
+        ? { ...s, stable: true, partialText: event.payload.text }
+        : s
+    ),
+  };
+}
+
+function handleFinal(
+  state: TranscriptState,
+  event: TranscriptFinalEvent
+): TranscriptState {
+  const existing = state.segments.find(
+    (s: TranscriptSegment) => s.segmentId === event.payload.segmentId
+  );
+
+  if (!existing) {
+    return {
+      ...state,
+      segments: [
+        ...state.segments,
+        {
+          segmentId: event.payload.segmentId,
+          segmentSeq: event.payload.segmentSeq,
+          partialText: null,
+          finalText: event.payload.text,
+          committedText: null,
+          isFinalized: true,
+          isCommitted: false,
+          revision: 0,
+          stable: true,
+          source: null,
+          mergedWith: null,
+        },
+      ],
+    };
+  }
+
+  return {
+    ...state,
+    segments: state.segments.map((s: TranscriptSegment) =>
+      s.segmentId === event.payload.segmentId
+        ? {
+            ...s,
+            finalText: event.payload.text,
+            isFinalized: true,
+            partialText: null,
+          }
+        : s
+    ),
+  };
+}
+
+function handleChunkFinalized(
+  state: TranscriptState,
+  event: TranscriptSegmentReadyEvent
+): TranscriptState {
+  const effectiveText = pickEffectiveText(event.payload);
+  const existing = state.segments.find(
+    (s: TranscriptSegment) => s.segmentId === event.payload.segmentId
+  );
+
+  if (!existing) {
+    return {
+      ...state,
+      segments: [
+        ...state.segments,
+        {
+          segmentId: event.payload.segmentId,
+          segmentSeq: event.payload.segmentSeq,
+          partialText: null,
+          finalText: effectiveText,
+          committedText: null,
+          isFinalized: true,
+          isCommitted: false,
+          revision: 0,
+          stable: true,
+          source: event.payload.provider ?? null,
+          mergedWith: null,
+        },
+      ],
+    };
+  }
+
+  return {
+    ...state,
+    segments: state.segments.map((s: TranscriptSegment) =>
+      s.segmentId === event.payload.segmentId
+        ? {
+            ...s,
+            finalText: effectiveText,
+            isFinalized: true,
+          }
+        : s
+    ),
+  };
+}
+
+function handleChunkCommitted(
+  state: TranscriptState,
+  event: TranscriptSegmentCommittedEvent
+): TranscriptState {
+  const { segmentId, source, mergedWith } = event.payload;
+  const text = pickEffectiveText(event.payload);
+  const mergedIds: string[] = mergedWith
+    ? Array.isArray(mergedWith)
+      ? mergedWith
+      : [mergedWith]
+    : [];
+
+  const existing = state.segments.find(
+    (s: TranscriptSegment) => s.segmentId === segmentId
+  );
+
+  let newSegments = existing
+    ? state.segments.map((s: TranscriptSegment) =>
+        s.segmentId === segmentId
+          ? {
+              ...s,
+              committedText: text,
+              isCommitted: true,
+              partialText: null,
+              finalText: text,
+              source: source ?? null,
+              mergedWith: mergedIds.length > 0 ? mergedIds : null,
+            }
+          : s
+      )
+    : [
+        ...state.segments,
+        {
+          segmentId,
+          segmentSeq: event.payload.segmentSeq,
+          partialText: null,
+          finalText: text,
+          committedText: text,
+          isFinalized: true,
+          isCommitted: true,
+          revision: 0,
+          stable: true,
+          source: source ?? null,
+          mergedWith: mergedIds.length > 0 ? mergedIds : null,
+        },
+      ];
+
+  // Marquer les segments absorbés comme superseded
+  for (const absorbedId of mergedIds) {
+    newSegments = newSegments.map((s: TranscriptSegment) =>
+      s.segmentId === absorbedId
+        ? {
+            ...s,
+            isCommitted: true,
+            committedText: null,
+            partialText: null,
+            finalText: null,
+            mergedWith: segmentId,
+          }
+        : s
+    );
+  }
+
+  // Reconstruire le document text
+  const documentText = newSegments
+    .filter(
+      (s) =>
+        s.isCommitted &&
+        s.committedText &&
+        (typeof s.mergedWith !== "string")
+    )
+    .map((s) => s.committedText as string)
+    .reduce((acc, text) => joinWithSpacing(acc, text), "");
+
+  return {
+    ...state,
+    segments: newSegments,
+    documentText,
+  };
+}
+
+function handleSessionContextReset(
+  state: TranscriptState,
+  event: { payload: { contextOnly?: boolean } }
+): TranscriptState {
+  const contextOnly = event.payload.contextOnly ?? false;
+  if (!contextOnly) {
+    return { ...initialTranscriptState };
+  }
+  // Fix 2.3 — contextOnly=true : conserver uniquement les segments committés
+  const committedSegments = state.segments.filter((s) => s.isCommitted);
+  const documentText = committedSegments
+    .filter(
+      (s) =>
+        s.committedText && (typeof s.mergedWith !== "string")
+    )
+    .map((s) => s.committedText as string)
+    .reduce((acc, t) => joinWithSpacing(acc, t), "");
+  return {
+    ...state,
+    segments: committedSegments,
+    currentSegmentId: null,
+    documentText,
+  };
+}
+
+function handleDocumentPatch(
+  state: TranscriptState,
+  event: DocumentPatchEvent
+): TranscriptState {
+  let segments = [...state.segments];
+
+  for (const op of event.payload.ops) {
+    switch (op.type) {
+      case "merge": {
+        const fromSeg = segments.find((s: TranscriptSegment) => s.segmentId === op.from);
+        const toSeg = segments.find((s: TranscriptSegment) => s.segmentId === op.to);
+        if (fromSeg && toSeg) {
+          segments = segments.map((s) =>
+            s.segmentId === op.to
+              ? { ...s, committedText: op.text ?? null, mergedWith: op.from ?? null }
+              : s
+          );
+        }
+        break;
+      }
+      case "replace": {
+        segments = segments.map((s: TranscriptSegment) =>
+          s.segmentId === op.blockId
+            ? { ...s, committedText: op.text ?? null }
+            : s
+        );
+        break;
+      }
+    }
+  }
+
+  const documentText = segments
+    .filter(
+      (s) =>
+        s.isCommitted &&
+        s.committedText &&
+        (typeof s.mergedWith !== "string")
+    )
+    .map((s) => s.committedText as string)
+    .reduce((acc, text) => joinWithSpacing(acc, text), "");
+
+  return { ...state, segments, documentText };
+}

package/src/core/transcript/client-transcript.state.ts

@@ -0,0 +1,25 @@
+export interface TranscriptSegment {
+  segmentId: string;
+  segmentSeq: number;
+  partialText: string | null;
+  finalText: string | null;
+  committedText: string | null;
+  isFinalized: boolean;
+  isCommitted: boolean;
+  revision: number;
+  stable: boolean;
+  source: string | null;
+  mergedWith: string | string[] | null;
+}
+
+export interface TranscriptState {
+  segments: TranscriptSegment[];
+  currentSegmentId: string | null;
+  documentText: string;
+}
+
+export const initialTranscriptState: TranscriptState = {
+  segments: [],
+  currentSegmentId: null,
+  documentText: "",
+};

package/src/core/transcript/index.ts

@@ -0,0 +1,19 @@
+export { eventReducer } from "./client-transcript.reducer";
+export { initialTranscriptState } from "./client-transcript.state";
+export type { TranscriptSegment, TranscriptState } from "./client-transcript.state";
+export {
+  assembleCommittedDocument,
+  assembleTranscript,
+  buildDisplayText,
+  joinWithSpacing,
+} from "./transcript.assembler";
+export { liveTranscriptReducer } from "./transcript.reducer";
+export type { LiveTranscriptAction } from "./transcript.reducer";
+export { initialLiveTranscriptState } from "./transcript.state";
+export type {
+  LiveTranscriptChunk,
+  LiveTranscriptChunkStatus,
+  LiveTranscriptDiagnostics,
+  LiveTranscriptState,
+  LiveTranscriptStatus,
+} from "./transcript.state";

package/src/core/transcript/transcript.assembler.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, it } from "vitest";
+import { pickJoiner } from "../bindings/TargetBinding";
+import {
+  assembleCommittedDocument,
+  assembleTranscript,
+  joinWithSpacing,
+} from "./transcript.assembler";
+import { initialLiveTranscriptState } from "./transcript.state";
+import { liveTranscriptReducer } from "./transcript.reducer";
+import type { LiveTranscriptChunk } from "./transcript.state";
+
+describe("dictated newlines", () => {
+  it("does not insert a space before a newline-leading chunk", () => {
+    expect(pickJoiner("Compte rendu", "\nConclusion")).toBe("");
+    expect(joinWithSpacing("Compte rendu", "\nConclusion")).toBe(
+      "Compte rendu\nConclusion"
+    );
+  });
+
+  it("preserves terminal newlines when assembling chunks", () => {
+    const chunks: LiveTranscriptChunk[] = [
+      {
+        segmentId: "s1",
+        segmentSeq: 1,
+        status: "done",
+        text: "Absence d'anomalie.\n",
+        revision: 0,
+      },
+      {
+        segmentId: "s2",
+        segmentSeq: 2,
+        status: "done",
+        text: "Conclusion normale.",
+        revision: 0,
+      },
+    ];
+
+    expect(assembleTranscript(chunks)).toBe(
+      "Absence d'anomalie.\nConclusion normale."
+    );
+  });
+
+  it("keeps the merged target and ignores absorbed chunks", () => {
+    expect(
+      assembleCommittedDocument(
+        {
+          s1: {
+            segmentId: "s1",
+            segmentSeq: 1,
+            status: "done",
+            text: "Bonjour frérot",
+            committedText: "Bonjour frérot",
+            revision: 0,
+            mergedWith: ["s2"],
+          },
+          s2: {
+            segmentId: "s2",
+            segmentSeq: 2,
+            status: "done",
+            text: "",
+            committedText: "",
+            revision: 0,
+            mergedWith: "s1",
+          },
+        },
+        ["s1", "s2"]
+      )
+    ).toBe("Bonjour frérot");
+  });
+
+  it.skip("removes committed text from following preview display — overlap trimming removed (Replace Model, backend-enforced)", () => {
+    let state = initialLiveTranscriptState;
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "segment.opened",
+        seq: 1,
+        sessionId: "s",
+        payload: { segmentId: "s1", segmentSeq: 1, startMs: 0 },
+      } as any,
+    });
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "segment.opened",
+        seq: 2,
+        sessionId: "s",
+        payload: { segmentId: "s2", segmentSeq: 2, startMs: 1 },
+      } as any,
+    });
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "transcript.preview",
+        seq: 3,
+        sessionId: "s",
+        payload: {
+          segmentId: "s2",
+          segmentSeq: 2,
+          revision: 1,
+          text: "On retrouve cependant une formation méningiomateuse mesurant 25 mm",
+        },
+      } as any,
+    });
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "transcript.segment.committed",
+        seq: 4,
+        sessionId: "s",
+        payload: {
+          segmentId: "s1",
+          segmentSeq: 1,
+          text: "Pas de déviation. On retrouve cependant une formation méningi",
+          source: "voxtral-small-2507",
+        },
+      } as any,
+    });
+
+    expect(state.displayText.match(/On retrouve cependant une formation/g)).toHaveLength(1);
+    expect(state.displayText).toContain("méningiomateuse mesurant 25 mm");
+    expect(state.displayText).not.toContain("méningi omateuse");
+    expect(state.previewText).toBe("omateuse mesurant 25 mm");
+  });
+
+  it("uses backend delta for cumulative finalized and committed chunks", () => {
+    let state = initialLiveTranscriptState;
+    const s1 = "Scanner cérébral sans injection de produit de contraste.";
+    const s2Raw =
+      "Scanner cérébral, sans injection de produit de contraste. Indication, traumatisme crânien.";
+    const s2Delta = "Indication, traumatisme crânien.";
+
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "segment.opened",
+        seq: 1,
+        sessionId: "s",
+        payload: { segmentId: "s1", segmentSeq: 1, startMs: 0 },
+      } as any,
+    });
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "transcript.segment.committed",
+        seq: 2,
+        sessionId: "s",
+        payload: {
+          segmentId: "s1",
+          segmentSeq: 1,
+          text: s1,
+          source: "voxtral-small-2507",
+        },
+      } as any,
+    });
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "segment.opened",
+        seq: 3,
+        sessionId: "s",
+        payload: { segmentId: "s2", segmentSeq: 2, startMs: 1 },
+      } as any,
+    });
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "transcript.segment.ready",
+        seq: 4,
+        sessionId: "s",
+        payload: {
+          segmentId: "s2",
+          segmentSeq: 2,
+          text: s2Raw,
+          delta: s2Delta,
+          tags: [],
+          provider: "voxtral-small-2507",
+        },
+      } as any,
+    });
+
+    expect(state.chunks.s2.finalizedText).toBe(s2Delta);
+    expect(state.displayText.match(/Scanner cérébral/g)).toHaveLength(1);
+
+    state = liveTranscriptReducer(state, {
+      type: "event",
+      event: {
+        type: "transcript.segment.committed",
+        seq: 5,
+        sessionId: "s",
+        payload: {
+          segmentId: "s2",
+          segmentSeq: 2,
+          text: s2Raw,
+          delta: s2Delta,
+          source: "voxtral-small-2507",
+        },
+      } as any,
+    });
+
+    expect(state.documentText).toBe(`${s1} ${s2Delta}`);
+    expect(state.finalText).toBe(`${s1} ${s2Delta}`);
+    expect(state.documentText.match(/Scanner cérébral/g)).toHaveLength(1);
+  });
+});