@dxos/plugin-transcription 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

package/src/components/Transcript/Transcript.tsx

@@ -1,93 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { type Space } from '@dxos/react-client/echo';
-import { type Identity } from '@dxos/react-client/halo';
-import { type ThemedClassName, useThemeContext } from '@dxos/react-ui';
-import {
-  autoScroll,
-  createBasicExtensions,
-  createMarkdownExtensions,
-  createThemeExtensions,
-  decorateMarkdown,
-  preview,
-  useTextEditor,
-} from '@dxos/react-ui-editor';
-import { mx } from '@dxos/react-ui-theme';
-import { type DataType } from '@dxos/schema';
-import { isNotFalsy } from '@dxos/util';
-
-import { type SerializationModel } from '../../model';
-import { type Transcript } from '../../types';
-
-import { transcript } from './transcript-extension';
-
-// TODO(thure): Move this?
-export const renderByline =
-  (identities: Identity[]) =>
-  (message: DataType.Message, index: number, debug = false): string[] => {
-    if (message.sender.role === 'assistant') {
-      // Start/stop block.
-      return [message.blocks.find((block) => block._tag === 'transcript')?.text ?? '', ''];
-    }
-
-    // TODO(burdon): Use link/reference markup for users (with popover).
-    // TODO(burdon): Color and avatar.
-    const identity = identities.find((identity) => identity.did === message.sender.identityDid);
-    const name =
-      identity?.profile?.displayName ??
-      message.sender.contact?.target?.fullName ??
-      message.sender.name ??
-      message.sender.email ??
-      message.sender.identityDid;
-    const blocks = message.blocks.filter((block) => block._tag === 'transcript');
-    return [
-      // TODO(thure): Use an XML tag with the bits needed here.
-      `###### ${name}` + (debug ? ` [${index}]:${message.id}` : ''),
-      blocks.map((block) => block.text.trim()).join(' '),
-      '',
-    ];
-  };
-
-export type TranscriptViewProps = ThemedClassName<{
-  space?: Space;
-  transcript?: Transcript.Transcript;
-  model: SerializationModel<DataType.Message>;
-  // TODO(burdon): Are these still in use?
-  attendableId?: string;
-  ignoreAttention?: boolean;
-}>;
-
-/**
- * Transcript component implemented using the editor.
- */
-export const TranscriptView = ({ classNames, space, transcript: object, model }: TranscriptViewProps) => {
-  const { themeMode } = useThemeContext();
-  const { parentRef } = useTextEditor(() => {
-    return {
-      extensions: [
-        createBasicExtensions({ readOnly: true, lineWrapping: true, search: true }),
-        createMarkdownExtensions(),
-        createThemeExtensions({ themeMode }),
-        decorateMarkdown(),
-        preview(),
-        transcript({
-          model,
-          started: object?.started ? new Date(object.started) : undefined,
-        }),
-        autoScroll(),
-      ].filter(isNotFalsy),
-    };
-  }, [space, model]);
-
-  return (
-    <div
-      ref={parentRef}
-      className={mx('flex grow overflow-hidden container-max-width', classNames)}
-      data-popover-collision-boundary={true /* TODO(thure): Make this a constant and document it. */}
-    />
-  );
-};

package/src/components/Transcript/deprecated/OldTranscript.tsx

