@dxos/plugin-transcription 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/operations/open.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database, Obj } from '@dxos/echo';
+import { QueueService } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+import { Message } from '@dxos/types';
+
+import { renderByline } from '../util';
+import { Open } from './definitions';
+
+const handler: Operation.WithHandler<typeof Open> = Open.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ transcript }) {
+      const transcriptObj = yield* Database.load(transcript);
+      const { dxn } = yield* Effect.promise(() => transcriptObj.queue.load());
+      const queue = yield* QueueService.getQueue(dxn);
+      yield* Effect.promise(() => queue?.queryObjects());
+      const content = queue?.objects
+        .filter((message: unknown) => Obj.instanceOf(Message.Message, message))
+        .flatMap((message: Message.Message, index: number) => renderByline([])(message, index))
+        .join('\n\n');
+      return { content };
+    }),
+  ),
+);
+
+export default handler;

package/src/{functions → operations}/summarize.ts

@@ -7,67 +7,61 @@ import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 import * as Layer from 'effect/Layer';
 import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
 
 import { AiService, ConsolePrinter, ToolExecutionService, ToolResolverService } from '@dxos/ai';
 import { AiSession, GenerationObserver } from '@dxos/assistant';
-import { TracingService, defineFunction } from '@dxos/functions';
+import { FunctionInvocationService, TracingService } from '@dxos/functions';
+import * as Trace from '@dxos/functions/Trace';
+import { Operation } from '@dxos/operation';
 import { trim } from '@dxos/util';
 
+import { Summarize } from './definitions';
+
 /**
  * Summarize a transcript of a meeting.
  */
-export default defineFunction({
-  key: 'dxos.org/function/transcription/summarize',
-  name: 'Summarize',
-  description: 'Summarize a transcript of a meeting.',
-  inputSchema: Schema.Struct({
-    transcript: Schema.String.annotations({
-      description: 'The transcript of the meeting.',
-    }),
-    notes: Schema.optional(Schema.String).annotations({
-      description: 'Additional notes from the participants.',
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    summary: Schema.String.annotations({
-      description: 'The summary of the transcript.',
-    }),
-  }),
-  handler: Effect.fnUntraced(
-    function* ({ data: { transcript, notes } }) {
-      const result = yield* new AiSession().run({
-        prompt: `Transcript: ${transcript}\n\nNotes: ${notes}`,
-        history: [],
-        system: systemPrompt,
-        observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'summarize' })),
-      });
+const handler: Operation.WithHandler<typeof Summarize> = Summarize.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({ transcript, notes }) {
+        const result = yield* new AiSession({
+          observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'summarize' })),
+        }).run({
+          prompt: `Transcript: ${transcript}\n\nNotes: ${notes}`,
+          history: [],
+          system: systemPrompt,
+        });
 
-      const summary = Function.pipe(
-        result,
-        Array.findLast((msg) => msg.sender.role === 'assistant' && msg.blocks.some((block) => block._tag === 'text')),
-        Option.flatMap((msg) =>
-          Function.pipe(
-            msg.blocks,
-            Array.findLast((block) => block._tag === 'text'),
-            Option.map((block) => block.text),
+        const summary = Function.pipe(
+          result,
+          Array.findLast((msg) => msg.sender.role === 'assistant' && msg.blocks.some((block) => block._tag === 'text')),
+          Option.flatMap((msg) =>
+            Function.pipe(
+              msg.blocks,
+              Array.findLast((block) => block._tag === 'text'),
+              Option.map((block) => block.text),
+            ),
           ),
-        ),
-        Option.getOrThrowWith(() => new Error('No summary found')),
-      );
+          Option.getOrThrowWith(() => new Error('No summary found')),
+        );
 
-      return { summary };
-    },
-    Effect.provide(
-      Layer.mergeAll(
-        AiService.model('@anthropic/claude-sonnet-4-0'),
-        ToolResolverService.layerEmpty,
-        ToolExecutionService.layerEmpty,
-        TracingService.layerNoop,
+        return { summary };
+      },
+      Effect.provide(
+        Layer.mergeAll(
+          AiService.model('@anthropic/claude-sonnet-4-0'),
+          ToolResolverService.layerEmpty,
+          ToolExecutionService.layerEmpty,
+          TracingService.layerNoop,
+          FunctionInvocationService.layerNotAvailable,
+          Trace.writerLayerNoop,
+        ),
       ),
     ),
   ),
