@dxos/assistant 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

package/src/session/session.ts

@@ -2,42 +2,94 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AiLanguageModel, AiToolkit, type AiError, type AiResponse, type AiTool } from '@effect/ai';
-import { Chunk, Context, Effect, Option, pipe, Stream, type Schema } from 'effect';
-import { Array, String } 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 * as Stream from 'effect/Stream';
+import * as Array from 'effect/Array';
+import * as Option from 'effect/Option';
 import {
   AiParser,
   AiPreprocessor,
-  getToolCalls,
-  runTool,
-  ToolExecutionService,
-  ToolResolverService,
-  type AgentStatus,
-  type AiInputPreprocessingError,
+  AiSummarizer,
   type AiToolNotFoundError,
-  type GenerationStream,
+  callTool,
+  type PromptPreprocessingError,
+  type ToolExecutionService,
+  type ToolResolverService,
+  withoutToolCallParising,
 } from '@dxos/ai';
-import { Event } from '@dxos/async';
 import { type Blueprint } from '@dxos/blueprints';
-import { todo } from '@dxos/debug';
 import { Obj } from '@dxos/echo';
-import { ObjectVersion } from '@dxos/echo-db';
-import { type ObjectId } from '@dxos/echo-schema';
-import { DatabaseService } from '@dxos/functions';
+import { type FunctionInvocationService, Trace, TracingService } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { DataType, type ContentBlock } from '@dxos/schema';
+import { ContentBlock, Message } from '@dxos/types';
+
+import { type AiAssistantError } from '../errors';
 
-import { AiAssistantError } from '../errors';
+import { formatSystemPrompt, formatUserPrompt } from './format';
+import { GenerationObserver } from './observer';
+import { pipe } from 'effect/Function';
+import { CompleteBlock, PartialBlock } from '../tracing';
 
-export type AiSessionOptions = {};
+export type AiSessionRunError = AiError.AiError | PromptPreprocessingError | AiToolNotFoundError | AiAssistantError;
 