@@ -1,260 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { intervalToDuration } from 'date-fns/intervalToDuration';
-import { Schema } from 'effect';
-import { yieldOrContinue } from 'main-thread-scheduling';
-import React, { type FC, type WheelEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { type OnResizeCallback, useResizeDetector } from 'react-resize-detector';
-
-import { Type } from '@dxos/echo';
-import { IconButton, type ThemedClassName, useTranslation } from '@dxos/react-ui';
-import { useAttention } from '@dxos/react-ui-attention';
-import {
-  type DxGridAxisMeta,
-  type DxGridCellValue,
-  type DxGridElement,
-  type DxGridPlaneCells,
-  Grid,
-  toPlaneCellIndex,
-} from '@dxos/react-ui-grid';
-import { mx } from '@dxos/react-ui-theme';
-
-import { TRANSCRIPTION_PLUGIN } from '../../../meta';
-
-/**
- * Transcription fragment.
- */
-const TranscriptSegment = Schema.Struct({
-  // TODO(burdon): TS from service is not Unix TS (x1000).
-  started: Schema.String,
-  text: Schema.String,
-});
-
-type TranscriptSegment = Schema.Schema.Type<typeof TranscriptSegment>;
-
-/**
- * Transcription block (from single speaker).
- */
-const TranscriptBlock = Schema.Struct({
-  id: Schema.String,
-  authorName: Schema.optional(Schema.String), // TODO(burdon): Replace with identityDid.
-  authorHue: Schema.optional(Schema.String), // TOOD(burdon): Remove.
-  segments: Schema.Array(TranscriptSegment),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/TranscriptBlock',
-    version: '0.1.0',
-  }),
-);
-
-type TranscriptBlock = Schema.Schema.Type<typeof TranscriptBlock>;
-
-// TODO(burdon): Actions (e.g., mark, summarize, translate, label, delete).
-
-const lineHeight = 20;
-const cellSpacing = 8 + 2;
-const timestampColumnWidth = 68;
-
-const authorClasses = 'font-medium text-base leading-[20px]';
-const timestampClasses = 'text-xs leading-[20px] text-description pie-0 tabular-nums';
-const segmentTextClasses = 'text-sm whitespace-normal hyphens-auto';
-const measureClasses = mx(
-  // NOTE(thure): The `inline-start` value must equal `timestampColumnWidth` plus grid’s gap (1px)
-  'absolute inline-start-[69px] inline-end-0 invisible z-[-1] border',
-  'pli-[--dx-grid-cell-padding-inline] plb-[--dx-grid-cell-padding-block] leading-[20px]',
-  segmentTextClasses,
-);
-
-const rowDefault = {
-  grid: { size: lineHeight + cellSpacing },
-};
-
-type QueueRows = [number, number][];
-
-const mapTranscriptQueue = (blocks?: TranscriptBlock[]): QueueRows => {
-  if (!blocks || !Array.isArray(blocks) || blocks.length === 0) {
-    return [];
-  } else {
-    return blocks.flatMap((block, blockIndex) => {
-      return [
-        [blockIndex, -1],
-        ...block.segments.map((segment, segmentIndex) => {
-          return [blockIndex, segmentIndex] as [number, number];
-        }),
-      ];
-    });
-  }
-};
-
-const pad = (n = 0) => String(n).padStart(2, '0');
-
-const formatTimestamp = (start: Date, end: Date) => {
-  const { hours, minutes, seconds } = intervalToDuration({ start, end });
-  return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`;
-};
-
-const measureRows = async (
-  host: HTMLDivElement,
-  blocks: TranscriptBlock[],
-  queueMap: QueueRows,
-  signal: AbortSignal,
-) => {
-  const result: DxGridAxisMeta = { grid: {} };
-  for (let row = 0; row < queueMap.length; row++) {
-    await yieldOrContinue('smooth', signal);
-    const [blockIndex, segmentIndex] = queueMap[row];
-    if (segmentIndex < 0) {
-      result.grid[row] = { size: lineHeight + cellSpacing };
-    } else {
-      host.textContent = blocks[blockIndex]!.segments[segmentIndex]!.text;
-      result.grid[row] = { size: host.offsetHeight };
-    }
-  }
-  return result;
-};
-
-export type TranscriptViewProps = ThemedClassName<{
-  blocks?: TranscriptBlock[];
-  attendableId?: string;
-  ignoreAttention?: boolean;
-}>;
-
-/**
- * @@deprecated
- */
-export const Transcript: FC<TranscriptViewProps> = ({ classNames, blocks, attendableId, ignoreAttention }) => {
-  const { t } = useTranslation(TRANSCRIPTION_PLUGIN);
-  const [dxGrid, setDxGrid] = useState<DxGridElement | null>(null);
-  const [rows, setRows] = useState<DxGridAxisMeta | undefined>(undefined);
-  const [columns, setColumns] = useState<DxGridAxisMeta | undefined>(undefined);
-
-  const queueMap = useMemo(() => mapTranscriptQueue(blocks), [blocks]);
-
-  const { hasAttention } = useAttention(attendableId);
-  const [autoScroll, setAutoScroll] = useState(true);
-  const handleWheel = useCallback(
-    (event: WheelEvent) => {
-      setAutoScroll(false);
-      if (!ignoreAttention && !hasAttention) {
-        event.stopPropagation();
-      }
-    },
-    [hasAttention, ignoreAttention],
-  );
-
-  const abortControllerRef = useRef<AbortController>();
-
-  const handleResize = useCallback(
-    async ({ entry }: { entry: { target: HTMLDivElement } | null }) => {
-      if (entry?.target && Array.isArray(blocks) && blocks[0] && queueMap) {
-        abortControllerRef.current?.abort();
-        abortControllerRef.current = new AbortController();
-        setColumns({ grid: { 0: { size: timestampColumnWidth }, 1: { size: entry.target.offsetWidth } } });
-        return measureRows(entry.target, blocks, queueMap, abortControllerRef.current.signal)
-          .then(setRows)
-          .catch(() => {
-            // Aborted mid-measurement by new size.
-          });
-      }
-    },
-    [blocks, queueMap],
-  );
-
-  const { width, ref: measureRef } = useResizeDetector({
-    onResize: handleResize as OnResizeCallback,
-    refreshOptions: { leading: true },
-  });
-
-  useEffect(() => {
-    if (queueMap.length !== Object.keys(rows?.grid ?? {}).length) {
-      void handleResize({ entry: { target: measureRef.current } }).then(() => {
-        if (autoScroll) {
-          // TODO(thure): Implement a deterministic way to do this when `rows` has fully settled and grid has a new `maxPosBlock`.
-          setTimeout(() => dxGrid?.scrollToEndRow(), 50);
-        }
-      });
-    }
-  }, [blocks, queueMap, width, autoScroll]);
-
-  useEffect(() => {
-    if (dxGrid && Array.isArray(blocks) && blocks[0]) {
-      const transcriptStart = blocks[0]!.segments[0]!.started;
-      dxGrid.getCells = (range, plane) => {
-        switch (plane) {
-          case 'grid': {
-            const cells: DxGridPlaneCells = {};
-            for (let row = range.start.row; row <= range.end.row && row < queueMap.length; row++) {
-              const [blockIndex, segmentIndex] = queueMap[row];
-
-              cells[toPlaneCellIndex({ col: 0, row })] = {
-                readonly: true,
-                value:
-                  segmentIndex < 0
-                    ? formatTimestamp(
-                        new Date(transcriptStart),
-                        new Date(blocks[blockIndex]!.segments[Math.max(0, segmentIndex)]!.started),
-                      )
-                    : '',
-                className: timestampClasses,
-              } satisfies DxGridCellValue;
-
-              cells[toPlaneCellIndex({ col: 1, row })] = (
-                segmentIndex < 0
-                  ? {
-                      readonly: true,
-                      accessoryHtml: `<span data-hue="${blocks[blockIndex]!.authorHue}" class="dx-text-hue">${blocks[blockIndex]!.authorName}</span>`,
-                      className: authorClasses,
-                    }
-                  : {
-                      readonly: true,
-                      value: blocks[blockIndex]!.segments[segmentIndex]!.text,
-                      className: segmentTextClasses,
-                    }
-              ) satisfies DxGridCellValue;
-            }
-            return cells;
-          }
-          default:
-            return {};
-        }
-      };
-    }
-  }, [dxGrid, blocks]);
-
-  const handleScrollToEnd = useCallback(() => {
-    setAutoScroll(true);
-    dxGrid?.scrollToEndRow();
-  }, [dxGrid, autoScroll]);
-
-  return (
-    <div role='none' className={mx('relative min-bs-0', classNames)}>
-      <Grid.Root id={`${attendableId}--transcript`}>
-        <Grid.Content
-          limitColumns={2}
-          limitRows={queueMap.length}
-          columns={columns}
-          rows={rows}
-          rowDefault={rowDefault}
-          onWheel={handleWheel}
-          className='[--dx-grid-base:var(--dx-baseSurface)] [--dx-grid-lines:var(--dx-baseSurface)] [&_.dx-grid]:min-bs-0 [&_.dx-grid]:min-is-0 [&_.dx-grid]:select-auto'
-          ref={setDxGrid}
-        />
-      </Grid.Root>
-      <div role='none' {...{ inert: '' }} aria-hidden className={measureClasses} ref={measureRef} />
-      <IconButton
-        icon='ph--arrow-line-down--regular'
-        iconOnly
-        label={t('scroll to end label')}
-        tooltipSide='left'
-        data-state={autoScroll ? 'invisible' : 'visible'}
-        classNames={[
-          'absolute inline-end-2 block-end-2 opacity-0 pointer-events-none',
-          'data-[state="visible"]:pointer-events-auto data-[state="visible"]:opacity-100 transition-opacity',
-        ]}
-        onClick={handleScrollToEnd}
-      />
-    </div>
-  );
-};

package/src/components/TranscriptContainer.tsx

@@ -1,36 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import React from 'react';
-
-import { fullyQualifiedId, getSpace } from '@dxos/client/echo';
-import { useMembers, useQueue } from '@dxos/react-client/echo';
-import { StackItem } from '@dxos/react-ui-stack';
-import { type DataType } from '@dxos/schema';
-
-import { useQueueModelAdapter } from '../hooks';
-import { type Transcript } from '../types';
-
-import { TranscriptView, renderByline } from './Transcript';
-
-export type TranscriptionContainerProps = {
-  role: string;
-  transcript: Transcript.Transcript;
-};
-
-export const TranscriptionContainer = ({ transcript }: TranscriptionContainerProps) => {
-  const attendableId = fullyQualifiedId(transcript);
-  const space = getSpace(transcript);
-  const members = useMembers(space?.key).map((member) => member.identity);
-  const queue = useQueue<DataType.Message>(transcript.queue.dxn, { pollInterval: 1_000 });
-  const model = useQueueModelAdapter(renderByline(members), queue);
-
-  return (
-    <StackItem.Content>
-      <TranscriptView attendableId={attendableId} space={space} model={model} transcript={transcript} />
-    </StackItem.Content>
-  );
-};
-
-export default TranscriptionContainer;

package/src/components/stories/TranscriptionStory.tsx

@@ -1,45 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import '@dxos-theme';
-
-import React, { type Dispatch, type FC, type RefObject, type SetStateAction } from 'react';
-
-import { useSpace } from '@dxos/react-client/echo';
-import { IconButton, Toolbar } from '@dxos/react-ui';
-import { ScrollContainer } from '@dxos/react-ui-components';
-import { type DataType } from '@dxos/schema';
-
-import { type SerializationModel } from '../../model';
-import { TranscriptView } from '../Transcript';
-
-export const TranscriptionStory: FC<{
-  model: SerializationModel<DataType.Message>;
-  disabled?: boolean;
-  running: boolean;
-  onRunningChange: Dispatch<SetStateAction<boolean>>;
-  audioRef?: RefObject<HTMLAudioElement>;
-}> = ({ model, running, onRunningChange, audioRef, disabled }) => {
-  const space = useSpace();
-
-  return (
-    <div className='flex flex-col w-[30rem]'>
-      {audioRef && <audio ref={audioRef} autoPlay />}
-      <Toolbar.Root>
-        <IconButton
-          iconOnly
-          disabled={disabled}
-          icon={running ? 'ph--pause--regular' : 'ph--play--regular'}
-          label={running ? 'Pause' : 'Play'}
-          onClick={() => onRunningChange((running) => !running)}
-        />
-      </Toolbar.Root>
-      <ScrollContainer.Root pin>
-        <ScrollContainer.Content>
-          <TranscriptView space={space} model={model} />
-        </ScrollContainer.Content>
-      </ScrollContainer.Root>
-    </div>
-  );
-};

package/src/functions/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export { default as open } from './open';
-export { default as summarize } from './summarize';

package/src/functions/open.ts

@@ -1,37 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Effect, Schema } from 'effect';
-
-import { ArtifactId } from '@dxos/assistant';
-import { Obj } from '@dxos/echo';
-import { DatabaseService, QueueService, defineFunction } from '@dxos/functions';
-import { DataType } from '@dxos/schema';
-
-import { renderByline } from '../components';
-import { Transcript } from '../types';
-
-export default defineFunction({
-  name: 'dxos.org/function/transcription/open',
-  description: 'Opens and reads the contents of a transcription object.',
-  inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
-      description: 'The ID of the transcription object.',
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    content: Schema.String,
-  }),
-  handler: Effect.fn(function* ({ data: { id } }) {
-    const transcript = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Transcript.Transcript);
-    const { dxn } = yield* Effect.promise(() => transcript.queue.load());
-    const queue = yield* QueueService.getQueue(dxn);
-    yield* Effect.promise(() => queue?.queryObjects());
-    const content = queue?.objects
-      .filter((message) => Obj.instanceOf(DataType.Message, message))
-      .flatMap((message, index) => renderByline([])(message, index))
-      .join('\n\n');
-    return { content };
-  }),
-});

package/src/functions/summarize.ts

@@ -1,97 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Array, Effect, Layer, Option, Schema, pipe } from 'effect';
-
-import { AiService, ConsolePrinter, ToolExecutionService, ToolResolverService } from '@dxos/ai';
-import { AiSession, GenerationObserver } from '@dxos/assistant';
-import { TracingService, defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
-
-/**
- * Summarize a transcript of a meeting.
- */
-export default defineFunction({
-  name: 'dxos.org/function/transcription/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 summary = pipe(
-        result,
-        Array.findLast((msg) => msg.sender.role === 'assistant' && msg.blocks.some((block) => block._tag === 'text')),
-        Option.flatMap((msg) =>
-          pipe(
-            msg.blocks,
-            Array.findLast((block) => block._tag === 'text'),
-            Option.map((block) => block.text),
-          ),
-        ),
-        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,
-      ),
-    ),
-  ),
-});
-
-const systemPrompt = trim`
-  You are a helpful assistant that summarizes transcripts of meetings.
-
-  # Goal
-  Create a markdown summary of the meeting transcript with text notes provided.
-  Notes are very important so make sure to include them in the summary if they contain meaningful information.
-
-  # Formatting
-  - Format the summary as a markdown document without extra comments like "Here is the summary of the transcript:".
-  - Use markdown formatting for headings and bullet points.
-  - Format the summary as a list of key points and takeaways.
-  - All names of people should be in bold.
-
-  # Note Taking
-  - Correlate items in the summary with the person of origin to build a coherent narrative.
-  - Include short quotes verbatim where appropriate. Especially when concerned with design decisions and problem descriptions.
-
-  # Tasks
-  At the end of the summary include tasks.
-  Extract only the tasks that are:
-  - Directly actionable.
-  - Clearly assigned to a person or team (or can easily be inferred).
-  - Strongly implied by the conversation and/or user note (no speculative tasks).
-  - Specific enough that someone reading them would know exactly what to do next.
-
-  Format all tasks as markdown checkboxes using the syntax:
-  - [ ] Task description.
-
-  Additional information can be included (indented).
-
-  If no actionable tasks are found, omit this tasks section.
-`;

package/src/segments-normalization/normalization.ts

@@ -1,115 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// ISSUE(burdon): defineFunction
-// @ts-nocheck
-
-import { Schema } from 'effect';
-
-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 { 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.',
-    }),
-  }),
-);
-
-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`
-  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.
-
-  # Task Description:
-    - Your task is to detect and reconstruct broken or incomplete sentences by merging segments into coherent, grammatically correct sentences where appropriate.
-
-  # 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.
-
-  # Output Format:
-    - You have been provided with the tool that defines the output format; make sure to query it.
-    - Do not output anything other than the expected format.
-
-  # Segment Handling Rules:
-    - Sort messages by timestamp.
-    - Leave ID of the first message in a sentence.
-    - Each divided sentence should be added to the output as a separate message or block within existing messages, preserving the original order.
-    - If one message contains multiple sentences, you should not split them.
-    - The last sentence may be incomplete; it should still be output as a separate block or message.
-    - Keep track of the original timestamps of the messages and blocks and, use the timestamp of the first message/block of a sentence as the 'started' field of the merged message.
-    - The 'rangeId' field of the merged message should include 'messageId'-s and 'rangeId'-s of all messages that have been used to construct this message.
-
-  # Punctuation and Capitalization:
-    - Do not rely on the original punctuation and capitalization—they may be incorrect.
-    - Use logical reasoning to apply appropriate punctuation (e.g., period, comma, question mark, exclamation mark) and capitalization.
-
-  # Restrictions:
-    - Do not alter the order of the original messages; maintain the natural flow of speech.
-    - Do not interpret or infer meaning beyond reconstructing sentences.
-    - Do not add or remove any words or phrases.
-`;