@dxos/plugin-transcription 0.8.2-main.fbd8ed0 → 0.8.2-staging.4d6ad0f

package/src/components/stories/useIsSpeaking.tsx

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { useEffect, useMemo, useState } from 'react';
+
+import { scheduleTask } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { SpeakingMonitor } from '@dxos/plugin-thread';
+
+export const useIsSpeaking = (track?: MediaStreamTrack) => {
+  const [isSpeaking, setIsSpeaking] = useState(false);
+  const speakingMonitor = useMemo(() => {
+    if (!track) {
+      return;
+    }
+    return new SpeakingMonitor(track);
+  }, [track]);
+
+  useEffect(() => {
+    if (!speakingMonitor) {
+      return;
+    }
+
+    const ctx = new Context();
+    scheduleTask(ctx, async () => {
+      speakingMonitor.speakingChanged.on(ctx, () => setIsSpeaking(speakingMonitor.isSpeaking));
+      await speakingMonitor.open();
+      ctx.onDispose(() => speakingMonitor.close());
+    });
+
+    return () => {
+      void ctx.dispose();
+    };
+  }, [speakingMonitor]);
+
+  return isSpeaking;
+};

package/src/hooks/useAudioFile.ts

@@ -4,6 +4,8 @@
 
 import { useEffect, useState } from 'react';
 
