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

package/src/execution-graph.test.ts

@@ -71,7 +71,7 @@ describe('ExecutionGraph', () => {
         blocks: [
           {
             _tag: 'text',
-            text: '{"id":"01K6AXZKK79H4E54RKP1YZDARK","@type":"dxn:type:dxos.org/type/Organization:0.1.0","@meta":{"keys":[]},"name":"Blue Yard","website":"https://blueyard.com"}',
+            text: '{"id":"01K6AXZKK79H4E54RKP1YZDARK","@type":"dxn:type:org.dxos.type.organization:0.1.0","@meta":{"keys":[]},"name":"Blue Yard","website":"https://blueyard.com"}',
           },
         ],
         properties: {},
@@ -619,7 +619,7 @@ describe('ExecutionGraph', () => {
           { _tag: 'reasoning', reasoningText: 'I need to think about this' },
           { _tag: 'toolCall', toolCallId: 'tool1', name: 'analyze', input: '{}', providerExecuted: false },
           {
-            _tag: 'summary',
+            _tag: 'stats',
             message: 'OK',
             duration: 1000,
             toolCalls: 1,

package/src/execution-graph.ts

@@ -412,7 +412,7 @@ const createBlockCommit = (
         message: block.error ? 'Tool error: ' + block.error : 'Tool call succeeded',
       } satisfies Commit;
 
-    case 'summary':
+    case 'stats':
       return {
         id: getGenericBlockId(message.id, idx),
         branch,
@@ -420,7 +420,7 @@ const createBlockCommit = (
         timestamp,
         icon: IconType.ROCKET,
         level: LogLevel.INFO,
-        message: ContentBlock.createSummaryMessage(block),
+        message: ContentBlock.createStatsMessage(block),
       } satisfies Commit;
 
     case 'status':

package/src/extraction/extraction-ner-function/index.ts

@@ -2,5 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './extraction-ner-function';
 export * from './named-entity-recognition';

package/src/extraction/extraction.ts

@@ -4,16 +4,14 @@
 
 import * as Schema from 'effect/Schema';
 
-import { asyncTimeout } from '@dxos/async';
-import { Type } from '@dxos/echo';
-import { type FunctionDefinition } from '@dxos/functions';
-import { type FunctionExecutor } from '@dxos/functions-runtime';
+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({
   message: Message.Message,
-  objects: Schema.optional(Schema.Array(Type.Obj)),
+  objects: Schema.optional(Schema.Array(Obj.Unknown)),
   options: Schema.optional(
     Schema.Struct({
       timeout: Schema.optional(Schema.Number),
@@ -31,8 +29,7 @@ export interface ExtractionOutput extends Schema.Schema.Type<typeof ExtractionOu
 
 export type ProcessTranscriptMessageProps = {
   input: ExtractionInput;
-  function: FunctionDefinition<ExtractionInput, ExtractionOutput>;
-  executor: FunctionExecutor;
+  function: Operation.Definition<ExtractionInput, ExtractionOutput>;
 
   options?: {
     /**
@@ -49,7 +46,35 @@ export type ProcessTranscriptMessageProps = {
   };
 };
 
-export type ExtractionFunction = FunctionDefinition<ExtractionInput, ExtractionOutput>;
+export type ExtractionFunction = Operation.Definition<ExtractionInput, ExtractionOutput>;
+
+/**
+ * Placeholder for Anthropic-based entity extraction.
+ * Implementation is currently disabled pending restoration of extraction logic.
+ */
+export const extractionAnthropicFunction = Operation.make({
+  meta: {
+    key: 'org.dxos.function.extraction.anthropic',
+    name: 'Entity Extraction (Anthropic)',
+    description: 'Extract entities from transcript using Anthropic LLM.',
+  },
+  input: ExtractionInput,
+  output: ExtractionOutput,
+});
+
+/**
+ * Placeholder for NER-based entity extraction.
+ * Implementation is currently disabled pending restoration of extraction logic.
+ */
+export const extractionNerFunction = Operation.make({
+  meta: {
+    key: 'org.dxos.function.extraction.ner',
+    name: 'Entity Extraction (NER)',
+    description: 'Extract entities from transcript using Named Entity Recognition.',
+  },
+  input: ExtractionInput,
+  output: ExtractionOutput,
+});
 
 /**
  * Extract entities from the transcript message and add them to the message.
@@ -58,9 +83,9 @@ export type ExtractionFunction = FunctionDefinition<ExtractionInput, ExtractionO
 export const processTranscriptMessage = async (params: ProcessTranscriptMessageProps): Promise<ExtractionOutput> => {
   try {
     if (params.options?.timeout && params.options.timeout > 0) {
-      return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);
+      // return await asyncTimeout(params.executor.invoke(params.function, params.input), params.options.timeout);
     } else {
-      return await params.executor.invoke(params.function, params.input);
+      // return await params.executor.invoke(params.function, params.input);
     }
   } catch (error) {
     if (params.options?.fallbackToRaw) {
@@ -73,4 +98,7 @@ export const processTranscriptMessage = async (params: ProcessTranscriptMessageP
       throw error;
     }
   }
+
+  // TODO(dmaretskyi): Restore extraction logic.
+  return { message: params.input.message, timeElapsed: 0 };
 };

package/src/extraction/index.ts

@@ -3,6 +3,5 @@
 //
 
 export * from './extraction';
-export * from './extraction-llm-function';
 export * from './extraction-ner-function';
 export * from './quotes';

package/src/functions/services.ts

@@ -9,71 +9,76 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Record from 'effect/Record';
 import * as Schema from 'effect/Schema';
-import type * as SchemaAST from 'effect/SchemaAST';
+import * as SchemaAST from 'effect/SchemaAST';
 
 import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { GenericToolkit } from '@dxos/ai';
 import { todo } from '@dxos/debug';
-import { Query, Type } from '@dxos/echo';
-import { Database } from '@dxos/echo';
-import { Function, FunctionDefinition, FunctionInvocationService } from '@dxos/functions';
+import { Ref } from '@dxos/echo';
+import { FunctionInvocationService, FunctionNotFoundError } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
+import { Operation, OperationRegistry } from '@dxos/operation';
+import * as Option from 'effect/Option';
 
 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. Functions in DB: query `FunctionType` by `key=id`; if found, deserialize and project to a tool
- *     (propagating any `deployedFunctionId` discovered in the object's metadata).
- *  3. Functions passed in: fall back to a matching `FunctionDefinition` from the `functions` array.
+ *  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 = (
-  functions: FunctionDefinition.Any[],
-  toolkit: Toolkit.Toolkit<any>,
-): Layer.Layer<ToolResolverService, never, Database.Service> => {
+export const makeToolResolverFromFunctions = (): Layer.Layer<
+  ToolResolverService,
+  never,
+  GenericToolkit.GenericToolkitProvider | FunctionInvocationService
+> => {
   return Layer.effect(
     ToolResolverService,
     Effect.gen(function* () {
-      const dbService = yield* Database.Service;
+      const toolkitProvider = yield* GenericToolkit.GenericToolkitProvider;
+      const functionInvocationService = yield* FunctionInvocationService;
       return {
         resolve: (id): Effect.Effect<Tool.Any, AiToolNotFoundError> =>
           Effect.gen(function* () {
-            // TODO(dmaretskyi): Use FunctionInvocationService.resolveFunction().
+            const toolkit = toolkitProvider.getToolkit();
 
-            const tool = toolkit.tools[id];
+            const tool = toolkit.toolkit.tools[id];
             if (tool) {
               return tool;
             }
 
-            const [dbFunction] = yield* Database.Service.runQuery(Query.type(Function.Function, { key: id }));
-
-            const functionDef = dbFunction
-              ? FunctionDefinition.deserialize(dbFunction)
-              : functions.find((fn) => fn.key === id);
-
-            if (!functionDef) {
-              return yield* Effect.fail(new AiToolNotFoundError(id));
-            }
-
-            return projectFunctionToTool(functionDef);
-          }).pipe(Effect.provideService(Database.Service, dbService)),
+            return yield* functionInvocationService.resolveFunction(id).pipe(
+              Effect.map(projectFunctionToTool),
+              Effect.catchTag('FunctionNotFound', () => Effect.fail(new AiToolNotFoundError(id))),
+            );
+          }),
       } satisfies Context.Tag.Service<ToolResolverService>;
     }),
   );
 };
 
-export const makeToolExecutionServiceFromFunctions = (
-  toolkit: Toolkit.Toolkit<any>,
-  handlersLayer: Layer.Layer<Tool.Handler<any>, never, never>,
-): Layer.Layer<ToolExecutionService, never, FunctionInvocationService> => {
+/**
+ * @deprecated Moving to operation-based services.
+ */
+export const makeToolExecutionServiceFromFunctions = (): Layer.Layer<
+  ToolExecutionService,
+  never,
+  FunctionInvocationService | GenericToolkit.GenericToolkitProvider
+> => {
   return Layer.effect(
     ToolExecutionService,
     Effect.gen(function* () {
-      const toolkitHandler = yield* toolkit.pipe(Effect.provide(handlersLayer));
+      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;
 
@@ -91,7 +96,7 @@ export const makeToolExecutionServiceFromFunctions = (
                 return result;
               }
 
-              const { definition: functionDef } = Context.get(FunctionToolAnnotation)(tool.annotations as any);
+              const functionDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
 
               return yield* functionInvocationService
                 .invokeFunction(functionDef, input as any)
@@ -108,33 +113,152 @@ export const makeToolExecutionServiceFromFunctions = (
   );
 };
 
+export const makeToolResolverFromOperations = <R = never>({
+  toolkit: extraToolkit = GenericToolkit.empty,
+}: { toolkit?: GenericToolkit.GenericToolkit<never, never, R> } = {}): Layer.Layer<
+  ToolResolverService,
+  never,
+  GenericToolkit.GenericToolkitProvider | OperationRegistry.Service | R
+> => {
+  return Layer.effect(
+    ToolResolverService,
+    Effect.gen(function* () {
+      const toolkitProvider = yield* GenericToolkit.GenericToolkitProvider;
+      const operationRegistry = yield* OperationRegistry.Service;
+      return {
+        resolve: (id): Effect.Effect<Tool.Any, AiToolNotFoundError> =>
+          Effect.gen(function* () {
+            const toolkit = GenericToolkit.merge(extraToolkit, toolkitProvider.getToolkit());
+
+            const tool = toolkit.toolkit.tools[id];
+            if (tool) {
+              return tool;
+            }
+
+            return yield* operationRegistry.resolve(id).pipe(
+              Effect.flatMap(
+                Option.match({
+                  onSome: (_) => Effect.succeed(projectFunctionToTool(_)),
+                  onNone: () => Effect.fail(new AiToolNotFoundError(id)),
+                }),
+              ),
+            );
+          }),
+      } satisfies Context.Tag.Service<ToolResolverService>;
+    }),
+  );
+};
+
+export const makeToolExecutionService = <E, R>(opts: {
+  invoke: (tool: Tool.Any, input: unknown) => Effect.Effect<unknown>;
+}): Layer.Layer<ToolExecutionService, never, GenericToolkit.GenericToolkitProvider> =>
+  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));
+
+      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;
+              }
+
+              return yield* opts.invoke(tool, input).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 makeToolExecutionServiceFromOperationInvoker = (): Layer.Layer<
+  ToolExecutionService,
+  never,
+  Operation.Service | GenericToolkit.GenericToolkitProvider
+> => {
+  return Layer.unwrapEffect(
+    Effect.gen(function* () {
+      const operationInvoker = yield* Operation.Service;
+
+      return makeToolExecutionService({
+        invoke: (tool, input) =>
+          Effect.gen(function* () {
+            const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
+
+            return yield* operationInvoker.invoke(operationDef, input).pipe(Effect.orDie);
+          }),
+      });
+    }),
+  );
+};
+
+/**
+ * @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(),
+);
+
 class FunctionToolAnnotation extends Context.Tag('@dxos/assistant/FunctionToolAnnotation')<
   FunctionToolAnnotation,
-  { definition: FunctionDefinition.Any }
+  { definition: Operation.Definition.Any }
 >() {}
 
-const toolCache = new WeakMap<FunctionDefinition.Any, Tool.Any>();
+export const getOperationFromTool = (tool: Tool.Any): Option.Option<Operation.Definition.Any> => {
+  return Context.getOption(FunctionToolAnnotation)(tool.annotations).pipe(Option.map(({ definition }) => definition));
+};
+
+const toolCache = new WeakMap<Operation.Definition.Any, Tool.Any>();
 
 /**
- * Projects a `FunctionDefinition` into an `AiTool`.
- *
- * @param fn The function definition to project into a tool.
- * @param meta Optional projection metadata.
- * @param meta.deployedFunctionId Backend deployment ID used for remote invocation when present.
- *    This is the EDGE service's function deployment identifier (not the ECHO object ID/DXN and not `FunctionDefinition.key`).
+ * Projects an `Operation.Definition` into an `AiTool`.
  */
-const projectFunctionToTool = (fn: FunctionDefinition.Any): Tool.Any => {
+const projectFunctionToTool = (fn: Operation.Definition.Any): Tool.Any => {
   if (toolCache.has(fn)) {
     return toolCache.get(fn)!;
   }
 
-  // TODO(burdon): Use and map function.key?
-  // TODO(dmaretskyi): Use function key instead.
-  const tool = Tool.make(makeToolName(fn.name), {
-    description: fn.description,
-    parameters: createStructFieldsFromSchema(fn.inputSchema),
-    // TODO(dmaretskyi): Include output schema.
-    failure: Schema.Any, // TODO(dmaretskyi): Better type for the failure?
+  const tool = Tool.make(makeToolName(fn.meta.name ?? fn.meta.key), {
+    description: fn.meta.description,
+    parameters: createStructFieldsFromSchema(fn.input),
+    failure: Schema.Any,
   }).annotate(FunctionToolAnnotation, { definition: fn });
   toolCache.set(fn, tool);
   return tool;
@@ -168,8 +292,33 @@ const createStructFieldsFromSchema = (schema: Schema.Schema<any, any>): Record<s
  * The picked schema type decodes to the original schema type.
  */
 const mapSchemaTypeForLLM = (ast: SchemaAST.AST): SchemaAST.AST => {
-  if (Type.Ref.isRefSchemaAST(ast)) {
-    return RefFromLLM.ast;
+  if (Ref.isRefType(ast)) {
+    const description = ast.annotations.description
+      ? ast.annotations.description + '\n' + RefFromLLM.ast.annotations.description
+      : (RefFromLLM.ast.annotations.description as string);
+    return RefFromLLM.annotations({ description }).ast;
+  } else if (SchemaAST.isTupleType(ast)) {
+    return new SchemaAST.TupleType(
+      ast.elements.map((t) => new SchemaAST.OptionalType(mapSchemaTypeForLLM(t.type), t.isOptional, t.annotations)),
+      ast.rest.map((t) => new SchemaAST.Type(mapSchemaTypeForLLM(t.type), t.annotations)),
+      ast.isReadonly,
+      ast.annotations,
+    );
+  } else if (SchemaAST.isTypeLiteral(ast)) {
+    return new SchemaAST.TypeLiteral(
+      ast.propertySignatures.map(
+        (p) =>
+          new SchemaAST.PropertySignature(
+            p.name,
+            mapSchemaTypeForLLM(p.type),
+            p.isOptional,
+            p.isReadonly,
+            p.annotations,
+          ),
+      ),
+      ast.indexSignatures,
+      ast.annotations,
+    );
   }
 
   return ast;