-});
+);
+
+export default handler;
 
 const systemPrompt = trim`
   You are a helpful assistant that summarizes transcripts of meetings.

package/src/segments-normalization/message-normalizer.ts

@@ -6,24 +6,22 @@
 // Copyright 2025 DXOS.org
 //
 
-import { effect } from '@preact/signals-core';
-
 import { DeferredTask, asyncTimeout } from '@dxos/async';
 import { LifecycleState, Resource } from '@dxos/context';
 import { type Queue } from '@dxos/echo-db';
-import { type FunctionExecutor } from '@dxos/functions';
+import { type FunctionExecutor } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { type DataType } from '@dxos/schema';
+import { type Message } from '@dxos/types';
 
-import { type MessageWithRangeId, sentenceNormalization } from './normalization';
+import { type MessageWithRangeId, type NormalizationOutput, sentenceNormalization } from './normalization';
 import { getActorId } from './utils';
 
 const PROCESSING_TIMEOUT = 20_000; // ms
 const MAX_RANGE_ID_COUNT = 10;
 
-export type SegmentsNormalizerParams = {
+export type SegmentsNormalizerProps = {
   functionExecutor: FunctionExecutor;
-  queue: Queue<DataType.Message>;
+  queue: Queue<Message.Message>;
   startingCursor: QueueCursor;
 };
 
@@ -36,13 +34,13 @@ export type QueueCursor = {
 // TODO(mykola): .
 export class MessageNormalizer extends Resource {
   private readonly _functionExecutor: FunctionExecutor;
-  private _queue: Queue<DataType.Message>;
+  private _queue: Queue<Message.Message>;
   private _cursor: QueueCursor;
   private _messagesToProcess: MessageWithRangeId[] = [];
   private _normalizationTask?: DeferredTask;
   private _lastProcessedMessageIds?: string[];
 
-  constructor({ functionExecutor, queue, startingCursor }: SegmentsNormalizerParams) {
+  constructor({ functionExecutor, queue, startingCursor }: SegmentsNormalizerProps) {
     super();
     this._functionExecutor = functionExecutor;
     this._queue = queue;
@@ -51,7 +49,8 @@ export class MessageNormalizer extends Resource {
 
   protected override async _open(): Promise<void> {
     this._normalizationTask = new DeferredTask(this._ctx, () => this._processMessages());
-    const unsubscribe = effect(() => {
+
+    const updateMessages = () => {
       if (this._lifecycleState !== LifecycleState.OPEN) {
         return;
       }
@@ -62,8 +61,14 @@ export class MessageNormalizer extends Resource {
       });
 
       this._normalizationTask!.schedule();
-    });
-    this._ctx.onDispose(() => unsubscribe());
+    };
+
+    // Initial update.
+    updateMessages();
+
+    // Subscribe to queue changes.
+    const unsubscribe = this._queue.subscribe(updateMessages);
+    this._ctx.onDispose(unsubscribe);
   }
 
   // Need to unpack strings from blocks from messages run them through the function and then pack them back into blocks into messages.
@@ -81,7 +86,7 @@ export class MessageNormalizer extends Resource {
 
     try {
       // TODO(mykola): Executor should support timeout.
-      const response = await asyncTimeout(
+      const response: NormalizationOutput = await asyncTimeout(
         this._functionExecutor.invoke(sentenceNormalization, { messages }),
         PROCESSING_TIMEOUT,
       );

package/src/segments-normalization/normalization.test.ts

@@ -2,7 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { effect } from '@preact/signals-core';
 import { describe, test } from 'vitest';
 
 import { scheduleTaskInterval } from '@dxos/async';
@@ -10,15 +9,15 @@ import { Context } from '@dxos/context';
 import { Obj } from '@dxos/echo';
 import { createQueueDXN } from '@dxos/echo/internal';
 import { MemoryQueue } from '@dxos/echo-db';
-import { FunctionExecutor, ServiceContainer } from '@dxos/functions';
+import { FunctionExecutor, ServiceContainer } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { type Actor, Message } from '@dxos/types';
 
 import { MessageNormalizer } from './message-normalizer';
 import { type MessageWithRangeId, sentenceNormalization } from './normalization';
 import { getActorId } from './utils';
 
-const sender: DataType.Actor = {
+const sender: Actor.Actor = {
   identityDid: 'did:key:123',
 };
 
@@ -48,7 +47,7 @@ const messages: MessageWithRangeId[] = [
   // No punctuation.
   'in classical physics objects have well-defined properties such as position speed and momentum',
 ].map((string, index) =>
-  Obj.make(DataType.Message, {
+  Obj.make(Message.Message, {
     created: new Date(Date.now() + 1_000 * index).toISOString(),
     sender,
     blocks: [{ _tag: 'transcript', started: new Date(Date.now() + 1_000 * index).toISOString(), text: string }],
@@ -99,7 +98,7 @@ describe.skip('SentenceNormalization', () => {
     }
 
     log.info('sentences', {
-      originalMessages: JSON.stringify(messages, null, 2),
+      messages: JSON.stringify(messages, null, 2),
       sentences: JSON.stringify(sentences, null, 2),
     });
     throw new Error('test');
@@ -108,7 +107,7 @@ describe.skip('SentenceNormalization', () => {
   test.only('queue', { timeout: 120_000 }, async () => {
     // Create queue.
     // TODO(dmaretskyi): Use space.queues.create() instead.
-    const queue = new MemoryQueue<DataType.Message>(createQueueDXN());
+    const queue = new MemoryQueue<Message.Message>(createQueueDXN());
     const ctx = new Context();
     let idx = 0;
     scheduleTaskInterval(
@@ -133,10 +132,6 @@ describe.skip('SentenceNormalization', () => {
 
     // Start normalizer.
     await normalizer.open();
-    effect(() => {
-      log.info('normalizer');
-      log.info(JSON.stringify(queue.objects, null, 2));
-    });
 
     await new Promise(() => {});
   });

package/src/segments-normalization/normalization.ts

@@ -2,85 +2,47 @@
 // Copyright 2025 DXOS.org
 //
 
-// ISSUE(burdon): defineFunction
-// @ts-nocheck
-
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { AiService, DEFAULT_EDGE_MODEL } from '@dxos/ai';
-import { AiSession } from '@dxos/assistant';
-import { Obj } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Operation } from '@dxos/operation';
 import { trim } from '@dxos/util';
 
-const MessageWithRangeId = Schema.extend(
-  DataType.Message,
-  Schema.Struct({
-    // TODO(mykola): Move to meta in DataType.Message. Use `DataType.Message` instead.
-    rangeId: Schema.optional(Schema.Array(Schema.String)).annotations({
-      description: 'The IDs of the messages that contain the sentences.',
+import {
+  SentenceNormalization,
+  SentenceNormalizationOutput,
+  type MessageWithRangeIdType,
+  type SentenceNormalizationInputType,
+} from '../operations/definitions';
+
+export type MessageWithRangeId = MessageWithRangeIdType;
+
+/** @deprecated Use SentenceNormalizationInputType */
+export type NormalizationInput = SentenceNormalizationInputType;
+
+/** @deprecated Use SentenceNormalizationOutput */
+export type NormalizationOutput = Schema.Schema.Type<typeof SentenceNormalizationOutput>;
+
+/**
+ * Sentence normalization for transcription.
+ * TODO(dmaretskyi): Reimplement using AiSession.run or LanguageModel.generateObject - runStructured was removed.
+ */
+export const sentenceNormalization = SentenceNormalization.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ messages }) {
+      log.info('input', { messages });
+      // TODO(dmaretskyi): runStructured was removed from AiSession. Reimplement using new API.
+      return yield* Effect.die(
+        new Error(
+          'Sentence normalization needs to be reimplemented - runStructured was removed from AiSession. Use AiSession.run or LanguageModel.generateObject.',
+        ),
+      );
     }),
-  }),
+  ),
 );
 
-export interface MessageWithRangeId extends Schema.Schema.Type<typeof MessageWithRangeId> {}
-
-export const NormalizationInput = Schema.Struct({
-  // TODO(mykola): Move to meta in DataType.Message. Use `DataType.Message` instead.
-  messages: Schema.Array(MessageWithRangeId).annotations({
-    description: 'Messages to normalize into sentences.',
-  }),
-});
-export interface NormalizationInput extends Schema.Schema.Type<typeof NormalizationInput> {}
-
-export const NormalizationOutput = Schema.Struct({
-  sentences: Schema.Array(MessageWithRangeId.pipe(Schema.mutable)).pipe(Schema.mutable).annotations({
-    description: 'The sentences of the transcript.',
-  }),
-});
-export interface NormalizationOutput extends Schema.Schema.Type<typeof NormalizationOutput> {}
-
-export const sentenceNormalization = defineFunction<NormalizationInput, NormalizationOutput>({
-  description: 'Post process of transcription for sentence normalization',
-  inputSchema: NormalizationInput,
-  outputSchema: NormalizationOutput,
-  handler: async ({ data: { messages }, context }) => {
-    log.info('input', { messages });
-    const ai = context.getService(AiService);
-    const session = new AiSession({ operationModel: 'configured' });
-
-    // TODO(dmaretskyi): This got broken after effect-ai transition.
-    const response = session.runStructured(NormalizationOutput, {
-      generationOptions: {
-        model: DEFAULT_EDGE_MODEL,
-      },
-      client: ai.client,
-      tools: [],
-      artifacts: [],
-      history: [
-        Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender: {
-            role: 'user',
-          },
-          blocks: messages.map((message) => ({ _tag: 'text', text: JSON.stringify(message) }) as const),
-        }),
-      ],
-      prompt,
-    }) as any;
-
-    response.sentences.forEach((sentence) => {
-      sentence.id = ObjectId.random();
-    });
-    log.info('response', { response });
-    return response;
-  },
-});
-
-const prompt = trim`
+const _unusedPrompt = trim`
   You are observing a real-time transcript of a single person speaking.
   The transcription is delivered in chunks of 10 seconds or less. As a result, individual sentences may be split across multiple messages, or multiple sentences may appear within a single message. Additionally, because this is real-time transcription, punctuation and capitalization may be incorrect or missing.
 
@@ -89,7 +51,7 @@ const prompt = trim`
 
   # Input Format:
     - The input is an array of messages that contain transcription blocks.