+import { scheduleTask } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { log } from '@dxos/log';
 
 export type UseAudioState = {
@@ -12,14 +14,22 @@ export type UseAudioState = {
   track?: MediaStreamTrack;
 };
 
-export const useAudioFile = (audioUrl: string): UseAudioState => {
+export const useAudioFile = (audioUrl: string, constraints?: MediaTrackConstraints): UseAudioState => {
   const [{ audio, stream, track }, setStream] = useState<UseAudioState>({});
   useEffect(() => {
-    const t = setTimeout(async () => {
+    const ctx = new Context();
+
+    scheduleTask(ctx, async () => {
       const response = await fetch(audioUrl);
       const blob = await response.blob();
+      const objectUrl = URL.createObjectURL(blob);
+      ctx.onDispose(() => {
+        URL.revokeObjectURL(objectUrl);
+      });
+
       const audio = new Audio();
-      audio.src = URL.createObjectURL(blob);
+      audio.src = objectUrl;
+
       await new Promise<void>((resolve, reject) => {
         audio.addEventListener(
           'error',
@@ -31,23 +41,41 @@ export const useAudioFile = (audioUrl: string): UseAudioState => {
         );
         audio.addEventListener(
           'canplay',
-          () => {
+          async () => {
             log.info('starting...');
-            resolve();
+            try {
+              // Try to play the audio
+              await audio.play();
+              resolve();
+            } catch (playError) {
+              log.error('Play failed', { playError });
+              // Still resolve as the audio is ready, even if autoplay failed.
+              resolve();
+            }
           },
           { once: true },
         );
         audio.load();
       });
 
-      const ctx = new AudioContext();
+      const audioCtx = new AudioContext();
+
+      // Resume AudioContext if it's suspended.
+      if (audioCtx.state === 'suspended') {
+        await audioCtx.resume();
+      }
 
-      const destination = ctx.createMediaStreamDestination();
+      const destination = audioCtx.createMediaStreamDestination();
       destination.channelCount = 1;
 
-      const source = ctx.createMediaElementSource(audio);
+      const source = audioCtx.createMediaElementSource(audio);
       source.connect(destination);
+      const track = destination.stream.getAudioTracks()[0];
+      if (constraints) {
+        await track.applyConstraints(constraints).catch((err) => log.catch(err));
+      }
 
+      // Also connect to speakers so audio is audible.
       setStream({
         audio,
         stream: destination.stream,
@@ -55,7 +83,9 @@ export const useAudioFile = (audioUrl: string): UseAudioState => {
       });
     });
 
-    return () => clearTimeout(t);
+    return () => {
+      void ctx.dispose();
+    };
   }, [audioUrl]);
 
   return { audio, stream, track };

package/src/hooks/useAudioTrack.ts

@@ -8,7 +8,7 @@ import { useEffect, useState } from 'react';
  *
  */
 // TODO(burdon): Reconcile with react-ui-sfx and plugin-calls.
-export const useAudioTrack = (active?: boolean): MediaStreamTrack | undefined => {
+export const useAudioTrack = (active?: boolean, constraints?: MediaTrackConstraints): MediaStreamTrack | undefined => {
   const [track, setTrack] = useState<MediaStreamTrack>();
   useEffect(() => {
     if (!active) {
@@ -19,7 +19,7 @@ export const useAudioTrack = (active?: boolean): MediaStreamTrack | undefined =>
 
     const initAudio = async () => {
       const audio = new Audio();
-      audio.srcObject = await navigator.mediaDevices.getUserMedia({ audio: true });
+      audio.srcObject = await navigator.mediaDevices.getUserMedia({ audio: constraints ?? true });
       const [track] = audio.srcObject.getAudioTracks();
       if (track) {
         setTrack(track);

package/src/hooks/useQueueModelAdapter.ts

@@ -26,7 +26,7 @@ export const useQueueModelAdapter = <T extends Chunk>(
     }
 
     const update = () => {
-      for (const block of queue?.items ?? []) {
+      for (const block of queue?.objects ?? []) {
         model.appendChunk(block);
       }
 
@@ -51,13 +51,15 @@ export const useQueueModelAdapter = <T extends Chunk>(
 
   // TODO(burdon): Can we listen for queue events?
   useEffect(() => {
-    if (!loaded || !queue || model.chunks.length === queue.items.length) {
+    if (!loaded || !queue || model.chunks.length === queue.objects.length) {
       return;
     }
 
-    const chunk = queue.items[queue.items.length - 1];
-    model.appendChunk(chunk);
-  }, [model, loaded, queue?.items.length]);
+    const chunk = queue.objects.at(-1);
+    if (chunk) {
+      model.appendChunk(chunk);
+    }
+  }, [model, loaded, queue?.objects.length]);
 
   return model;
 };

package/src/hooks/useTranscriber.ts

@@ -15,7 +15,8 @@ import { type Transcriber } from '../transcriber';
 export const useTranscriber = ({
   audioStreamTrack,
   onSegments,
-  config,
+  transcriberConfig,
+  recorderConfig,
 }: Partial<TranscriptionCapabilities.GetTranscriberProps>) => {
   const [getTranscriber] = useCapabilities(TranscriptionCapabilities.Transcriber);
 
@@ -25,8 +26,8 @@ export const useTranscriber = ({
       return undefined;
     }
 
-    return getTranscriber({ audioStreamTrack, onSegments, config });
-  }, [audioStreamTrack, onSegments, getTranscriber, config]);
+    return getTranscriber({ audioStreamTrack, onSegments, transcriberConfig, recorderConfig });
+  }, [audioStreamTrack, onSegments, getTranscriber, transcriberConfig, recorderConfig]);
 
   useEffect(() => {
     return () => {

package/src/meta.ts

@@ -11,7 +11,7 @@ export const meta: PluginMeta = {
   name: 'Transcription',
   description: 'Voice transcription.',
   icon: 'ph--microphone--regular',
-  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-transcription',
-  tags: ['experimental'],
+  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-transcription',
+  tags: ['labs'],
   screenshots: [],
 };

package/src/model/model.ts

@@ -104,7 +104,7 @@ export class SerializationModel<T extends Chunk> {
     });
   }
 
-  toJSON() {
+  toJSON(): { chunks: number; changes: number } {
     return {
       chunks: this._chunks.length,
       changes: this._changes.length,

package/src/segments-normalization/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './normalization';
+export * from './message-normalizer';
+export * from './utils';

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

@@ -0,0 +1,108 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+//
+// Copyright 2025 DXOS.org
+//
+
+import { effect } from '@preact/signals-core';
+
+import { asyncTimeout, DeferredTask } from '@dxos/async';
+import { LifecycleState, Resource } from '@dxos/context';
+import { type Queue } from '@dxos/echo-db';
+import { type FunctionExecutor } from '@dxos/functions';
+import { log } from '@dxos/log';
+import { type DataType } from '@dxos/schema';
+
+import { type MessageWithRangeId, sentenceNormalization } from './normalization';
+import { getActorId } from './utils';
+
+const PROCESSING_TIMEOUT = 20_000; // ms
+const MAX_RANGE_ID_COUNT = 10;
+
+export type SegmentsNormalizerParams = {
+  functionExecutor: FunctionExecutor;
+  queue: Queue<DataType.Message>;
+  startingCursor: QueueCursor;
+};
+
+// TODO(mykola): Use generic queue cursor from @dxos/protocols.
+export type QueueCursor = {
+  actorId: string;
+  timestamp: string;
+};
+
+// TODO(mykola): .
+export class MessageNormalizer extends Resource {
+  private readonly _functionExecutor: FunctionExecutor;
+  private _queue: Queue<DataType.Message>;
+  private _cursor: QueueCursor;
+  private _messagesToProcess: MessageWithRangeId[] = [];
+  private _normalizationTask?: DeferredTask;
+  private _lastProcessedMessageIds?: string[];
+
+  constructor({ functionExecutor, queue, startingCursor }: SegmentsNormalizerParams) {
+    super();
+    this._functionExecutor = functionExecutor;
+    this._queue = queue;
+    this._cursor = startingCursor;
+  }
+
+  protected override async _open(): Promise<void> {
+    this._normalizationTask = new DeferredTask(this._ctx, () => this._processMessages());
+    const unsubscribe = effect(() => {
+      if (this._lifecycleState !== LifecycleState.OPEN) {
+        return;
+      }
+
+      this._messagesToProcess = this._queue.objects.filter((message) => {
+        const actorId = getActorId(message.sender);
+        return actorId === this._cursor.actorId && message.created >= this._cursor.timestamp;
+      });
+
+      this._normalizationTask!.schedule();
+    });
+    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.
+  private async _processMessages(): Promise<void> {
+    const messages = this._messagesToProcess;
+    this._messagesToProcess = [];
+    if (
+      this._lastProcessedMessageIds &&
+      messages.every((message) => this._lastProcessedMessageIds!.includes(message.id))
+    ) {
+      return;
+    }
+
+    this._lastProcessedMessageIds = messages.map((message) => message.id);
+
+    try {
+      // TODO(mykola): Executor should support timeout.
+      const response = await asyncTimeout(
+        this._functionExecutor.invoke(sentenceNormalization, { messages }),
+        PROCESSING_TIMEOUT,
+      );
+
+      this._writeMessages(response.sentences);
+      this._lastProcessedMessageIds.push(...response.sentences.map((sentence) => sentence.id));
+      if (response.sentences.length === 1 && response.sentences.at(-1)!.rangeId!.length > MAX_RANGE_ID_COUNT) {
+        log.warn('Sentence is too long', { messages });
+        this._cursor.timestamp = new Date(new Date(response.sentences[0].created).getTime() + 1).toISOString();
+      }
+    } catch {
+      log.error('Failed to normalize segments', { messages });
+      // If processing failed, emit the segments as is.
+      this._writeMessages(messages);
+    }
+  }
+
+  private _writeMessages(messages: MessageWithRangeId[]): void {
+    log.info('writing messages', { messages });
+    const lastMessage = messages[messages.length - 1];
+    this._cursor.timestamp = lastMessage.created;
+    this._queue.append(messages);
+  }
+}

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

@@ -0,0 +1,142 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { effect } from '@preact/signals-core';
+import { describe, test } from 'vitest';
+
+import { AIServiceEdgeClient, OllamaClient } from '@dxos/ai';
+import { AI_SERVICE_ENDPOINT } from '@dxos/ai/testing';
+import { scheduleTaskInterval } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { MemoryQueue } from '@dxos/echo-db';
+import { createQueueDxn, ObjectId } from '@dxos/echo-schema';
+import { FunctionExecutor, ServiceContainer } from '@dxos/functions';
+import { log } from '@dxos/log';
+import { type DataType } from '@dxos/schema';
+
+import { MessageNormalizer } from './message-normalizer';
+import { type MessageWithRangeId, sentenceNormalization } from './normalization';
+import { getActorId } from './utils';
+
+const sender: DataType.Actor = {
+  identityDid: 'did:key:123',
+};
+
+// Generate bunch of complex messages.
+const messages: MessageWithRangeId[] = [
+  // Control message.
+  'Hello, every body. We will talk about quantum entanglement today',
+
+  // Two sentences in one message.
+  'hello every body we will talk about quantum entanglement today',
+
+  // Sentence broken into pieces.
+  'quantum entanglement',
+  'is one of the most...',
+  'perplexing and fascinating phenomena',
+  'in modern physics',
+
+  // Two sentences without separators.
+  'it challenges our classical intuitions about how the universe works and forces us to reconsider our assumptions about space, time, and information',
+  'at its core, quantum entanglement refers to a peculiar connection between two or more particles in such a way that the state of one particle instantly...',
+  'determines the state of the other, no matter how far apart they may be — even if they are light-years away',
+
+  // 2 sentences are merged.
+  'this seemingly instantaneous correlation between distant particles has baffled physicists since the early 20th century to understand entanglement, we',
+  'first need to touch on the fundamentals of quantum mechanics',
+
+  // No punctuation.
+  'in classical physics objects have well-defined properties such as position speed and momentum',
+].map((string, index) => ({
+  id: ObjectId.random(),
+  created: new Date(Date.now() + 1000 * index).toISOString(),
+  sender,
+  blocks: [{ type: 'transcription', started: new Date(Date.now() + 1000 * index).toISOString(), text: string }],
+  rangeId: [],
+}));
+
+const REMOTE_AI = true;
+
+describe.skip('SentenceNormalization', () => {
+  const getExecutor = () => {
+    return new FunctionExecutor(
+      new ServiceContainer().setServices({
+        ai: {
+          client: REMOTE_AI
+            ? new AIServiceEdgeClient({
+                endpoint: AI_SERVICE_ENDPOINT.REMOTE,
+                defaultGenerationOptions: {
+                  model: '@anthropic/claude-3-5-sonnet-20241022',
+                },
+              })
+            : new OllamaClient({
+                overrides: {
+                  model: 'llama3.1:8b',
+                },
+              }),
+        },
+      }),
+    );
+  };
+
+  test('messages merging', { timeout: 120_000 }, async () => {
+    const executor = getExecutor();
+    const sentences: MessageWithRangeId[] = [];
+    let buffer: MessageWithRangeId[] = [];
+    let activeSentenceIndex = 0;
+    for (const message of messages) {
+      const result = await executor.invoke(sentenceNormalization, {
+        messages: [...buffer, message],
+      });
+      log.info('BEFORE sentence splicing', { activeSentenceIndex, sentences, inserting: result.sentences });
+      sentences.splice(activeSentenceIndex, sentences.length - activeSentenceIndex, ...result.sentences);
+      log.info('AFTER sentence splicing', { activeSentenceIndex, sentences });
+
+      if (sentences.length > 0) {
+        activeSentenceIndex = sentences.length - 1;
+        buffer = sentences.slice(activeSentenceIndex);
+      }
+    }
+    log.info('sentences', {
+      originalMessages: JSON.stringify(messages, null, 2),
+      sentences: JSON.stringify(sentences, null, 2),
+    });
+    throw new Error('test');
+  });
+
+  test.only('queue', { timeout: 120_000 }, async () => {
+    // Create queue.
+    const queue = new MemoryQueue<DataType.Message>(createQueueDxn());
+    const ctx = new Context();
+    let idx = 0;
+    scheduleTaskInterval(
+      ctx,
+      async () => {
+        if (idx >= messages.length) {
+          void ctx.dispose();
+          return;
+        }
+        await queue.append([messages[idx]]);
+        idx++;
+      },
+      2_000,
+    );
+
+    // Create normalizer.
+    const normalizer = new MessageNormalizer({
+      functionExecutor: getExecutor(),
+      queue,
+      startingCursor: { actorId: getActorId(sender), timestamp: '0' },
+    });
+
+    // 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

@@ -0,0 +1,103 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { DEFAULT_EDGE_MODEL } from '@dxos/ai';
+import { AISession } from '@dxos/assistant';
+import { AiService, defineFunction } from '@dxos/functions';
+import { ObjectId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { DataType } from '@dxos/schema';
+
+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 const NormalizationOutput = Schema.Struct({
+  sentences: Schema.Array(MessageWithRangeId.pipe(Schema.mutable)).pipe(Schema.mutable).annotations({
+    description: 'The sentences of the transcript.',
+  }),
+});
+
+const prompt = `
+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.
+`;
+
+export const sentenceNormalization = defineFunction({
+  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' });
+
+    const response = await session.runStructured(NormalizationOutput, {
+      generationOptions: { model: DEFAULT_EDGE_MODEL },
+      client: ai.client,
+      tools: [],
+      artifacts: [],
+      history: [
+        {
+          id: ObjectId.random(),
+          role: 'user',
+          content: messages.map((message) => ({ type: 'text', text: JSON.stringify(message) })),
+        },
+      ],
+      prompt,
+    });
+
+    response.sentences.forEach((sentence) => {
+      sentence.id = ObjectId.random();
+    });
+    log.info('response', { response });
+    return response;
+  },
+});

package/src/segments-normalization/utils.ts

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

package/src/testing/testing.ts

@@ -2,16 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema, SchemaAST } from 'effect';
+import { Schema } from 'effect';
 import { useEffect, useMemo, useState } from 'react';
 
-import { AIServiceEdgeClient } from '@dxos/assistant';
-import { AI_SERVICE_ENDPOINT } from '@dxos/assistant/testing';
+import { AIServiceEdgeClient } from '@dxos/ai';
+import { AI_SERVICE_ENDPOINT } from '@dxos/ai/testing';
+import { extractionAnthropicFn, processTranscriptMessage } from '@dxos/assistant';
 import { scheduleTaskInterval } from '@dxos/async';
 import { Filter, type Queue } from '@dxos/client/echo';
 import { Context } from '@dxos/context';
 import { Type } from '@dxos/echo';
 import { create, createQueueDxn, ObjectId } from '@dxos/echo-schema';
+import { FunctionExecutor, ServiceContainer } from '@dxos/functions';
 import { IdentityDid } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { faker } from '@dxos/random';
@@ -19,20 +21,18 @@ import { live, makeRef, useQueue, type Space } from '@dxos/react-client/echo';
 import { DataType } from '@dxos/schema';
 import { Testing, seedTestData } from '@dxos/schema/testing';
 
-import { processTranscriptMessage } from '../entity-extraction';
-
 // TODO(burdon): Reconcile with plugin-markdown. Move to @dxos/schema/testing.
 export const TestItem = Schema.Struct({
   title: Schema.String.annotations({
-    [SchemaAST.TitleAnnotationId]: 'Title',
-    [SchemaAST.DescriptionAnnotationId]: 'Product title',
+    title: 'Title',
+    description: 'Product title',
   }),
   description: Schema.String.annotations({
-    [SchemaAST.TitleAnnotationId]: 'Description',
-    [SchemaAST.DescriptionAnnotationId]: 'Product description',
+    title: 'Description',
+    description: 'Product description',
   }),
 }).pipe(
-  Type.def({
+  Type.Obj({
     typename: 'dxos.org/type/Test',
     version: '0.1.0',
   }),
@@ -88,7 +88,7 @@ export class MessageBuilder extends AbstractMessageBuilder {
     };
   }
 
-  next() {
+  next(): Date {
     this.start = new Date(this.start.getTime() + Math.random() * 10_000);
     return this.start;
   }
@@ -100,11 +100,13 @@ class EntityExtractionMessageBuilder extends AbstractMessageBuilder {
     endpoint: AI_SERVICE_ENDPOINT.REMOTE,
   });
 
+  executor = new FunctionExecutor(new ServiceContainer().setServices({ ai: { client: this.aiService } }));
+
   space: Space | undefined;
   currentMessage: number = 0;
   transcriptMessages: DataType.Message[] = [];
 
-  async connect(space: Space) {
+  async connect(space: Space): Promise<void> {
     this.space = space;
     const { transcriptMessages } = await seedTestData(space);
     this.transcriptMessages = transcriptMessages;
@@ -127,11 +129,9 @@ class EntityExtractionMessageBuilder extends AbstractMessageBuilder {
     this.currentMessage = this.currentMessage % this.transcriptMessages.length;
 
     const { message: enhancedMessage } = await processTranscriptMessage({
-      message,
-      aiService: this.aiService,
-      context: {
-        objects,
-      },
+      input: { message },
+      executor: this.executor,
+      function: extractionAnthropicFn,
     });
 
     return enhancedMessage;