@dxos/plugin-transcription 0.8.4-main.fd6878d → 0.9.0

package/src/transcriber/transcriber.test.ts

@@ -0,0 +1,104 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { type AudioChunk } from './audio-recorder';
+import { alignWhisperSegments, type WhisperSegment } from './transcriber';
+
+const T0 = Date.parse('2026-01-01T00:00:00.000Z');
+
+const chunk = (offsetMs = 0, samples = 16): AudioChunk => ({
+  timestamp: T0 + offsetMs,
+  data: new Float64Array(samples),
+});
+
+const segment = (overrides: Partial<WhisperSegment>): WhisperSegment => ({
+  text: '',
+  start: 0,
+  end: 0,
+  no_speech_prob: 0,
+  words: [],
+  ...overrides,
+});
+
+describe('alignWhisperSegments', () => {
+  test('returns empty when no chunks were transcribed', ({ expect }) => {
+    const result = alignWhisperSegments(
+      [segment({ text: 'x', end: 1, words: [{ word: 'x', start: 0, end: 1 }] })],
+      [],
+      0,
+    );
+    expect(result.transcripts).toEqual([]);
+    expect(result.lastTimestamp).toBeUndefined();
+  });
+
+  test('absolute-timestamps and deduplicates segments against lastTimestamp', ({ expect }) => {
+    const segments: WhisperSegment[] = [
+      segment({
+        text: 'hello world',
+        start: 0,
+        end: 1,
+        words: [
+          { word: 'hello ', start: 0, end: 0.5 },
+          { word: 'world', start: 0.5, end: 1 },
+        ],
+      }),
+    ];
+
+    const first = alignWhisperSegments(segments, [chunk(0)], 0);
+    expect(first.transcripts).toHaveLength(1);
+    expect(first.transcripts[0]._tag).toBe('transcript');
+    expect(first.transcripts[0].text).toBe('hello world');
+    expect(new Date(first.transcripts[0].started).getTime()).toBe(T0);
+    expect(first.lastTimestamp).toBe(T0 + 1_000);
+
+    // Same segments, same chunk start: every word's absolute start is < lastTimestamp -> filtered out.
+    const second = alignWhisperSegments(segments, [chunk(0)], first.lastTimestamp!);
+    expect(second.transcripts).toEqual([]);
+    expect(second.lastTimestamp).toBeUndefined();
+  });
+
+  test('keeps later words when earlier words fall before lastTimestamp', ({ expect }) => {
+    const segments: WhisperSegment[] = [
+      segment({
+        text: 'old new',
+        start: 0,
+        end: 2,
+        words: [
+          { word: 'old ', start: 0, end: 1 },
+          { word: 'new', start: 1.5, end: 2 },
+        ],
+      }),
+    ];
+
+    // First word starts at T0, second at T0+1500 — only the second survives a cursor at T0+1000.
+    const result = alignWhisperSegments(segments, [chunk(0)], T0 + 1_000);
+    expect(result.transcripts).toHaveLength(1);
+    expect(result.transcripts[0].text).toBe('new');
+    expect(new Date(result.transcripts[0].started).getTime()).toBe(T0 + 1_500);
+    expect(result.lastTimestamp).toBe(T0 + 2_000);
+  });
+
+  test('drops segments that end before lastTimestamp', ({ expect }) => {
+    const segments: WhisperSegment[] = [
+      segment({
+        text: 'stale',
+        start: 0,
+        end: 0.5,
+        words: [{ word: 'stale', start: 0, end: 0.5 }],
+      }),
+      segment({
+        text: 'fresh',
+        start: 1,
+        end: 2,
+        words: [{ word: 'fresh', start: 1.5, end: 2 }],
+      }),
+    ];
+
+    const result = alignWhisperSegments(segments, [chunk(0)], T0 + 1_000);
+    expect(result.transcripts).toHaveLength(1);
+    expect(result.transcripts[0].text).toBe('fresh');
+  });
+});

package/src/transcriber/transcriber.ts