-    - Each message is a DataType.Message, as described in the output format.
+    - Each message is a Message.Message, as described in the output format.
 
   # Output Format:
     - You have been provided with the tool that defines the output format; make sure to query it.

package/src/segments-normalization/utils.ts

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type DataType } from '@dxos/schema';
+import { type Actor } from '@dxos/types';
 
-export const getActorId = (actor: DataType.Actor) => {
+export const getActorId = (actor: Actor.Actor) => {
   return actor.identityDid || actor.identityKey || actor.email || actor.name || '';
 };

package/src/testing/testing.ts

@@ -11,13 +11,13 @@ import { Filter, type Queue } from '@dxos/client/echo';
 import { Context } from '@dxos/context';
 import { type Key, Obj, Ref, Type } from '@dxos/echo';
 import { createQueueDXN } from '@dxos/echo/internal';
-import { FunctionExecutor, ServiceContainer } from '@dxos/functions';
 import { IdentityDid } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { faker } from '@dxos/random';
 import { type Space, useQueue } from '@dxos/react-client/echo';
-import { DataType } from '@dxos/schema';
-import { Testing, seedTestData } from '@dxos/schema/testing';
+import { TestSchema } from '@dxos/schema/testing';
+import { type ContentBlock, Message, Organization, Person } from '@dxos/types';
+import { seedTestData } from '@dxos/types/testing';
 
 // TODO(burdon): Reconcile with plugin-markdown. Move to @dxos/schema/testing.
 export const TestItem = Schema.Struct({
@@ -30,15 +30,15 @@ export const TestItem = Schema.Struct({
     description: 'Product description',
   }),
 }).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Test',
+  Type.object({
+    typename: 'org.dxos.type.test',
     version: '0.1.0',
   }),
 );
 
 // TODO(wittjosiah): Make builder generic and reuse for all message types.
 abstract class AbstractMessageBuilder {
-  abstract createMessage(numSegments?: number): Promise<DataType.Message>;
+  abstract createMessage(numSegments?: number): Promise<Message.Message>;
 }
 
 /**
@@ -59,19 +59,24 @@ export class MessageBuilder extends AbstractMessageBuilder {
     super();
   }
 
-  override async createMessage(numSegments = 1): Promise<DataType.Message> {
-    return Obj.make(DataType.Message, {
+  override async createMessage(numSegments = 1): Promise<Message.Message> {
+    return Obj.make(Message.Message, {
       created: this.next().toISOString(),
       sender: faker.helpers.arrayElement(this.users),
       blocks: Array.from({ length: numSegments }).map(() => this.createBlock()),
     });
   }
 
-  createBlock(): DataType.MessageBlock.Transcript {
+  createBlock(): ContentBlock.Transcript {
     let text = faker.lorem.paragraph();
     if (this._space) {
       const label = faker.commerce.productName();
-      const obj = this._space.db.add(Obj.make(TestItem, { title: label, description: faker.lorem.paragraph() }));
+      const obj = this._space.db.add(
+        Obj.make(TestItem, {
+          title: label,
+          description: faker.lorem.paragraph(),
+        }),
+      );
       const dxn = Ref.make(obj).dxn.toString();
       const words = text.split(' ');
       words.splice(Math.floor(Math.random() * words.length), 0, `[${label}](${dxn})`);
@@ -93,17 +98,9 @@ export class MessageBuilder extends AbstractMessageBuilder {
 
 // TODO(burdon): Reconcile with BlockBuilder.
 class EntityExtractionMessageBuilder extends AbstractMessageBuilder {
-  executor = new FunctionExecutor(
-    new ServiceContainer().setServices({
-      // ai: {
-      //   client: this.AiService,
-      // },
-    }),
-  );
-
   space: Space | undefined;
   currentMessage: number = 0;
-  transcriptMessages: DataType.Message[] = [];
+  transcriptMessages: Message.Message[] = [];
 
   async connect(space: Space): Promise<void> {
     this.space = space;
@@ -111,14 +108,18 @@ class EntityExtractionMessageBuilder extends AbstractMessageBuilder {
     this.transcriptMessages = transcriptMessages;
   }
 
-  override async createMessage(): Promise<DataType.Message> {
+  override async createMessage(): Promise<Message.Message> {
     if (!this.space) {
       throw new Error('Space not connected');
     }
 
-    const { objects } = await this.space.db
+    const objects = await this.space.db
       .query(
-        Filter.or(Filter.type(DataType.Person), Filter.type(DataType.Organization), Filter.type(Testing.DocumentType)),
+        Filter.or(
+          Filter.type(Person.Person),
+          Filter.type(Organization.Organization),
+          Filter.type(TestSchema.DocumentType),
+        ),
       )
       .run();
 
@@ -129,7 +130,6 @@ class EntityExtractionMessageBuilder extends AbstractMessageBuilder {
 
     const { message: enhancedMessage } = await processTranscriptMessage({
       input: { message },
-      executor: this.executor,
       function: extractionAnthropicFunction,
     });
 
@@ -142,7 +142,7 @@ type UseTestTranscriptionQueue = (
   queueId?: Key.ObjectId,
   running?: boolean,
   interval?: number,
-) => Queue<DataType.Message> | undefined;
+) => Queue<Message.Message> | undefined;
 
 /**
  * Test transcriptionqueue.
@@ -155,7 +155,7 @@ export const useTestTranscriptionQueue: UseTestTranscriptionQueue = (
 ) => {
   // TODO(dmaretskyi): Use space.queues.create() instead.
   const queueDxn = useMemo(() => (space ? createQueueDXN(space.id, queueId) : undefined), [space, queueId]);
-  const queue = useQueue<DataType.Message>(queueDxn);
+  const queue = useQueue<Message.Message>(queueDxn);
   const builder = useMemo(() => new MessageBuilder(space), [space]);
 
   useEffect(() => {
@@ -165,7 +165,7 @@ export const useTestTranscriptionQueue: UseTestTranscriptionQueue = (
 
     const i = setInterval(() => {
       void builder.createMessage(Math.ceil(Math.random() * 3)).then(async (message) => {
-        await queue.append([Obj.make(DataType.Message, message)]);
+        await queue.append([Obj.make(Message.Message, message)]);
       });
     }, interval);
     return () => clearInterval(i);
@@ -186,7 +186,7 @@ export const useTestTranscriptionQueueWithEntityExtraction: UseTestTranscription
 ) => {
   // TODO(dmaretskyi): Use space.queues.create() instead.
   const queueDxn = useMemo(() => (space ? createQueueDXN(space.id, queueId) : undefined), [space, queueId]);
-  const queue = useQueue<DataType.Message>(queueDxn);
+  const queue = useQueue<Message.Message>(queueDxn);
   const [builder] = useState(() => new EntityExtractionMessageBuilder());
 
   useEffect(() => {
@@ -203,7 +203,7 @@ export const useTestTranscriptionQueueWithEntityExtraction: UseTestTranscription
       ctx,
       async () => {
         const message = await builder.createMessage();
-        void queue.append([Obj.make(DataType.Message, message)]);
+        void queue.append([Obj.make(Message.Message, message)]);
       },
       interval,
     );

package/src/transcriber/media-stream-recorder.ts

@@ -19,7 +19,7 @@ const initializeExtendableMediaRecorder = async () => {
   await register(await connect());
 };
 
-export type MediaStreamRecorderParams = {
+export type MediaStreamRecorderProps = {
   mediaStreamTrack: MediaStreamTrack;
   config: {
     interval: number;
@@ -37,12 +37,12 @@ export class MediaStreamRecorder implements AudioRecorder {
   /**
    * Default MediaRecorder implementation do not support wav encoding.
    */
