@dxos/assistant 0.8.4-main.fd6878d → 0.8.4-main.fffef41

package/src/session/session.test.ts

@@ -2,13 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AiTool, AiToolkit } from '@effect/ai';
+import * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
 import { describe, it } from '@effect/vitest';
-import { Effect, Layer, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
 
-import { AiService, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { AiService, MemoizedAiService, ToolExecutionService, ToolResolverService } from '@dxos/ai';
 import { AiServiceTestingPreset } from '@dxos/ai/testing';
 import { Obj, Type } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect';
+import { TracingService } from '@dxos/functions';
 import { log } from '@dxos/log';
 
 import { AiSession } from './session';
@@ -28,8 +33,8 @@ const CalendarEventSchema = Schema.Struct({
 
 type CalendarEvent = Schema.Schema.Type<typeof CalendarEventSchema>;
 
-class TestToolkit extends AiToolkit.make(
-  AiTool.make('Calculator', {
+const TestToolkit = Toolkit.make(
+  Tool.make('Calculator', {
     description: 'Basic calculator tool',
     parameters: {
       input: Schema.String.annotations({
@@ -41,7 +46,7 @@ class TestToolkit extends AiToolkit.make(
     }),
     failure: Schema.Never,
   }),
-) {}
+);
 
 // Tool handlers.
 const toolkitLayer = TestToolkit.toLayer({
@@ -60,11 +65,23 @@ const toolkitLayer = TestToolkit.toLayer({
     }),
 });
 
-describe.runIf(process.env.DX_RUN_SLOW_TESTS)('AiSession', () => {
+const TestLayer = Layer.mergeAll(
+  toolkitLayer,
+  AiService.model('@anthropic/claude-3-5-sonnet-20241022'),
+  TracingService.layerNoop,
+  ToolResolverService.layerEmpty,
+  ToolExecutionService.layerEmpty,
+).pipe(
+  //
+  Layer.provideMerge(MemoizedAiService.layerTest()),
+  Layer.provide(AiServiceTestingPreset('direct')),
+);
+
+describe('AiSession', () => {
   it.effect(
     'no tools',
-    Effect.fn(
-      function* ({ expect: _ }) {
+    Effect.fnUntraced(
+      function* (_) {
         const session = new AiSession({ operationModel: 'configured' });
         const response = yield* session.run({
           prompt: 'Hello world!',
@@ -72,161 +89,28 @@ describe.runIf(process.env.DX_RUN_SLOW_TESTS)('AiSession', () => {
         });
         log.info('response', { response });
       },
-      Effect.provide(
-        AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
-          Layer.provideMerge(ToolResolverService.layerEmpty),
-          Layer.provideMerge(ToolExecutionService.layerEmpty),
-          Layer.provideMerge(AiServiceTestingPreset('direct')),
-        ),
-      ),
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
     ),
   );
 
   it.effect(
     'calculator',
-    Effect.fn(
-      function* ({ expect: _ }) {
+    Effect.fnUntraced(
+      function* (_) {
         const session = new AiSession({ operationModel: 'configured' });
+        const toolkit = yield* TestToolkit;
         const response = yield* session.run({
-          prompt: 'What is 10 + 20?',
+          toolkit,
+          prompt: 'What is 10 + 30?',
           history: [],
-          toolkit: TestToolkit,
         });
         log.info('response', { response });
       },
-      Effect.provide(
-        Layer.mergeAll(
-          toolkitLayer,
-          ToolResolverService.layerEmpty,
-          ToolExecutionService.layerEmpty,
-          AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
-            Layer.provideMerge(AiServiceTestingPreset('direct')),
-          ),
-        ),
-      ),
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
     ),
   );
-
-  // TODO(dmaretskyi): Revive test.
-  /*
-  it.skip('create calendar itinerary', { timeout: 60_000 }, async () => {
-    // overrides: { model: 'llama3.1:8b' },
-    const session = new AiSession({ operationModel: 'configured' });
-    const objects = new Set<string>();
-
-    // Define calendar artifact.
-    const calendarArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/calendar',
-      name: 'Calendar',
-      instructions: 'Use this to create and query calendar events.',
-      schema: CalendarEventSchema,
-      tools: [
-        createTool('calendar', {
-          name: 'query',
-          description: 'Query the calendar for events',
-          schema: Schema.Struct({}),
-          execute: async () => {
-            return ToolResult.Success(CALENDAR_EVENTS);
-          },
-        }),
-      ],
-    });
-
-    const tableArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/table',
-      name: 'Table',
-      instructions: 'Use this to create and manage tables. Each table has a unique id.',
-      schema: Schema.Struct({}),
-      tools: [
-        createTool('table', {
-          name: 'create',
-          description: 'Create a table',
-          schema: Schema.Struct({
-            data: Schema.Array(Schema.Any).annotations({ description: 'Array of data payloads to add as rows' }),
-          }),
-          execute: async ({ data }) => {
-            log('create table', { data });
-            const id = DXN.fromLocalObjectId(ObjectId.random()).toString();
-            objects.add(id);
-            // TODO(dmaretskyi): consider xml for refs instead of @dxn:echo:@:XXXXX
-            return ToolResult.Success(`table @${id}`);
-          },
-        }),
-      ],
-    });
-
-    const mapArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/map',
-      name: 'Map',
-      instructions:
-        'Use this to create and manage maps. Maps source data from tables. Table id is required to create a map.',
-      schema: Schema.Struct({}),
-      tools: [
-        createTool('map', {
-          name: 'create',
-          description: 'Create a map',
-          schema: Schema.Struct({
-            source: ArtifactId.annotations({
-              description: 'The table that will be used as the source of the map',
-            }),
-          }),
-          execute: async ({ source }) => {
-            // TODO(dmaretskyi): Use effect-schema decode instead of manual parsing.
-            const sourceId = ArtifactId.toDXN(source);
-            if (!objects.has(sourceId.toString())) {
-              return ToolResult.Error(`table id=${source} not found`);
-            }
-            log('create map', { sourceId });
-            const id = DXN.fromLocalObjectId(ObjectId.random()).toString();
-            objects.add(id);
-            // TODO(dmaretskyi): consider xml for refs instead of @dxn:echo:@:XXXXX
-            return ToolResult.Success(`map @${id}`);
-          },
-        }),
-      ],
-    });
-
-    const scriptArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/script',
-      name: 'Script',
-      instructions: 'Use this to create and manage scripts',
-      schema: Schema.Struct({}),
-      tools: [],
-    });
-
-    // session.streamEvent.on((event) => {
-    //   printStreamEvent(event);
-    // });
-
-    const printer = new ConsolePrinter();
-    session.message.on((message) => printer.printMessage(message));
-    session.userMessage.on((message) => printer.printMessage(message));
-    session.block.on((block) => printer.printContentBlock(block));
-
-    // session.update.on((update) => {
-    //   log('update', { update });
-    // });
-
-    // Test creating an itinerary
-    const response = await session.run({
-      client: aiClient,
-      tools: [],
-      artifacts: [calendarArtifact, tableArtifact, mapArtifact, scriptArtifact],
-      requiredArtifactIds: [calendarArtifact.id, tableArtifact.id, mapArtifact.id, scriptArtifact.id],
-      history: [],
-      generationOptions: {
-        model: '@anthropic/claude-3-5-haiku-20241022',
-      },
-      prompt: 'create a table and map for a travel itinerary based on events in my calendar',
-      toolResolver: new ToolRegistry([]),
-    });
-
-    log('result', {
-      objects,
-      finalMessage: response.at(-1),
-    });
-  });
-  */
 });
 
 // Travel to rome, florence, livorno, siena, madrid for conferences
@@ -263,43 +147,3 @@ const _CALENDAR_EVENTS: CalendarEvent[] = [
     description: 'Travel to Madrid',
   }),
 ];
-
-// const printStreamEvent = (event: GenerationStreamEvent) => {
-//   switch (event.type) {
-//     case 'message_start': {
-//       process.stdout.write(`${event.message.role.toUpperCase()}\n\n`);
-//       for (const content of event.message.content) {
-//         printContentBlock(content);
-//       }
-//       break;
-//     }
-//     case 'content_block_start': {
-//       printContentBlock(event.content);
-//       break;
-//     }
-//     case 'content_block_delta': {
-//       switch (event.delta.type) {
-//         case 'text_delta': {
-//           process.stdout.write(event.delta.text);
-//           break;
-//         }
-//         case 'input_json_delta': {
-//           process.stdout.write(event.delta.partial_json);
-//           break;
-//         }
-//       }
-//       break;
-//     }
-//     case 'content_block_stop': {
-//       process.stdout.write('\n');
-//       break;
-//     }
-//     case 'message_delta': {
-//       break;
-//     }
-//     case 'message_stop': {
-//       process.stdout.write('\n\n');
-//       break;
-//     }
-//   }
-// };

package/src/session/session.ts

@@ -2,106 +2,58 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type AiError, AiLanguageModel, type AiResponse, type AiTool, AiToolkit } from '@effect/ai';
-import { Chunk, type Context, Effect, Function, Option, Queue, type Schema, Stream } from 'effect';
+import type * as AiError from '@effect/ai/AiError';
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import type * as Tool from '@effect/ai/Tool';
+import type * as Toolkit from '@effect/ai/Toolkit';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import type * as Schema from 'effect/Schema';
+import * as Stream from 'effect/Stream';
 
 import {
-  type AiInputPreprocessingError,
   AiParser,
   AiPreprocessor,
   type AiToolNotFoundError,
-  type ConsolePrinter,
-  ToolExecutionService,
-  ToolResolverService,
-  callTools,
+  type PromptPreprocessingError,
+  type ToolExecutionService,
+  type ToolResolverService,
+  callTool,
   getToolCalls,
 } from '@dxos/ai';
 import { type Blueprint } from '@dxos/blueprints';
 import { todo } from '@dxos/debug';
 import { Obj } from '@dxos/echo';
+import { TracingService } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { type ContentBlock, DataType } from '@dxos/schema';
-import { isNotFalsy } from '@dxos/util';
+import { Message } from '@dxos/types';
 
 import { type AiAssistantError } from '../errors';
 
 import { formatSystemPrompt, formatUserPrompt } from './format';
+import { GenerationObserver } from './observer';
 
-export type AiSessionOptions = {};
+export type AiSessionRunError = AiError.AiError | PromptPreprocessingError | AiToolNotFoundError | AiAssistantError;
 
-/**
- * Live observer of the generation process.
- */
-export interface GenerationObserver {
-  /**
-   * Unparsed content block parts from the model.
-   */
-  onPart: (part: AiResponse.Part) => Effect.Effect<void>;
+export type AiSessionRunRequirements =
+  | LanguageModel.LanguageModel
+  | ToolExecutionService
+  | ToolResolverService
+  | TracingService;
 
-  /**
-   * Parsed content blocks from the model.
-   * NOTE: Use block.pending to determine if the block was completed.
-   * For each block this will be called 0..n times with a pending block and then once with the final state of the block.
-   *
-   * Example:
-   *  1. { pending: true, text: "Hello"}
-   *  2. { pending: true, text: "Hello, I am a"}
-   *  3. { pending: false, text: "Hello, I am a helpful assistant!"}
-   */
-  onBlock: (block: ContentBlock.Any) => Effect.Effect<void>;
-
-  /**
-   * Complete messages fired during the session, both from the model and from the user.
-   * This message will contain all message blocks emitted through the `onBlock` callback.
-   */
-  onMessage: (message: DataType.Message) => Effect.Effect<void>;
-}
-
-export const GenerationObserver = Object.freeze({
-  make: ({
-    onPart = Function.constant(Effect.void),
-    onBlock = Function.constant(Effect.void),
-    onMessage = Function.constant(Effect.void),
-  }: Partial<GenerationObserver> = {}): GenerationObserver => ({
-    onPart,
-    onBlock,
-    onMessage,
-  }),
-
-  noop: () => GenerationObserver.make(),
-
-  /**
-   * Debug printer to be used in unit-tests and browser devtools.
-   */
-  fromPrinter: (printer: ConsolePrinter) =>
-    GenerationObserver.make({
-      onBlock: (block) =>
-        Effect.sync(() => {
-          if (block.pending) {
-            return; // Only prints full blocks (better for unit-tests and browser devtools).
-          }
-          printer.printContentBlock(block);
-        }),
-      onMessage: (message) =>
-        Effect.sync(() => {
-          if (message.sender.role === 'assistant') {
-            return; // Skip assistant messages since they are printed in the `onBlock` callback.
-          }
-          printer.printMessage(message);
-        }),
-    }),
-});
-
-export type SessionRunParams<Tools extends AiTool.Any> = {
+export type AiSessionRunParams<Tools extends Record<string, Tool.Any>> = {
   prompt: string;
+  // TODO(wittjosiah): Rename to systemPrompt.
   system?: string;
-  history?: DataType.Message[];
-  objects?: Obj.Any[]; // TODO(burdon): Meta only (typename and id -- write to binder).
+  history?: Message.Message[];
+  objects?: Obj.Any[];
   blueprints?: Blueprint.Blueprint[];
-  toolkit?: AiToolkit.AiToolkit<Tools>;
+  toolkit?: Toolkit.WithHandler<Tools>;
   observer?: GenerationObserver;
 };
 
+export type AiSessionOptions = {};
+
 /**
  * Contains message history, tools, current context.
  * Current context means the state of the app, time of day, and other contextual information.
@@ -113,142 +65,130 @@ export type SessionRunParams<Tools extends AiTool.Any> = {
  * Could be personal or shared.
  */
 export class AiSession {
-  /** Complete messages fired during the session, both from the model and from the user. */
-  public readonly messageQueue = Effect.runSync(Queue.unbounded<DataType.Message>());
-
-  // TODO(dmaretskyi): Remove the queues and convert everything to observer.
-
-  /**
-   * Blocks streaming from the model during the session.
-   * @deprecated Use `observer.onBlock` instead.
-   */
-  public readonly blockQueue = Effect.runSync(Queue.unbounded<Option.Option<ContentBlock.Any>>());
-
-  /** Unparsed events from the underlying generation stream. */
-  public readonly eventQueue = Effect.runSync(Queue.unbounded<AiResponse.Part>());
-
   /** Prevents concurrent execution of session. */
   private readonly _semaphore = Effect.runSync(Effect.makeSemaphore(1));
 
-  /** Pending messages (incl. the current user request). */
-  private _pending: DataType.Message[] = [];
+  /** Message history from queue. */
+  // TODO(burdon): Evolve into supporting a git-like graph of messages.
+  private _history: Message.Message[] = [];
 
-  /** Prior history from queue. */
-  private _history: DataType.Message[] = [];
+  /** Pending messages for this session (incl. the current prompt). */
+  private _pending: Message.Message[] = [];
 
   constructor(private readonly _options: AiSessionOptions = {}) {}
 
-  /**
-   * Runs the AI model loop interacting with tools and artifacts.
-   * @returns The messages generated by the session, including the user's prompt.
-   */
-  // TODO(dmaretskyi): Toolkit context doesn't get added to the effect type.
-  run = <Tools extends AiTool.Any>(
-    params: SessionRunParams<Tools>,
-  ): Effect.Effect<
-    DataType.Message[],
-    AiAssistantError | AiInputPreprocessingError | AiToolNotFoundError | AiError.AiError,
-    AiLanguageModel.AiLanguageModel | ToolResolverService | ToolExecutionService | AiTool.ToHandler<Tools>
-  > =>
+  run = <Tools extends Record<string, Tool.Any>>({
+    prompt,
+    system: systemTemplate,
+    history = [],
+    objects = [],
+    blueprints = [],
+    toolkit,
+    observer = GenerationObserver.noop(),
+  }: AiSessionRunParams<Tools>): Effect.Effect<Message.Message[], AiSessionRunError, AiSessionRunRequirements> =>
     Effect.gen(this, function* () {
-      const observer = params.observer ?? GenerationObserver.noop();
-
-      // Create toolkit.
-      const toolkit: AiToolkit.ToHandler<Tools> = yield* createToolkit(params);
+      this._history = [...history];
+      this._pending = [];
+      const pending = this._pending;
 
-      // Generate system prompt.
-      // TODO(budon): Dynamically resolve template variables.
-      const system = yield* formatSystemPrompt(params);
-      console.log(system);
+      const submitMessage = Effect.fnUntraced(function* (message: Message.Message) {
+        pending.push(message);
+        yield* observer.onMessage(message);
+        yield* TracingService.emitConverationMessage(message);
+        return message;
+      });
 
-      // Generate user prompt.
-      const promptMessages = yield* formatUserPrompt(params);
-      yield* this.messageQueue.offer(promptMessages);
-      yield* observer.onMessage(promptMessages);
+      // Submit the prompt.
+      // TODO(burdon): Remove if cancelled?
+      const promptMessage = yield* submitMessage(yield* formatUserPrompt({ prompt, history }));
 
-      this._history = [...(params.history ?? [])];
-      this._pending = [promptMessages];
+      // Generate system and prompt messages.
+      const system = yield* formatSystemPrompt({ system: systemTemplate, blueprints, objects });
 
-      // Potential tool-use loop.
+      // Tool call loop.
       do {
-        log.info('request', {
-          prompt: promptMessages,
-          system: { snippet: [system.slice(0, 32), '...', system.slice(-32)].join(''), length: system.length },
+        log('request', {
+          prompt: promptMessage,
+          system: { snippet: createSnippet(system), length: system.length },
           pending: this._pending.length,
           history: this._history.length,
-          objects: params.objects?.length ?? 0,
-          blueprints: params.blueprints?.length ?? 0,
-          toolkit: Object.values(toolkit.tools).map((tool: AiTool.Any) => tool.name),
+          objects: objects?.length ?? 0,
         });
 
-        // Generate the prompt and make request.
-        const prompt = yield* AiPreprocessor.preprocessAiInput([...this._history, ...this._pending]);
-        const blocks = yield* AiLanguageModel.streamText({
+        const prompt = yield* AiPreprocessor.preprocessPrompt([...this._history, ...this._pending], { system });
+
+        // Execute the stream request.
+        // logDump('prompt', Prompt.Prompt.pipe(Schema.encodeSync)(prompt));
+        const blocks = yield* LanguageModel.streamText({
           prompt,
-          system,
           toolkit,
-          // TODO(burdon): Despite this flag, the model still calls tools.
-          //  Flag is only used in generateText (not streamText); patch and submit bug.
-          //  https://github.com/Effect-TS/effect/blob/main/packages/ai/ai/src/AiLanguageModel.ts#L401
           disableToolCallResolution: true,
         }).pipe(
+          // TOOD(dmaretskyi): Error mapping.
           AiParser.parseResponse({
-            onBlock: (block) =>
-              Effect.all([this.blockQueue.offer(Option.some(block)), observer.onBlock(block)], { discard: true }),
-            onPart: (part) => Effect.all([this.eventQueue.offer(part), observer.onPart(part)], { discard: true }),
+            onBegin: () => observer.onBegin(),
+            onBlock: (block) => observer.onBlock(block),
+            onPart: (part) => observer.onPart(part),
+            onEnd: (summary) => observer.onEnd(summary),
           }),
           Stream.runCollect,
           Effect.map(Chunk.toArray),
         );
 
-        // Signal to stream consumers that message blocks are complete.
-        // Allows for coordination between the block and message queues
-        //   to prevent the streaming blocks from being rendered twice when the message is produced.
-        // TODO(wittjosiah): The block queue should probably be drained at this point in the case that there is no consumer.
-        yield* this.blockQueue.offer(Option.none());
-
-        // Create response message.
-        const response = Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender: { role: 'assistant' },
-          blocks,
-        });
-        this._pending.push(response);
-        yield* this.messageQueue.offer(response);
-        yield* observer.onMessage(response);
+        // Create the response message.
+        const response = yield* submitMessage(
+          Obj.make(Message.Message, {
+            created: new Date().toISOString(),
+            sender: { role: 'assistant' },
+            blocks,
+          }),
+        );
 
-        // Parse response for tool calls.
+        // Parse the response for tool calls.
         const toolCalls = getToolCalls(response);
         if (toolCalls.length === 0) {
           break;
+        } else if (!toolkit) {
+          throw new Error('No toolkit provided'); // TODO(burdon): Throw user error?
         }
 
-        // TODO(burdon): Report errors to user; with proposed actions.
-        const toolResults = yield* callTools(toolkit, toolCalls);
-        const toolResultsMessage = Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender: { role: 'user' },
-          blocks: toolResults,
+        // Execute the tool calls.
+        // TODO(burdon): Retry errors? Write result when each completes individually?
+        const toolResults = yield* Effect.forEach(toolCalls, (toolCall) => {
+          return callTool(toolkit, toolCall).pipe(
+            Effect.provide(
+              TracingService.layerSubframe((context) => ({
+                ...context,
+                parentMessage: response.id,
+                toolCallId: toolCall.toolCallId,
+              })),
+            ),
+          );
         });
 
-        this._pending.push(toolResultsMessage);
-        yield* this.messageQueue.offer(toolResultsMessage);
-        yield* observer.onMessage(toolResultsMessage);
+        // Add to queue and continue loop.
+        // TODO(wittjosiah): Sometimes tool error results are added to the queue before the tool agent statuses.
+        //   This results in a broken execution graph.
+        yield* submitMessage(
+          Obj.make(Message.Message, {
+            created: new Date().toISOString(),
+            sender: { role: 'tool' },
+            blocks: toolResults,
+          }),
+        );
       } while (true);
 
-      // Signals to stream consumers that the session has completed and no more messages are coming.
-      yield* Queue.shutdown(this.messageQueue);
-      yield* Queue.shutdown(this.blockQueue);
-      yield* Queue.shutdown(this.eventQueue);
-
       log('done', { pending: this._pending.length });
       return this._pending;
     }).pipe(this._semaphore.withPermits(1), Effect.withSpan('AiSession.run'));
 
-  // TODO(burdon): Implement.
+  /**
+   * @deprecated
+   */
+  // TODO(burdon): Implement or remove.
   async runStructured<S extends Schema.Schema.AnyNoContext>(
     _schema: S,
-    _options: SessionRunParams<AiTool.Any>,
+    _options: AiSessionRunParams<any>,
   ): Promise<Schema.Schema.Type<S>> {
     return todo();
     // const parser = structuredOutputParser(schema);
@@ -260,20 +200,14 @@ export class AiSession {
   }
 }
 
-/**
- * Build a combined toolkit from the blueprint tools and the provided toolkit.
- */
-const createToolkit = <Tools extends AiTool.Any>({
-  toolkit,
-  blueprints = [],
-}: Pick<SessionRunParams<Tools>, 'toolkit' | 'blueprints'>) =>
-  Effect.gen(function* () {
-    const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap(({ tools }) => tools));
-    const blueprintToolkitHandler: Context.Context<AiTool.ToHandler<AiTool.Any>> = yield* blueprintToolkit.toContext(
-      ToolExecutionService.handlersFor(blueprintToolkit),
-    );
+const createSnippet = (text: string, len = 32) =>
+  text.length <= len * 2 ? text : [text.slice(0, len), '...', text.slice(-len)].join('');
 
-    return yield* AiToolkit.merge(...[toolkit, blueprintToolkit].filter(isNotFalsy)).pipe(
-      Effect.provide(blueprintToolkitHandler),
-    ) as Effect.Effect<AiToolkit.ToHandler<any>, never, AiTool.ToHandler<Tools>>;
-  });
+// TODO(dmaretskyi): Extract as a general util.
+const logDump = (message: string, data: unknown) => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { writeFileSync } = require('node:fs');
+  const path = `/tmp/log-data-${Date.now()}.json`;
+  writeFileSync(path, JSON.stringify(data, null, 2));
+  log.info(message, { path });
+};