@dxos/assistant 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/assistant",
-  "version": "0.8.4-main.9be5663bfe",
+  "version": "0.8.4-main.abd8ff62ef",
   "description": "Natural language interface to DXOS",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -22,24 +22,9 @@
       "source": "./src/extraction/index.ts",
       "types": "./dist/types/src/extraction/index.d.ts",
       "default": "./dist/lib/neutral/extraction/index.mjs"
-    },
-    "./testing": {
-      "source": "./src/testing/index.ts",
-      "types": "./dist/types/src/testing/index.d.ts",
-      "default": "./dist/lib/neutral/testing/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "types": [
-        "dist/types/src/types/index.d.ts"
-      ],
-      "extraction": [
-        "dist/types/src/extraction/index.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist",
     "src"
@@ -53,28 +38,26 @@
     "@effect/platform": "0.94.4",
     "@xenova/transformers": "^2.17.2",
     "lodash.defaultsdeep": "^4.6.1",
-    "@dxos/ai": "0.8.4-main.9be5663bfe",
-    "@dxos/async": "0.8.4-main.9be5663bfe",
-    "@dxos/debug": "0.8.4-main.9be5663bfe",
-    "@dxos/echo-db": "0.8.4-main.9be5663bfe",
-    "@dxos/context": "0.8.4-main.9be5663bfe",
-    "@dxos/echo-protocol": "0.8.4-main.9be5663bfe",
-    "@dxos/echo": "0.8.4-main.9be5663bfe",
-    "@dxos/effect": "0.8.4-main.9be5663bfe",
-    "@dxos/functions": "0.8.4-main.9be5663bfe",
-    "@dxos/errors": "0.8.4-main.9be5663bfe",
-    "@dxos/functions-runtime": "0.8.4-main.9be5663bfe",
-    "@dxos/blueprints": "0.8.4-main.9be5663bfe",
-    "@dxos/invariant": "0.8.4-main.9be5663bfe",
-    "@dxos/graph": "0.8.4-main.9be5663bfe",
-    "@dxos/keys": "0.8.4-main.9be5663bfe",
-    "@dxos/log": "0.8.4-main.9be5663bfe",
-    "@dxos/node-std": "0.8.4-main.9be5663bfe",
-    "@dxos/mcp-client": "0.8.4-main.9be5663bfe",
-    "@dxos/operation": "0.8.4-main.9be5663bfe",
-    "@dxos/schema": "0.8.4-main.9be5663bfe",
-    "@dxos/types": "0.8.4-main.9be5663bfe",
-    "@dxos/util": "0.8.4-main.9be5663bfe"
+    "@dxos/ai": "0.8.4-main.abd8ff62ef",
+    "@dxos/context": "0.8.4-main.abd8ff62ef",
+    "@dxos/compute": "0.8.4-main.abd8ff62ef",
+    "@dxos/async": "0.8.4-main.abd8ff62ef",
+    "@dxos/echo-db": "0.8.4-main.abd8ff62ef",
+    "@dxos/debug": "0.8.4-main.abd8ff62ef",
+    "@dxos/echo": "0.8.4-main.abd8ff62ef",
+    "@dxos/echo-protocol": "0.8.4-main.abd8ff62ef",
+    "@dxos/errors": "0.8.4-main.abd8ff62ef",
+    "@dxos/effect": "0.8.4-main.abd8ff62ef",
+    "@dxos/functions": "0.8.4-main.abd8ff62ef",
+    "@dxos/invariant": "0.8.4-main.abd8ff62ef",
+    "@dxos/mcp-client": "0.8.4-main.abd8ff62ef",
+    "@dxos/keys": "0.8.4-main.abd8ff62ef",
+    "@dxos/log": "0.8.4-main.abd8ff62ef",
+    "@dxos/node-std": "0.8.4-main.abd8ff62ef",
+    "@dxos/schema": "0.8.4-main.abd8ff62ef",
+    "@dxos/util": "0.8.4-main.abd8ff62ef",
+    "@dxos/graph": "0.8.4-main.abd8ff62ef",
+    "@dxos/types": "0.8.4-main.abd8ff62ef"
   },
   "devDependencies": {
     "@types/lodash.defaultsdeep": "^4.6.6",

package/src/conversation/context.ts

@@ -10,7 +10,7 @@ import * as Function from 'effect/Function';
 import * as Runtime from 'effect/Runtime';
 import * as Schema from 'effect/Schema';
 
-import { Blueprint } from '@dxos/blueprints';
+import { Blueprint } from '@dxos/compute';
 import { Resource } from '@dxos/context';
 import { DXN, Feed, Obj, type QueryResult, Query, Ref, Type } from '@dxos/echo';
 import { assertArgument } from '@dxos/invariant';

package/src/conversation/index.ts

@@ -3,4 +3,4 @@
 //
 
 export * from './context';
-export * from './conversation';
+export * from './session';

package/src/conversation/session.ts

@@ -0,0 +1,334 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type { Registry } from '@effect-atom/atom-react';
+import * as Array from 'effect/Array';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Either from 'effect/Either';
+import { pipe } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Record from 'effect/Record';
+import * as Runtime from 'effect/Runtime';
+
+import { type OpaqueToolkit, type ToolExecutionService, type ToolResolverService } from '@dxos/ai';
+import { type Blueprint, type OperationRegistry, Operation, Trace } from '@dxos/compute';
+import { Resource } from '@dxos/context';
+import { Database, Feed, Filter, Obj } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { McpToolkit } from '@dxos/mcp-client';
+import { Message, type ContentBlock } from '@dxos/types';
+
+import { ToolExecutionServices } from '../functions';
+import {
+  AiRequest,
+  type AiRequestRunError,
+  type AiRequestRunRequirements,
+  type GenerationObserver,
+  createToolkit,
+  formatSystemPrompt,
+} from '../session';
+import { McpServerError } from '../tracing';
+import { AiContextBinder, AiContextService } from './context';
+
+export interface McpServerConfig {
+  url: string;
+  protocol: 'sse' | 'http';
+  apiKey?: string;
+}
+
+export interface AiSessionRunProps<R = never> {
+  prompt: string | ContentBlock.Any[];
+  system?: string;
+  observer?: GenerationObserver;
+  toolkit?: OpaqueToolkit.OpaqueToolkit<R>;
+
+  /**
+   * Space-level MCP servers to connect alongside blueprint-defined ones.
+   */
+  mcpServers?: readonly McpServerConfig[];
+}
+
+export type AiSessionOptions = {
+  feed: Feed.Feed;
+  runtime: Runtime.Runtime<Feed.FeedService>;
+  registry?: Registry.Registry;
+};
+
+// TODO(dmaretskyi): Take from model characteristics. opus has 200k max tokens.
+/**
+ * Summarization threshold in tokens.
+ */
+const SUMMARY_THRESHOLD = 80_000;
+
+/**
+ * Durable conversation state (initiated by users and agents) backed by a Feed.
+ * Executes tools based on AI responses and supports cancellation of in-progress requests.
+ */
+export class AiSession extends Resource {
+  /**
+   * Blueprints and objects bound to the session.
+   */
+  private readonly _binder: AiContextBinder;
+  private readonly _feed: Feed.Feed;
+  private readonly _runtime: Runtime.Runtime<Feed.FeedService>;
+
+  public constructor(options: AiSessionOptions) {
+    super();
+    this._feed = options.feed;
+    this._runtime = options.runtime;
+    invariant(this._feed);
+    invariant(this._runtime);
+    this._binder = new AiContextBinder({ feed: this._feed, runtime: this._runtime, registry: options.registry });
+  }
+
+  protected override async _open(): Promise<void> {
+    await this._binder.open(this._ctx);
+  }
+
+  public get feed() {
+    return this._feed;
+  }
+
+  public get context() {
+    return this._binder;
+  }
+
+  public async getHistory(): Promise<Message.Message[]> {
+    const queryResult = await Runtime.runPromise(this._runtime)(Feed.query(this._feed, Filter.type(Message.Message)));
+    const items = await queryResult.run();
+    return items.filter(Obj.instanceOf(Message.Message));
+  }
+
+  getTools(): Effect.Effect<
+    Record<string, import('@effect/ai/Tool').Any>,
+    never,
+    ToolExecutionService | ToolResolverService
+  > {
+    return Effect.gen(this, function* () {
+      const toolkit = yield* createToolkit({ blueprints: this.context.getBlueprints() });
+      return toolkit.toolkit.tools;
+    }).pipe(Effect.orDie);
+  }
+
+  /**
+   * Not provided by default, since users might want to override them.
+   */
+  makeToolExecutionServices(): Layer.Layer<
+    ToolExecutionService | ToolResolverService,
+    never,
+    OpaqueToolkit.OpaqueToolkitProvider | Operation.Service | OperationRegistry.Service
+  > {
+    return ToolExecutionServices.pipe(
+      Layer.provide(Operation.withInvocationOptions({ conversation: Obj.getDXN(this._feed).toString() })),
+    );
+  }
+  /**
+   * Creates a new cancelable request effect.
+   */
+  public createRequest<R = never>(
+    params: AiSessionRunProps<R>,
+  ): Effect.Effect<Message.Message[], AiRequestRunError, AiRequestRunRequirements | R> {
+    return Effect.gen(this, function* () {
+      const history = yield* Effect.promise(() => this.getHistory());
+      const blueprints = this.context.getBlueprints();
+      const objects = this.context.getObjects();
+
+      log('run', {
+        history: history.length,
+        blueprints: blueprints.length,
+        objects: objects.length,
+      });
+
+      const request = new AiRequest({
+        summarizationThreshold: SUMMARY_THRESHOLD,
+        observer: params.observer,
+        onOutput: (message) =>
+          Effect.promise(() => Runtime.runPromise(this._runtime)(Feed.append(this._feed, [message]))),
+      });
+
+      yield* request.begin({
+        history,
+        blueprints,
+        objects,
+        prompt: params.prompt,
+        system: params.system,
+      });
+
+      // Turn loop: recompute toolkit and system prompt between turns to pick up dynamically enabled blueprints.
+      do {
+        yield* Effect.promise(() => this.context.sync());
+        const currentBlueprints = this.context.getBlueprints();
+        const mcps = yield* connectMcpServers(currentBlueprints, params.mcpServers);
+        const toolkit = yield* createToolkit({
+          toolkit: params.toolkit,
+          blueprints: currentBlueprints,
+          opaqueToolkits: mcps,
+        });
+
+        log('toolkit', { tools: Record.keys(toolkit.toolkit.tools) });
+        const system = yield* formatSystemPrompt({
+          system: params.system,
+          blueprints: currentBlueprints,
+          objects: this.context.getObjects(),
+        }).pipe(Effect.orDie);
+
+        const { done } = yield* request.runAgentTurn({ system, toolkit });
+        if (done) {
+          break;
+        }
+
+        yield* request.runTools({ toolkit });
+      } while (true);
+
+      log('result', {
+        messages: request.pending.length,
+        duration: request.duration,
+        toolCalls: request.toolCalls,
+      });
+
+      return [...request.pending];
+    }).pipe(
+      Effect.provide(
+        Layer.mergeAll(
+          Layer.succeed(AiContextService, {
+            binder: this.context,
+          }),
+          Layer.succeed(AiSessionService, this),
+          Operation.withInvocationOptions({ conversation: Obj.getDXN(this._feed).toString() }),
+        ),
+      ),
+      Effect.withSpan('AiSession.createRequest'),
+    );
+  }
+}
+
+/**
+ * Gives access to the ai session.
+ */
+export class AiSessionService extends Context.Tag('@dxos/assistant/AiSessionService')<AiSessionService, AiSession>() {
+  /**
+   * Create a new session layer from options.
+   */
+  static layer = (options: AiSessionOptions): Layer.Layer<AiSessionService | AiContextService> =>
+    aiContextFromSession.pipe(
+      Layer.provideMerge(
+        Layer.scoped(
+          AiSessionService,
+          Effect.gen(function* () {
+            const session = yield* acquireReleaseResource(() => new AiSession(options));
+            return session;
+          }),
+        ),
+      ),
+    );
+
+  /**
+   * Create a new session with a new feed.
+   */
+  static layerNewFeed = (
+    options?: Omit<AiSessionOptions, 'feed' | 'runtime'>,
+  ): Layer.Layer<AiSessionService | AiContextService, never, Database.Service | Feed.FeedService> =>
+    Layer.unwrapScoped(
+      Effect.gen(function* () {
+        const feed = Feed.make();
+        yield* Database.add(feed);
+        const runtime = yield* Effect.runtime<Feed.FeedService>();
+        return AiSessionService.layer({
+          ...options,
+          feed,
+          runtime,
+        });
+      }),
+    );
+
+  /**
+   * Run a prompt in the current session.
+   */
+  static run = <R = never>(
+    params: AiSessionRunProps<R>,
+  ): Effect.Effect<Message.Message[], AiRequestRunError, AiRequestRunRequirements | AiSessionService | R> =>
+    Effect.gen(function* () {
+      const session = yield* AiSessionService;
+      return yield* session.createRequest(params);
+    });
+}
+
+const aiContextFromSession = Layer.effect(
+  AiContextService,
+  Effect.gen(function* () {
+    const session = yield* AiSessionService;
+    return {
+      binder: session.context,
+    };
+  }),
+);
+
+const connectMcpServers = (
+  blueprints: readonly Blueprint.Blueprint[],
+  spaceMcpServers: readonly McpServerConfig[] = [],
+): Effect.Effect<OpaqueToolkit.OpaqueToolkit[], never, Trace.TraceService> => {
+  const blueprintServers: McpToolkit.McpToolkitOptions[] = pipe(
+    blueprints,
+    Array.flatMap((_) => _.mcpServers ?? []),
+    Array.map(({ url, protocol }) => ({ url, kind: protocol })),
+  );
+  const spaceServers: McpToolkit.McpToolkitOptions[] = spaceMcpServers.map(({ url, protocol, apiKey }) => ({
+    url,
+    kind: protocol,
+    apiKey,
+  }));
+  const allServers = [...blueprintServers, ...spaceServers];
+
+  return pipe(
+    allServers,
+    Effect.forEach((options) =>
+      McpToolkit.make(options).pipe(
+        // NOTE: Type-inference fails here without explicit void return.
+        Effect.tap((toolkit): void =>
+          log.info('Connected to MCP server', { url: options.url, tools: Object.keys(toolkit.toolkit.tools).length }),
+        ),
+        // Surface typed connection failures via ephemeral trace + warn log, then drop the server.
+        Effect.tapError((error) =>
+          Effect.gen(function* () {
+            log.warn('Failed to connect to MCP server', {
+              url: error.url,
+              kind: error.kind,
+              message: error.message,
+            });
+            yield* Trace.write(McpServerError, {
+              url: error.url,
+              kind: error.kind,
+              message: error.message,
+            });
+          }),
+        ),
+        // Catch unexpected defects too (e.g. malformed tool schemas) so a single broken
+        // server can never abort the whole turn — surface them through the same channel.
+        Effect.catchAllDefect((defect) =>
+          Effect.gen(function* () {
+            const message = defect instanceof Error ? defect.message : String(defect);
+            log.warn('Unexpected MCP defect', { url: options.url, message });
+            yield* Trace.write(McpServerError, {
+              url: options.url,
+              kind: options.kind,
+              message: `Unexpected MCP failure: ${message}`,
+            });
+            return yield* Effect.fail(
+              new McpToolkit.McpConnectionError({
+                url: options.url,
+                kind: options.kind,
+                message,
+              }),
+            );
+          }),
+        ),
+        Effect.either,
+      ),
+    ),
+    Effect.map(Array.filterMap((_) => Either.getRight(_))),
+  );
+};

package/src/execution-graph.ts

@@ -199,13 +199,19 @@ export class ExecutionGraph {
    */
   private _updatePendingToolResults(toolCallId: string, agentStatusId: string) {
     const toolResultId = this._pendingToolResults.get(toolCallId);
-    if (!toolResultId) return;
+    if (!toolResultId) {
+      return;
+    }
 
     const toolResultCommit = this._commits.find((c) => c.id === toolResultId);
-    if (!toolResultCommit) return;
+    if (!toolResultCommit) {
+      return;
+    }
 
     const toolCallCommitId = this._toolCallCommitIds.get(toolCallId);
-    if (!toolCallCommitId) return;
+    if (!toolCallCommitId) {
+      return;
+    }
 
     // Replace tool call commit with AgentStatus commit.
     const toolCallIndex = toolResultCommit.parents.indexOf(toolCallCommitId);
@@ -221,7 +227,9 @@ export class ExecutionGraph {
    */
   private _handleLateToolResultUpdate(toolCallId: string, toolResultId: string) {
     const toolCallCommitId = this._toolCallCommitIds.get(toolCallId);
-    if (!toolCallCommitId) return;
+    if (!toolCallCommitId) {
+      return;
+    }
 
     const messageId = toolCallCommitId.split('_toolCall_')[0];
     const toolCallBranch = `${messageId}_${toolCallId}`;
@@ -372,7 +380,9 @@ const createBlockCommit = (
   const timestamp = new Date(message.created);
   switch (block._tag) {
     case 'text':
-      if (!block.text.trim().length) return null;
+      if (!block.text.trim().length) {
+        return null;
+      }
       return {
         id: getGenericBlockId(message.id, idx),
         branch,

package/src/extraction/extraction.ts

@@ -4,9 +4,9 @@
 
 import * as Schema from 'effect/Schema';
 
+import { Operation } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
 import { Message } from '@dxos/types';
 
 export const ExtractionInput = Schema.Struct({

package/src/functions/services.ts

@@ -13,122 +13,30 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
 import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';
-import { GenericToolkit } from '@dxos/ai';
+import { OpaqueToolkit } from '@dxos/ai';
+import { Operation, OperationRegistry } from '@dxos/compute';
 import { todo } from '@dxos/debug';
 import { Ref } from '@dxos/echo';
-import { FunctionInvocationService, FunctionNotFoundError } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
-import { Operation, OperationRegistry } from '@dxos/operation';
 
 import { RefFromLLM } from '../types';
 
-/**
- * Constructs a `ToolResolverService` whose `resolve(id)` looks up tools in the following order:
- *  1. Toolkit: return an existing tool from the provided `toolkit` if one is present under `id`.
- *  2. Operations in DB: query by `key=id`; if found, deserialize and project to a tool.
- *  3. Registered operations: fall back to a matching `Operation.Definition` from the handler set.
- *
- * If none of the above yield a match, the effect fails with `AiToolNotFoundError`.
- *
- * Requires `Database.Service` in the environment.
- *
- * @deprecated Moving to operation-based services.
- */
-export const makeToolResolverFromFunctions = (): Layer.Layer<
-  ToolResolverService,
-  never,
-  GenericToolkit.GenericToolkitProvider | FunctionInvocationService
-> => {
-  return Layer.effect(
-    ToolResolverService,
-    Effect.gen(function* () {
-      const toolkitProvider = yield* GenericToolkit.GenericToolkitProvider;
-      const functionInvocationService = yield* FunctionInvocationService;
-      return {
-        resolve: (id): Effect.Effect<Tool.Any, AiToolNotFoundError> =>
-          Effect.gen(function* () {
-            const toolkit = toolkitProvider.getToolkit();
-
-            const tool = toolkit.toolkit.tools[id];
-            if (tool) {
-              return tool;
-            }
-
-            return yield* functionInvocationService.resolveFunction(id).pipe(
-              Effect.map(projectFunctionToTool),
-              Effect.catchTag('FunctionNotFound', () => Effect.fail(new AiToolNotFoundError(id))),
-            );
-          }),
-      } satisfies Context.Tag.Service<ToolResolverService>;
-    }),
-  );
-};
-
-/**
- * @deprecated Moving to operation-based services.
- */
-export const makeToolExecutionServiceFromFunctions = (): Layer.Layer<
-  ToolExecutionService,
-  never,
-  FunctionInvocationService | GenericToolkit.GenericToolkitProvider
-> => {
-  return Layer.effect(
-    ToolExecutionService,
-    Effect.gen(function* () {
-      const toolkitProvider = yield* GenericToolkit.GenericToolkitProvider;
-      const toolkit = toolkitProvider.getToolkit();
-
-      const toolkitHandler = yield* toolkit.toolkit.pipe(Effect.provide(toolkit.layer));
-      invariant(isHandlerLike(toolkitHandler));
-      const functionInvocationService = yield* FunctionInvocationService;
-
-      return {
-        handlersFor: (toolkit) => {
-          const makeHandler = (tool: Tool.Any): ((params: unknown) => Effect.Effect<unknown, any, any>) => {
-            return Effect.fn(`toolFunctionHandler ${tool.name}`)(function* (input: any) {
-              if (toolkitHandler.tools[tool.name]) {
-                if (Tool.isProviderDefined(tool)) {
-                  throw new Error('Attempted to call a provider-defined tool');
-                }
-
-                // TODO(wittjosiah): Everything is `never` here.
-                const { result } = yield* (toolkitHandler.handle as any)(tool.name, input);
-                return result;
-              }
-
-              const functionDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
-
-              return yield* functionInvocationService
-                .invokeFunction(functionDef, input as any)
-                .pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
-            });
-          };
-
-          return toolkit.of(
-            Record.map(toolkit.tools, (tool, _name) => (Tool.isUserDefined(tool) ? makeHandler(tool) : null)) as any,
-          ) as any;
-        },
-      };
-    }),
-  );
-};
-
 export const makeToolResolverFromOperations = <R = never>({
-  toolkit: extraToolkit = GenericToolkit.empty,
-}: { toolkit?: GenericToolkit.GenericToolkit<never, never, R> } = {}): Layer.Layer<
+  toolkit: extraToolkit = OpaqueToolkit.empty,
+}: { toolkit?: OpaqueToolkit.OpaqueToolkit<never, never, R> } = {}): Layer.Layer<
   ToolResolverService,
   never,
-  GenericToolkit.GenericToolkitProvider | OperationRegistry.Service | R
+  OpaqueToolkit.OpaqueToolkitProvider | OperationRegistry.Service | R
 > => {
   return Layer.effect(
     ToolResolverService,
     Effect.gen(function* () {
-      const toolkitProvider = yield* GenericToolkit.GenericToolkitProvider;
+      const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
       const operationRegistry = yield* OperationRegistry.Service;
       return {
         resolve: (id): Effect.Effect<Tool.Any, AiToolNotFoundError> =>
           Effect.gen(function* () {
-            const toolkit = GenericToolkit.merge(extraToolkit, toolkitProvider.getToolkit());
+            const toolkit = OpaqueToolkit.merge(extraToolkit, toolkitProvider.getToolkit());
 
             const tool = toolkit.toolkit.tools[id];
             if (tool) {
@@ -151,11 +59,11 @@ export const makeToolResolverFromOperations = <R = never>({
 
 export const makeToolExecutionService = <E, R>(opts: {
   invoke: (tool: Tool.Any, input: unknown) => Effect.Effect<unknown>;
-}): Layer.Layer<ToolExecutionService, never, GenericToolkit.GenericToolkitProvider> =>
+}): Layer.Layer<ToolExecutionService, never, OpaqueToolkit.OpaqueToolkitProvider> =>
   Layer.effect(
     ToolExecutionService,
     Effect.gen(function* () {
-      const toolkitProvider = yield* GenericToolkit.GenericToolkitProvider;
+      const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
       const toolkit = toolkitProvider.getToolkit();
 
       const toolkitHandler = yield* toolkit.toolkit.pipe(Effect.provide(toolkit.layer));
@@ -190,7 +98,7 @@ export const makeToolExecutionService = <E, R>(opts: {
 export const makeToolExecutionServiceFromOperationInvoker = (): Layer.Layer<
   ToolExecutionService,
   never,
-  Operation.Service | GenericToolkit.GenericToolkitProvider
+  Operation.Service | OpaqueToolkit.OpaqueToolkitProvider
 > => {
   return Layer.unwrapEffect(
     Effect.gen(function* () {
@@ -208,32 +116,9 @@ export const makeToolExecutionServiceFromOperationInvoker = (): Layer.Layer<
   );
 };
 
-/**
- * @deprecated Bridge beetwen deprecated function invocataion service and operation services until we remove function invocation service.
- */
-export const functionInvocationServiceFromOperations: Layer.Layer<
-  FunctionInvocationService,
-  never,
-  OperationRegistry.Service | Operation.Service
-> = Layer.effect(
-  FunctionInvocationService,
-  Effect.gen(function* () {
-    const operationRegistry = yield* OperationRegistry.Service;
-    const operationInvoker = yield* Operation.Service;
-    return {
-      invokeFunction: (operationDef, input) => operationInvoker.invoke(operationDef, input).pipe(Effect.orDie),
-      resolveFunction: (key) =>
-        operationRegistry.resolve(key).pipe(
-          Effect.flatten,
-          Effect.catchTag('NoSuchElementException', () => Effect.fail(new FunctionNotFoundError(key))),
-        ),
-    } satisfies Context.Tag.Service<FunctionInvocationService>;
-  }),
-);
-
 export const ToolExecutionServices = Layer.mergeAll(
-  makeToolResolverFromFunctions(),
-  makeToolExecutionServiceFromFunctions(),
+  makeToolResolverFromOperations(),
+  makeToolExecutionServiceFromOperationInvoker(),
 );
 
 class FunctionToolAnnotation extends Context.Tag('@dxos/assistant/FunctionToolAnnotation')<