-  private readonly _config: MediaStreamRecorderParams['config'];
+  private readonly _config: MediaStreamRecorderProps['config'];
   private _mediaRecorder?: IMediaRecorder = undefined;
   private _header?: Uint8Array = undefined;
   private _onChunk?: (chunk: AudioChunk) => void;
 
-  constructor({ mediaStreamTrack, config }: MediaStreamRecorderParams) {
+  constructor({ mediaStreamTrack, config }: MediaStreamRecorderProps) {
     this._mediaStreamTrack = mediaStreamTrack;
     this._config = config;
   }

package/src/transcriber/transcriber.browser.test.ts

@@ -10,9 +10,9 @@ import { WaveFile } from 'wavefile';
 
 import { Trigger } from '@dxos/async';
 import { log } from '@dxos/log';
-import { type DataType } from '@dxos/schema';
 import { openAndClose } from '@dxos/test-utils';
 import { TRACE_PROCESSOR, trace } from '@dxos/tracing';
+import { type ContentBlock } from '@dxos/types';
 
 import { type AudioChunk, type AudioRecorder, Transcriber } from '../transcriber';
 import { mergeFloat64Arrays } from '../util';
@@ -94,7 +94,7 @@ describe.skip('Transcriber', () => {
   });
 
   test.skip('transcription of audio recording', { timeout: 10_000 }, async () => {
-    const trigger = new Trigger<DataType.MessageBlock.Transcript[]>({ autoReset: true });
+    const trigger = new Trigger<ContentBlock.Transcript[]>({ autoReset: true });
     const recorder = new MockAudioRecorder({
       buffer: await readFile('test.wav'),
       chunkDuration: 3_000,
@@ -128,7 +128,7 @@ describe.skip('Transcriber', () => {
   });
 
   test.skip('transcription of audio recording with overlapping chunks', { timeout: 20_000 }, async () => {
-    const trigger = new Trigger<DataType.MessageBlock.Transcript[]>({ autoReset: true });
+    const trigger = new Trigger<ContentBlock.Transcript[]>({ autoReset: true });
     const recorder = new MockAudioRecorder({
       buffer: await readFile('test.wav'),
       chunkDuration: 3_000,
@@ -213,7 +213,7 @@ class MockAudioRecorder implements AudioRecorder {
 
   @trace.span()
   async start(): Promise<void> {
-    log.info('start mock audio recorder', { wavParams: this.wav.fmt });
+    log.info('start mock audio recorder', { wavProps: this.wav.fmt });
     const now = Date.now();
     const samples = this.wav.getSamples();
     const sampleRate = this.wavConfig.sampleRate;