@@ -7,15 +7,18 @@ import { WaveFile } from 'wavefile';
 import { DeferredTask, Trigger } from '@dxos/async';
 import { type Context, LifecycleState, Resource } from '@dxos/context';
 import { log } from '@dxos/log';
-import { type DataType } from '@dxos/schema';
 import { trace } from '@dxos/tracing';
+import { type ContentBlock } from '@dxos/types';
 
-import { TRANSCRIPTION_URL } from '../types';
 import { mergeFloat64Arrays } from '../util';
-
 import { type AudioChunk, type AudioRecorder } from './audio-recorder';
 
-type WhisperWord = {
+/**
+ * Endpoint to the calls service.
+ */
+const DEFAULT_TRANSCRIPTION_URL = 'https://calls-service.dxos.workers.dev';
+
+export type WhisperWord = {
   word: string;
 
   /**
@@ -29,7 +32,7 @@ type WhisperWord = {
   end: number;
 };
 
-type WhisperSegment = {
+export type WhisperSegment = {
   text: string;
 
   /**
@@ -61,16 +64,32 @@ export type TranscribeConfig = {
    * This is needed to catch the beginning of the user's speech.
    */
   prefixBufferChunksAmount: number;
+
+  /**
+   * Override the transcription endpoint base URL.
+   * Defaults to the DXOS calls service.
+   */
+  endpoint?: string;
 };
 
-export type TranscriberParams = {
+/**
+ * Function that converts a base64-encoded WAV payload into Whisper segments.
+ * Allows callers to swap in alternative providers or mock the transport.
+ */
+export type TranscribeFn = (audio: string) => Promise<WhisperSegment[]>;
+
+export type TranscriberProps = {
   config: TranscribeConfig;
   recorder: AudioRecorder;
   /**
    * Callback to handle the transcribed segments, after all segment transformers are applied.
    * @param segments - The transcribed segments.
    */
-  onSegments: (segments: DataType.MessageBlock.Transcript[]) => Promise<void>;
+  onSegments: (segments: ContentBlock.Transcript[]) => Promise<void>;
+  /**
+   * Optional override of the transcription transport. When provided, supersedes `config.endpoint`.
+   */
+  transcribe?: TranscribeFn;
 };
 
 /**
@@ -80,22 +99,24 @@ export type TranscriberParams = {
  */
 export class Transcriber extends Resource {
   private _audioChunks: AudioChunk[] = [];
-  private _lastUsedTimestamp = 0;
+  private _lastTimestamp = 0;
 
   private readonly _openTrigger = new Trigger({ autoReset: true });
 
   private readonly _config: TranscribeConfig;
   private readonly _recorder: AudioRecorder;
-  private readonly _onSegments: TranscriberParams['onSegments'];
+  private readonly _onSegments: TranscriberProps['onSegments'];
+  private readonly _transcribeFn?: TranscribeFn;
 
   private _recording = false;
   private _transcribeTask?: DeferredTask = undefined;
 
-  constructor({ config, recorder, onSegments }: TranscriberParams) {
+  constructor({ config, recorder, onSegments, transcribe }: TranscriberProps) {
     super();
     this._config = config;
     this._recorder = recorder;
     this._onSegments = onSegments;
+    this._transcribeFn = transcribe;
   }
 
   protected override async _open(ctx: Context): Promise<void> {
@@ -192,67 +213,91 @@ export class Transcriber extends Resource {
   @trace.span({ showInBrowserTimeline: true })
   private async _fetchTranscription(audio: string): Promise<WhisperSegment[]> {
     if (audio.length === 0) {
-      this._audioChunks = [];
       throw new Error('No audio to send for transcribing');
     }
 
-    const response = await fetch(`${TRANSCRIPTION_URL}/transcribe`, {
-      method: 'POST',
-      body: JSON.stringify({ audio }),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    });
-
-    if (!response.ok) {
-      this._audioChunks = [];
-      throw new Error(`Transcription failed: ${response.statusText}`);
+    let segments: unknown;
+    if (this._transcribeFn) {
+      segments = await this._transcribeFn(audio);
+    } else {
+      // TODO(burdon): Create separate endpoint?
+      const endpoint = this._config.endpoint ?? DEFAULT_TRANSCRIPTION_URL;
+      const response = await fetch(`${endpoint}/transcribe`, {
+        method: 'POST',
+        body: JSON.stringify({ audio }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Transcription failed: ${response.statusText}`);
+      }
+
+      ({ segments } = (await response.json()) as { segments?: unknown });
     }
 
-    const { segments } = (await response.json()) as {
-      segments: WhisperSegment[];
-    };
-
-    log.info('transcription response', {
-      segments: segments.length,
-      string: segments.map((segments) => segments.text).join(' '),
-    });
+    if (!Array.isArray(segments)) {
+      throw new Error('Transcription response payload is invalid');
+    }
 
-    return segments;
+    log.info('transcription response', { segments: segments.length });
+    return segments as WhisperSegment[];
   }
 
-  private _alignSegments(segments: WhisperSegment[], originalChunks: AudioChunk[]): DataType.MessageBlock.Transcript[] {
-    // Absolute zero for all relative timestamps in the segments.
-    const zeroTimestamp = originalChunks.at(0)!.timestamp;
-
-    const filteredSegments = segments
-      // Use segments that end after the last used timestamp.
-      // Segments could overlap, so we need to filter words that starts after the last used timestamp.
-      .filter((segment) => zeroTimestamp + segment.end * 1_000 >= this._lastUsedTimestamp)
-      // Use words that starts after the last used timestamp.
-      .map((segment) => {
-        const words = segment.words.filter((word) => zeroTimestamp + word.start * 1_000 >= this._lastUsedTimestamp);
-        return {
-          ...segment,
-          words,
-          text: words.map((word) => word.word).join(''),
-          start: words.at(0)?.start ?? segment.end,
-        };
-      })
-      .filter((segment) => segment.words.length > 0);
-
-    if (filteredSegments.length === 0) {
-      return [];
+  private _alignSegments(segments: WhisperSegment[], originalChunks: AudioChunk[]): ContentBlock.Transcript[] {
+    const result = alignWhisperSegments(segments, originalChunks, this._lastTimestamp);
+    if (result.lastTimestamp !== undefined) {
+      this._lastTimestamp = result.lastTimestamp;
     }
 
-    // Update last timestamp.
-    this._lastUsedTimestamp = zeroTimestamp + filteredSegments.at(-1)!.end * 1_000;
+    return result.transcripts;
+  }
+}
+
+/**
+ * Pure helper that filters and absolute-timestamps Whisper segments against a chunk timeline.
+ * Exported for testing.
+ *
+ * @param segments - Raw segments returned by the Whisper service for `originalChunks`.
+ * @param originalChunks - Chunks fed into the transcription request (used for the zero timestamp).
+ * @param lastTimestamp - Most recent absolute timestamp already emitted; segments whose end
+ *   falls strictly before this point are deduped out, as are individual words whose start does.
+ */
+export const alignWhisperSegments = (
+  segments: WhisperSegment[],
+  originalChunks: AudioChunk[],
+  lastTimestamp: number,
+): { transcripts: ContentBlock.Transcript[]; lastTimestamp?: number } => {
+  if (originalChunks.length === 0) {
+    return { transcripts: [] };
+  }
+
+  const zeroTimestamp = originalChunks[0].timestamp;
+
+  const filteredSegments = segments
+    .filter((segment) => zeroTimestamp + segment.end * 1_000 >= lastTimestamp)
+    .map((segment) => {
+      const words = segment.words.filter((word) => zeroTimestamp + word.start * 1_000 >= lastTimestamp);
+      return {
+        ...segment,
+        words,
+        text: words.map((word) => word.word).join(''),
+        start: words.at(0)?.start ?? segment.end,
+      };
+    })
+    .filter((segment) => segment.words.length > 0);
+
+  if (filteredSegments.length === 0) {
+    return { transcripts: [] };
+  }
 
-    // Add absolute timestamp to each segment.
-    return filteredSegments.map((segment) => ({
+  return {
+    lastTimestamp: zeroTimestamp + filteredSegments.at(-1)!.end * 1_000,
+    transcripts: filteredSegments.map((segment) => ({
       _tag: 'transcript',
       started: new Date(zeroTimestamp + segment.start * 1_000).toISOString(),
       text: segment.text.trim(),
-    }));
-  }
-}
+    })),
+  };
+};

package/src/transcriber/transcription-manager.ts

@@ -2,14 +2,17 @@
 // Copyright 2025 DXOS.org
 //
 
-import { signal } from '@preact/signals-core';
+import { Atom, type Registry } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import { synchronized } from '@dxos/async';
+import { createFeedServiceLayer, type Space } from '@dxos/client/echo';
 import { Resource } from '@dxos/context';
-import { Obj } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-db';
+import { Feed, Obj } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
 import { type EdgeHttpClient } from '@dxos/react-edge-client';
-import { DataType } from '@dxos/schema';
+import { type ContentBlock, Message } from '@dxos/types';
 
 import { MediaStreamRecorder } from './media-stream-recorder';
 import { Transcriber } from './transcriber';
@@ -30,13 +33,14 @@ const PREFIXED_CHUNKS_AMOUNT = 10;
  */
 const TRANSCRIBE_AFTER_CHUNKS_AMOUNT = 50;
 
-export type TranscriptMessageEnricher = (message: DataType.Message) => Promise<DataType.Message>;
+export type TranscriptMessageEnricher = (message: Message.Message) => Promise<Message.Message>;
 
 export type TranscriptionManagerOptions = {
   edgeClient: EdgeHttpClient;
+  registry: Registry.Registry;
 
   /**
-   * Enrich the message before it is written to the transcription queue.
+   * Enrich the message before it is written to the transcription feed.
    */
   messageEnricher?: TranscriptMessageEnricher;
 };
@@ -47,26 +51,33 @@ export type TranscriptionManagerOptions = {
 export class TranscriptionManager extends Resource {
   private readonly _edgeClient: EdgeHttpClient;
   private readonly _messageEnricher?: TranscriptMessageEnricher;
+  private readonly _registry: Registry.Registry;
   private _audioStreamTrack?: MediaStreamTrack = undefined;
   private _identityDid?: string = undefined;
   private _mediaRecorder?: MediaStreamRecorder = undefined;
   private _transcriber?: Transcriber = undefined;
-  private _queue?: Queue<DataType.Message> = undefined;
-  private _enabled = signal(false);
+  private _feed?: Feed.Feed = undefined;
+  private _feedServiceLayer?: Layer.Layer<Feed.FeedService> = undefined;
+  private _enabledAtom = Atom.make(false);
 
   constructor(options: TranscriptionManagerOptions) {
     super();
     this._edgeClient = options.edgeClient;
     this._messageEnricher = options.messageEnricher;
+    this._registry = options.registry;
   }
 
-  /** @reactive */
-  get enabled() {
-    return this._enabled.value;
+  get enabled(): Atom.Atom<boolean> {
+    return this._enabledAtom;
   }
 
-  setQueue(queue: Queue<DataType.Message>): this {
-    this._queue = queue;
+  getEnabled(): boolean {
+    return this._registry.get(this._enabledAtom);
+  }
+
+  setFeed(space: Space, feed: Feed.Feed): this {
+    this._feed = feed;
+    this._feedServiceLayer = createFeedServiceLayer(space.queues);
     return this;
   }
 
@@ -78,7 +89,7 @@ export class TranscriptionManager extends Resource {
   }
 
   setRecording(recording?: boolean): this {
-    if (!this.isOpen || !this._enabled.value) {
+    if (!this.isOpen || !this.getEnabled()) {
       return this;
     }
 
@@ -90,19 +101,17 @@ export class TranscriptionManager extends Resource {
     return this;
   }
 
-  /**
-   * Enable or disable transcription.
-   * @param enabled - Whether to enable transcription.
-   */
-  @synchronized
-  async setEnabled(enabled?: boolean): Promise<void> {
-    if (this._enabled.value === enabled) {
+  async setEnabled(enabled: boolean): Promise<void> {
+    if (this.getEnabled() === enabled) {
       return;
     }
 
-    this._enabled.value = enabled ?? false;
-    // TODO(burdon): Why is toggle called here?
-    this.isOpen && (await this._toggleTranscriber());
+    this._registry.set(this._enabledAtom, enabled ?? false);
+    if (enabled) {
+      await this._maybeRestartTranscriber();
+    } else {
+      await this._stopTranscriber();
+    }
   }
 
   @synchronized
@@ -112,48 +121,23 @@ export class TranscriptionManager extends Resource {
     }
 
     this._audioStreamTrack = track;
-    this.isOpen && (await this._toggleTranscriber());
+    await this._maybeRestartTranscriber();
   }
 
   protected override async _open(): Promise<void> {
-    await this._toggleTranscriber();
+    await this._maybeRestartTranscriber();
   }
 
   protected override async _close(): Promise<void> {
-    void this._transcriber?.close();
-  }
-
-  // TODO(burdon): Change this to setEnables (explicit), not toggle.
-  private async _toggleTranscriber(): Promise<void> {
-    await this._maybeReinitTranscriber();
-
-    // Open or close transcriber if transcription is enabled or disabled.
-    if (this._enabled.value) {
-      await this._transcriber?.open();
-      // TODO(burdon): Started and stopped blocks appear twice.
-      const block = Obj.make(DataType.Message, {
-        created: new Date().toISOString(),
-        blocks: [{ _tag: 'transcript', text: 'Started', started: new Date().toISOString() }],
-        sender: { role: 'assistant' },
-      });
-      await this._queue?.append([block]);
-    } else {
-      await this._transcriber?.close();
-      const block = Obj.make(DataType.Message, {
-        created: new Date().toISOString(),
-        blocks: [{ _tag: 'transcript', text: 'Stopped', started: new Date().toISOString() }],
-        sender: { role: 'assistant' },
-      });
-      await this._queue?.append([block]);
-    }
+    await this._stopTranscriber();
   }
 
-  private async _maybeReinitTranscriber(): Promise<void> {
-    if (!this._audioStreamTrack || !this._enabled.value) {
+  private async _maybeRestartTranscriber(): Promise<void> {
+    if (!this._audioStreamTrack || !this.getEnabled() || !this.isOpen) {
       return;
     }
 
-    // Reinitialize transcriber if queue or media stream track has changed.
+    // Reinitialize transcriber if feed or media stream track has changed.
     let needReinit = false;
     if (this._audioStreamTrack !== this._mediaRecorder?.mediaStreamTrack) {
       this._mediaRecorder = new MediaStreamRecorder({
@@ -172,15 +156,21 @@ export class TranscriptionManager extends Resource {
         recorder: this._mediaRecorder,
         onSegments: (segments) => this._onSegments(segments),
       });
+
+      await this._transcriber?.open();
     }
   }
 
-  private async _onSegments(segments: DataType.MessageBlock.Transcript[]): Promise<void> {
-    if (!this.isOpen || !this._queue) {
+  private async _stopTranscriber(): Promise<void> {
+    await this._transcriber?.close();
+  }
+
+  private async _onSegments(segments: ContentBlock.Transcript[]): Promise<void> {
+    if (!this.isOpen || !this._feed || !this._feedServiceLayer) {
       return;
     }
 
-    let block = Obj.make(DataType.Message, {
+    let block = Obj.make(Message.Message, {
       created: new Date().toISOString(),
       blocks: segments,
       sender: { identityDid: this._identityDid },
@@ -190,6 +180,6 @@ export class TranscriptionManager extends Resource {
       block = await this._messageEnricher(block);
     }
 
-    await this._queue.append([block]);
+    await Feed.append(this._feed, [block]).pipe(Effect.provide(this._feedServiceLayer), EffectEx.runAndForwardErrors);
   }
 }

package/src/translations.ts

@@ -4,20 +4,23 @@
 
 import { type Resource } from '@dxos/react-ui';
 
-import { meta } from './meta';
+import { meta } from '#meta';
 
 export const translations = [
   {
     'en-US': {
       [meta.id]: {
-        'plugin name': 'Transcription',
-        'transcript companion label': 'Transcript',
+        'plugin.name': 'Transcription',
+        'transcript-companion.label': 'Transcript',
 
-        'delete button': 'Delete',
-        'bookmark button': 'Bookmark',
-        'scroll to end label': 'Scroll to latest',
+        'delete.button': 'Delete',
+        'bookmark.button': 'Bookmark',
+        'scroll-to-end.label': 'Scroll to latest',
 
-        'settings entity extraction label': 'Entity extraction',
+        'start-recording.label': 'Start recording',
+        'stop-recording.label': 'Stop recording',
+
+        'settings.entity-extraction.label': 'Entity extraction',
       },
     },
   },

package/src/types/TranscriptOperation.ts

@@ -0,0 +1,106 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+import { SpaceSchema } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Database, Feed, Ref, Type, DXN } from '@dxos/echo';
+import { Message, Transcript } from '@dxos/types';
+
+import { meta } from '#meta';
+
+const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
+
+export const Create = Operation.make({
+  meta: { key: makeKey('create'), name: 'Create Transcript', icon: 'ph--microphone--regular' },
+  input: Schema.Struct({
+    name: Schema.optional(Schema.String),
+    space: SpaceSchema,
+  }),
+  output: Schema.Struct({
+    object: Type.getSchema(Transcript.Transcript),
+  }),
+});
+
+export const MessageWithRangeId = Schema.extend(
+  Type.getSchema(Message.Message),
+  Schema.Struct({
+    rangeId: Schema.optional(Schema.Array(Schema.String)).annotations({
+      description: 'The IDs of the messages that contain the sentences.',
+    }),
+  }),
+);
+
+export type MessageWithRangeIdType = Schema.Schema.Type<typeof MessageWithRangeId>;
+
+export const Open = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.transcription.open'),
+    name: 'Open',
+    description: 'Opens and reads the contents of a transcription object.',
+    icon: 'ph--folder-open--regular',
+  },
+  input: Schema.Struct({
+    transcript: Ref.Ref(Transcript.Transcript).annotations({
+      description: 'The ID of the transcription object.',
+    }),
+  }),
+  output: Schema.Struct({
+    content: Schema.String,
+  }),
+  services: [Database.Service, Feed.FeedService],
+});
+
+export const Summarize = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.transcription.summarize'),
+    name: 'Summarize',
+    description: 'Summarize a transcript of a meeting.',
+    icon: 'ph--text-align-left--regular',
+  },
+  input: Schema.Struct({
+    transcript: Schema.String.annotations({
+      description: 'The transcript of the meeting.',
+    }),
+    notes: Schema.optional(Schema.String).annotations({
+      description: 'Additional notes from the participants.',
+    }),
+  }),
+  output: Schema.Struct({
+    summary: Schema.String.annotations({
+      description: 'The summary of the transcript.',
+    }),
+  }),
+  services: [AiService.AiService],
+});
+
+export const SentenceNormalizationInput = Schema.Struct({
+  messages: Schema.Array(MessageWithRangeId).annotations({
+    description: 'Messages to normalize into sentences.',
+  }),
+});
+
+export type SentenceNormalizationInputType = Schema.Schema.Type<typeof SentenceNormalizationInput>;
+
+export const SentenceNormalizationOutput = Schema.Struct({
+  sentences: Schema.Array(MessageWithRangeId.pipe(Schema.mutable)).pipe(Schema.mutable).annotations({
+    description: 'The sentences of the transcript.',
+  }),
+});
+
+export const SentenceNormalization = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.function.transcription.sentenceNormalization'),
+    name: 'Sentence Normalization',
+    description: 'Post process of transcription for sentence normalization',
+    icon: 'ph--text-t--regular',
+  },
+  input: SentenceNormalizationInput,
+  output: SentenceNormalizationOutput,
+  services: [],
+});