-export type SessionRunOptions<Tools extends AiTool.Any> = {
+export type AiSessionRunRequirements =
+  | LanguageModel.LanguageModel
+  | ToolExecutionService
+  | ToolResolverService
+  | FunctionInvocationService
+  | Trace.TraceService
+  /**
+   * @deprecated Retained for backward compatibility with tool handlers that use TracingService.emitStatus().
+   *   New code should use Trace.TraceService instead.
+   */
+  | TracingService;
+
+export type AiSessionOptions = {
+  /**
+   * Summarize before executing the prompt if the existing history exceeds this threshold.
+   */
+  summarizationThreshold?: number;
+
+  // TODO(dmaretskyi): Plan to phase out in favor of TracingService and the return type being a stream.
+  observer?: GenerationObserver;
+  /**
+   * Callback for when a message is received from the user, model, or tool.
+   * This is useful for streaming the output to a queue.
+   */
+  onOutput?: (message: Message.Message) => Effect.Effect<void, never, never>;
+};
+
+export type AiSessionRunProps<Tools extends Record<string, Tool.Any>> = {
   prompt: string;
-  history: DataType.Message[];
-  systemPrompt?: string;
-  toolkit?: AiToolkit.AiToolkit<Tools>;
-  blueprints?: Blueprint.Blueprint[];
+  // TODO(wittjosiah): Rename to systemPrompt.
+  system?: string;
+  history?: Message.Message[];
+  objects?: Obj.Unknown[];
+  blueprints?: readonly Blueprint.Blueprint[];
+  toolkit?: Toolkit.WithHandler<Tools>;
+};
+
+export type AiSessionBeginProps = {
+  prompt: string;
+  system?: string;
+  history?: Message.Message[];
+  objects?: Obj.Unknown[];
+  blueprints?: readonly Blueprint.Blueprint[];
+};
+
+export type AiSessionTurnProps<Tools extends Record<string, Tool.Any>> = {
+  system: string;
+  toolkit?: Toolkit.WithHandler<Tools>;
+};
+
+export type AiSessionTurnResult = {
+  messages: Message.Message[];
+  done: boolean;
 };
 
 /**
@@ -50,287 +102,247 @@ export type SessionRunOptions<Tools extends AiTool.Any> = {
  * Could be run locally in the app or remotely.
  * Could be personal or shared.
  */
+// TODO(dmaretskyi): Rename AiSessionRequest
 export class AiSession {
-  // TODO(burdon): Move to conversation.
+  /** Prevents concurrent execution of session. */
   private readonly _semaphore = Effect.runSync(Effect.makeSemaphore(1));
 
-  /** Pending messages (incl. the current user request). */
-  private _pending: DataType.Message[] = [];
+  private readonly _observer: GenerationObserver;
+  private readonly _onOutput: (message: Message.Message) => Effect.Effect<void, never, never>;
 
-  /** Current streaming response. */
-  private _stream: GenerationStream | undefined;
+  /** 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[] = [];
 
-  /**
-   * New message.
-   */
-  public readonly message = new Event<DataType.Message>();
+  private _started = 0;
+  private _ended = 0;
+  private _toolCalls = 0;
 
-  /**
-   * Complete block added to Message.
-   */
-  public readonly block = new Event<ContentBlock.Any>();
+  constructor(private readonly _options: AiSessionOptions = {}) {
+    this._observer = _options.observer ?? GenerationObserver.noop();
+    this._onOutput = _options.onOutput ?? (() => Effect.void);
+  }
 
-  /**
-   * Update partial block (while streaming).
-   */
-  public readonly update = new Event<ContentBlock.Any>();
+  get duration(): number {
+    return this._ended - this._started;
+  }
 
-  /**
-   * Unparsed events from the underlying generation stream.
-   */
-  public readonly streamEvent = new Event<AiResponse.Part>();
+  get toolCalls(): number {
+    return this._toolCalls;
+  }
 
-  /**
-   * User prompt or tool result.
-   */
-  public readonly userMessage = new Event<DataType.Message>();
+  get pending(): readonly Message.Message[] {
+    return this._pending;
+  }
 
-  /**
-   * Agent self-reporting its status.
-   * Triggered by the model.
-   */
-  public readonly statusReport = new Event<AgentStatus>();
+  private _submitMessage = (message: Message.Message): Effect.Effect<Message.Message, never, Trace.TraceService> =>
+    Effect.gen(this, function* () {
+      this._pending.push(message);
+      yield* this._observer.onMessage(message);
+      for (const block of message.blocks) {
+        yield* Trace.write(CompleteBlock, {
+          messageId: message.id,
+          role: message.sender.role!,
+          block,
+        });
+      }
+      yield* this._onOutput(message);
+      return message;
+    });
+
+  getToolCalls = () =>
+    pipe(
+      [...this._history, ...this._pending],
+      Array.reverse,
+      Array.takeWhile((_) => _.sender.role === 'assistant'),
+      Array.flatMap((_) => _.blocks.filter(ContentBlock.is('toolCall')).map((block) => ({ block, message: _ }))),
+      Array.filter((_) => !_.block.providerExecuted),
+    );
 
   /**
-   * Emits when the session is done.
+   * Initialize a session: set up history, perform summarization if needed, and submit the user prompt.
+   * Must be called before `runTurn()`.
    */
-  public readonly done = new Event<void>();
+  begin = ({
+    prompt,
+    system,
+    history = [],
+    blueprints = [],
+    objects = [],
+  }: AiSessionBeginProps): Effect.Effect<void, AiSessionRunError, AiSessionRunRequirements> =>
+    Effect.gen(this, function* () {
+      this._started = Date.now();
+      this._history = [...history];
+      this._pending = [];
+
+      const systemPrompt = yield* formatSystemPrompt({ system, blueprints, objects }).pipe(Effect.orDie);
+
+      if (this._options.summarizationThreshold !== undefined) {
+        const tokenCount = yield* AiPreprocessor.estimateTokens(
+          yield* AiPreprocessor.preprocessPrompt([...this._history], {
+            system: systemPrompt,
+          }),
+        );
+        if (tokenCount > this._options.summarizationThreshold) {
+          const summary = yield* AiSummarizer.summarize([...this._history]);
+          yield* this._submitMessage(summary);
+        }
+      }
 
-  constructor(private readonly _options: AiSessionOptions = {}) {}
+      yield* this._submitMessage(yield* formatUserPrompt({ prompt, history }));
+    });
 
   /**
-   * Runs the AI model loop interacting with tools and artifacts.
-   * @param options - The session options.
-   * @returns The messages generated by the session, including the user's prompt.
+   * Execute a single turn: one LLM generation followed by tool execution.
+   * The toolkit and system prompt can be updated between turns to reflect context changes (e.g. dynamically enabled blueprints).
    */
-  // TODO(dmaretskyi): Toolkit context doesn't get added to the effect type.
-  run = <Tools extends AiTool.Any>(
-    options: SessionRunOptions<Tools>,
-  ): Effect.Effect<
-    DataType.Message[],
-    AiAssistantError | AiInputPreprocessingError | AiToolNotFoundError | AiError.AiError,
-    AiLanguageModel.AiLanguageModel | ToolResolverService | ToolExecutionService | AiTool.ToHandler<Tools>
-  > =>
+  runAgentTurn = <Tools extends Record<string, Tool.Any>>({
+    system,
+    toolkit,
+  }: AiSessionTurnProps<Tools>): Effect.Effect<AiSessionTurnResult, AiSessionRunError, AiSessionRunRequirements> =>
     Effect.gen(this, function* () {
-      this._history = [...options.history];
-
-      const promptMessages = yield* this._formatUserPrompt(options.prompt, options.history);
-      this._pending = [promptMessages];
-      this.userMessage.emit(promptMessages);
+      log('request', {
+        system: { snippet: createSnippet(system), length: system.length },
+        pending: this._pending.length,
+        history: this._history.length,
+      });
 
-      // Potential tool use loop.
-      do {
-        log('request', {
-          pending: this._pending.length,
-          history: this._history.length,
-          tools: (Object.values(options.toolkit?.tools ?? {}) as AiTool.Any[]).map((tool: AiTool.Any) => tool.name),
-        });
+      const prompt = yield* AiPreprocessor.preprocessPrompt([...this._history, ...this._pending], {
+        system,
+        cacheControl: 'ephemeral',
+      });
 
-        const prompt = yield* AiPreprocessor.preprocessAiInput([...this._history, ...this._pending]);
+      const observer = this._observer;
+      let currentMessageId: Obj.ID | null = null; // Consistent IDs for pending blocks preceding the complete one.
+      const messages = yield* LanguageModel.streamText({
+        prompt,
+        toolkit,
+        disableToolCallResolution: true,
+      }).pipe(
+        withoutToolCallParising,
+        AiParser.parseResponse({
+          emitPartial: true,
+          onBegin: () => observer.onBegin(),
+          onBlock: (block) => observer.onBlock(block),
+          onPart: (part) => observer.onPart(part as any),
+          onEnd: (summary) => observer.onEnd(summary),
+        }),
+        Stream.mapEffect(
+          (block) =>
+            Effect.gen(this, function* () {
+              if (block.pending) {
+                currentMessageId ??= Obj.ID.random();
+                log('emit ephemeral message', { id: currentMessageId, type: block._tag });
+                yield* Trace.write(PartialBlock, {
+                  messageId: currentMessageId,
+                  role: 'assistant',
+                  block,
+                });
+                return Option.none();
+              } else {
+                currentMessageId ??= Obj.ID.random();
+                const id = currentMessageId;
+                currentMessageId = null;
+                log('emit complete message', { id, type: block._tag });
+                const message = Obj.make(Message.Message, {
+                  id,
+                  created: new Date().toISOString(),
+                  sender: { role: 'assistant' },
+                  blocks: [block],
+                });
+                return Option.some(yield* this._submitMessage(message));
+              }
+            }),
+          { concurrency: 1, unordered: false },
+        ),
+        Stream.filterMap((_) => _),
+        Stream.runCollect,
+        Effect.map(Chunk.toArray),
+      );
+
+      const toolCalls = this.getToolCalls();
+
+      if (toolCalls.length === 0) {
+        this._ended = Date.now();
+        return { messages, done: true };
+      } else if (!toolkit) {
+        throw new Error('No toolkit provided');
+      }
 
-        const blueprints = options.blueprints ?? [];
+      return { messages, done: false };
+    });
 
-        // Build system prompt from blueprint templates.
-        // TODO(dmaretskyi): Loading BP from the Database should be done at the higher level. We need a type for the resolved blueprint.
-        const systemPrompt = yield* pipe(
-          blueprints,
-          Effect.forEach((blueprint) => DatabaseService.loadRef(blueprint.instructions)),
-          Effect.flatMap(Effect.forEach((template) => DatabaseService.loadRef(template.source))),
-          Effect.map(Array.map((template) => `\n\n<blueprint>${template.content}</blueprint>`)),
-          Effect.map(Array.reduce(options.systemPrompt ?? '', String.concat)),
+  runTools = <Tools extends Record<string, Tool.Any>>({ toolkit }: { toolkit?: Toolkit.WithHandler<Tools> }) =>
+    Effect.gen(this, function* () {
+      const toolCalls = this.getToolCalls();
+      // TODO(burdon): Retry errors? Write result when each completes individually?
+      const toolResults = yield* Effect.forEach(toolCalls, ({ block, message }) => {
+        if (!toolkit) {
+          throw new Error('No toolkit provided');
+        }
+        return callTool(toolkit, block).pipe(
+          Effect.provide(
+            TracingService.layerSubframe((context) => ({
+              ...context,
+              parentMessage: message.id,
+              toolCallId: block.toolCallId,
+            })),
+          ),
         );
+      });
 
-        // Build a combined toolkit from the blueprint tools and the provided toolkit.
-        const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap((bp) => bp.tools));
-        const blueprintToolkitHandler: Context.Context<AiTool.ToHandler<AiTool.Any>> =
-          yield* blueprintToolkit.toContext(yield* ToolExecutionService.handlersFor(blueprintToolkit));
-        const toolkit = options.toolkit != null ? AiToolkit.merge(options.toolkit, blueprintToolkit) : blueprintToolkit;
-        const toolkitWithBlueprintHandlers = yield* toolkit.pipe(
-          Effect.provide(blueprintToolkitHandler) as any,
-        ) as Effect.Effect<AiToolkit.ToHandler<any>, never, AiTool.ToHandler<Tools>>;
-
-        log.info('run', {
-          systemPrompt: [systemPrompt.slice(0, 32), '...', systemPrompt.slice(-32), systemPrompt.length].join(' '),
-          tools: Object.keys(blueprintToolkit.tools),
-        });
+      // TODO(wittjosiah): Sometimes tool error results are added to the queue before the tool agent statuses.
+      // TODO(dmaretskyi): Stream tool results one by one.
+      yield* this._submitMessage(
+        Obj.make(Message.Message, {
+          created: new Date().toISOString(),
+          sender: { role: 'tool' },
+          blocks: toolResults,
+        }),
+      );
 
-        const blocks = yield* AiLanguageModel.streamText({
-          prompt,
-          system: systemPrompt,
-          toolkit: toolkitWithBlueprintHandlers,
-          disableToolCallResolution: true,
-        }).pipe(
-          AiParser.parseGptStream({
-            onBlock: (block) =>
-              Effect.gen(this, function* () {
-                if (block.pending) {
-                  this.update.emit(block);
-                } else {
-                  this.block.emit(block);
-                }
-              }),
-            onPart: (part) =>
-              Effect.gen(this, function* () {
-                this.streamEvent.emit(part);
-              }),
-          }),
-          Stream.runCollect,
-          Effect.map(Chunk.toArray),
-        );
+      this._toolCalls += toolResults.length;
+    });
+  /**
+   * Run a full conversation turn loop. Equivalent to calling `begin()` then `runTurn()` in a loop.
+   */
+  run = <Tools extends Record<string, Tool.Any>>({
+    prompt,
+    system: systemTemplate,
+    history = [],
+    objects = [],
+    blueprints = [],
+    toolkit,
+  }: AiSessionRunProps<Tools>): Effect.Effect<Message.Message[], AiSessionRunError, AiSessionRunRequirements> =>
+    Effect.gen(this, function* () {
+      yield* this.begin({ prompt, system: systemTemplate, history, objects, blueprints });
 
-        const response = Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender: { role: 'assistant' },
-          blocks,
-        });
-        this._pending.push(response);
-        this.message.emit(response);
+      const system = yield* formatSystemPrompt({ system: systemTemplate, blueprints, objects }).pipe(Effect.orDie);
 
-        const toolCalls = getToolCalls(response);
-        if (toolCalls.length === 0) {
+      do {
+        const { done } = yield* this.runAgentTurn({ system, toolkit });
+        if (done) {
           break;
         }
-
-        const toolResults = yield* runTools(toolCalls, toolkitWithBlueprintHandlers as any);
-        this._pending.push(
-          Obj.make(DataType.Message, {
-            created: new Date().toISOString(),
-            sender: { role: 'user' },
-            blocks: toolResults,
-          }),
-        );
+        yield* this.runTools({ toolkit });
       } while (true);
 
+      log('done', { pending: this._pending.length, duration: this.duration, tools: this._toolCalls });
       return this._pending;
     }).pipe(this._semaphore.withPermits(1), Effect.withSpan('AiSession.run'));
-
-  async runStructured<S extends Schema.Schema.AnyNoContext>(
-    schema: S,
-    options: SessionRunOptions<AiTool.Any>,
-  ): Promise<Schema.Schema.Type<S>> {
-    return todo();
-    // const parser = structuredOutputParser(schema);
-    // const result = await this.run({
-    //   ...options,
-    //   executableTools: [...(options.executableTools ?? []), parser.tool],
-    // });
-    // return parser.getResult(result);
-  }
-
-  private _formatUserPrompt = (prompt: string, history: DataType.Message[]) =>
-    Effect.gen(function* () {
-      const prelude: ContentBlock.Any[] = [];
-
-      // TODO(dmaretskyi): Evaluate other approaches as `serviceOption` isn't represented in the type system.
-      const artifactDiffResolver = yield* Effect.serviceOption(ArtifactDiffResolver);
-      if (Option.isSome(artifactDiffResolver)) {
-        const versions = gatherObjectVersions(history);
-
-        const artifactDiff = yield* Effect.tryPromise({
-          try: () =>
-            artifactDiffResolver.value.resolve(
-              [...versions.entries()].map(([id, version]) => ({ id, lastVersion: version })),
-            ),
-          catch: AiAssistantError.wrap('Artifact diff resolution error'),
-        });
-
-        log.info('vision', {
-          artifactDiff,
-          versions,
-        });
-
-        for (const [id, { version }] of [...artifactDiff.entries()]) {
-          if (ObjectVersion.equals(version, versions.get(id)!)) {
-            artifactDiff.delete(id);
-            continue;
-          }
-
-          prelude.push({ _tag: 'anchor', objectId: id, version });
-        }
-        if (artifactDiff.size > 0) {
-          prelude.push(createArtifactUpdateBlock(artifactDiff));
-        }
-      }
-
-      return Obj.make(DataType.Message, {
-        created: new Date().toISOString(),
-        sender: { role: 'user' },
-        blocks: [...prelude, { _tag: 'text', text: prompt }],
-      });
-    });
-
-  abort(): void {
-    this._stream?.abort();
-  }
 }
 
-const gatherObjectVersions = (messages: DataType.Message[]): Map<ObjectId, ObjectVersion> => {
-  const artifactIds = new Map<ObjectId, ObjectVersion>();
-  for (const message of messages) {
-    for (const block of message.blocks) {
-      if (block._tag === 'anchor') {
-        artifactIds.set(block.objectId, block.version as ObjectVersion);
-      }
-    }
-  }
-
-  return artifactIds;
-};
+const createSnippet = (text: string, len = 32) =>
+  text.length <= len * 2 ? text : [text.slice(0, len), '...', text.slice(-len)].join('');
 
-const createArtifactUpdateBlock = (
-  artifactDiff: Map<ObjectId, { version: ObjectVersion; diff?: string }>,
-): ContentBlock.Any => {
-  return {
-    _tag: 'text',
-    // TODO(dmaretskyi): Does this need to be a special content-block?
-    disposition: 'artifact-update',
-    text: `
-      The following artifacts have been updated since the last message:
-      ${[...artifactDiff.entries()]
-        .map(([id, { diff }]) => `<changed-artifact id="${id}">${diff ? `\n${diff}` : ''}</changed-artifact>`)
-        .join('\n')}
-    `,
-  };
+// 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 });
 };
-
-/**
- * Resolves artifact ids to their versions.
- * Used to give the model a sense of the changes to the artifacts made by users during the conversation.
- * The artifacts versions are pinned in the history, and whenever the artifact changes in-between assistant's steps,
- * a diff is inserted into the conversation.
- *
- * Can be optionally provided to the session run call.
- */
-// TODO(dmaretskyi): Convert to Context.Reference
-export class ArtifactDiffResolver extends Context.Tag('ArtifactDiffResolver')<
-  ArtifactDiffResolver,
-  ArtifactDiffResolver.Service
->() {}
-
-export namespace ArtifactDiffResolver {
-  export type Service = {
-    resolve: (artifacts: { id: ObjectId; lastVersion: ObjectVersion }[]) => Promise<
-      Map<
-        ObjectId,
-        {
-          version: ObjectVersion;
-          diff?: string;
-        }
-      >
-    >;
-  };
-}
-
-const runTools: <Tools extends AiTool.Any>(
-  toolCalls: ContentBlock.ToolCall[],
-  toolkit: AiToolkit.AiToolkit<Tools>,
-) => Effect.Effect<ContentBlock.ToolResult[], AiError.AiError, AiTool.ToHandler<Tools>> = Effect.fn('runTools')(
-  function* (toolCalls, toolkit) {
-    const toolkitWithHandlers = Effect.isEffect(toolkit) ? yield* toolkit : toolkit;
-
-    return yield* Effect.forEach(toolCalls, (toolCall) => runTool(toolkitWithHandlers, toolCall));
-  },
-);

package/src/session/toolkit.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
+import * as Effect from 'effect/Effect';
+
+import { type AiToolNotFoundError, GenericToolkit, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { type Blueprint } from '@dxos/blueprints';
+import { isTruthy } from '@dxos/util';
+
+export type CreateToolkitProps = {
+  toolkit?: Toolkit.Any;
+  blueprints?: readonly Blueprint.Blueprint[];
+  /**
+   * Self-contained with handlers toolkits.
+   */
+  genericToolkits?: readonly GenericToolkit.GenericToolkit[];
+};
+
+/**
+ * Build a combined toolkit from the blueprint tools and the provided toolkit.
+ */
+export const createToolkit = ({
+  toolkit: toolkitProp,
+  blueprints = [],
+  genericToolkits = [],
+}: CreateToolkitProps): Effect.Effect<
+  Toolkit.WithHandler<any>,
+  AiToolNotFoundError,
+  ToolResolverService | ToolExecutionService | Tool.HandlersFor<any>
+> =>
+  Effect.gen(function* () {
+    const blueprintToolkit = yield* ToolResolverService.resolveToolkit(blueprints.flatMap(({ tools }) => tools));
+    const blueprintToolHandler = yield* blueprintToolkit.toContext(ToolExecutionService.handlersFor(blueprintToolkit));
+    const genericToolkit = GenericToolkit.merge(...genericToolkits);
+
+    const toolkit = Toolkit.merge(...[toolkitProp, blueprintToolkit, genericToolkit.toolkit].filter(isTruthy));
+    return yield* toolkit.pipe(
+      Effect.provide(blueprintToolHandler),
+      Effect.provide(genericToolkit.layer),
+    ) as any as Effect.Effect<Toolkit.WithHandler<any>, never, Tool.HandlersFor<any>>;
+  });