@dxos/assistant 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

package/src/extraction/extraction.ts

@@ -2,17 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { asyncTimeout } from '@dxos/async';
-import { Expando } from '@dxos/echo-schema';
-import { type FunctionDefinition, type FunctionExecutor } from '@dxos/functions';
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Message } from '@dxos/types';
 
 export const ExtractionInput = Schema.Struct({
-  message: DataType.Message,
-  objects: Schema.optional(Schema.Array(Expando)),
+  message: Message.Message,
+  objects: Schema.optional(Schema.Array(Obj.Unknown)),
   options: Schema.optional(
     Schema.Struct({
       timeout: Schema.optional(Schema.Number),
@@ -23,15 +22,14 @@ export const ExtractionInput = Schema.Struct({
 export interface ExtractionInput extends Schema.Schema.Type<typeof ExtractionInput> {}
 
 export const ExtractionOutput = Schema.Struct({
-  message: DataType.Message,
+  message: Message.Message,
   timeElapsed: Schema.Number,
 });
 export interface ExtractionOutput extends Schema.Schema.Type<typeof ExtractionOutput> {}
 
-export type ProcessTranscriptMessageParams = {
+export type ProcessTranscriptMessageProps = {
   input: ExtractionInput;
-  function: FunctionDefinition<ExtractionInput, ExtractionOutput>;
-  executor: FunctionExecutor;
+  function: Operation.Definition<ExtractionInput, ExtractionOutput>;
 
   options?: {
     /**
@@ -48,18 +46,46 @@ export type ProcessTranscriptMessageParams = {
   };
 };
 
-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.
  */
 // TODO(dmaretskyi): Move context to a vector search index.
-export const processTranscriptMessage = async (params: ProcessTranscriptMessageParams): Promise<ExtractionOutput> => {
+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) {
@@ -72,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/extraction/quotes.ts

@@ -2,11 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { Filter, Query } from '@dxos/echo';
-import { type EchoDatabase } from '@dxos/echo-db';
-import { ObjectId } from '@dxos/echo-schema';
+import { type Database, Filter, Query } from '@dxos/echo';
+import { ObjectId } from '@dxos/keys';
 import { DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
 
@@ -28,10 +27,10 @@ export const ReferencedQuotes = Schema.Struct({
 });
 export type ReferencedQuotes = Schema.Schema.Type<typeof ReferencedQuotes>;
 
-export const findQuotes = async (quotes: string[], db: EchoDatabase): Promise<ReferencedQuotes> => {
+export const findQuotes = async (quotes: string[], db: Database.Database): Promise<ReferencedQuotes> => {
   const references = await Promise.all(
     quotes.map(async (quote) => {
-      const { objects } = await db.query(Query.select(Filter.text(quote, { type: 'vector' }))).run();
+      const objects = await db.query(Query.select(Filter.text(quote, { type: 'vector' }))).run();
       log.info('found quotes in vector index', { objects, quote });
       return objects.length > 0 ? [{ id: objects[0].id.toString(), quote }] : [];
     }),

package/src/functions/services.ts

@@ -2,71 +2,72 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Tool, type Toolkit } from '@effect/ai';
-import { Context, Effect, Layer, Record, Schema } from 'effect';
+import * as Tool from '@effect/ai/Tool';
+import type * as Toolkit from '@effect/ai/Toolkit';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 
 import { AiToolNotFoundError, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { OpaqueToolkit } from '@dxos/ai';
+import { Operation, OperationRegistry } from '@dxos/compute';
 import { todo } from '@dxos/debug';
-import { Query } from '@dxos/echo';
-import { DatabaseService, FunctionDefinition, FunctionInvocationService, FunctionType } from '@dxos/functions';
+import { Ref } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 
-/**
- * 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.
- *
- * If none of the above yield a match, the effect fails with `AiToolNotFoundError`.
- *
- * Requires `DatabaseService` in the environment.
- */
-export const makeToolResolverFromFunctions = (
-  functions: FunctionDefinition<any, any>[],
-  toolkit: Toolkit.Toolkit<any>,
-): Layer.Layer<ToolResolverService, never, DatabaseService> => {
+import { RefFromLLM } from '../types';
+
+export const makeToolResolverFromOperations = <R = never>({
+  toolkit: extraToolkit = OpaqueToolkit.empty,
+}: { toolkit?: OpaqueToolkit.OpaqueToolkit<never, never, R> } = {}): Layer.Layer<
+  ToolResolverService,
+  never,
+  OpaqueToolkit.OpaqueToolkitProvider | OperationRegistry.Service | R
+> => {
   return Layer.effect(
     ToolResolverService,
     Effect.gen(function* () {
-      const dbService = yield* DatabaseService;
+      const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
+      const operationRegistry = yield* OperationRegistry.Service;
       return {
         resolve: (id): Effect.Effect<Tool.Any, AiToolNotFoundError> =>
           Effect.gen(function* () {
-            const tool = toolkit.tools[id];
+            const toolkit = OpaqueToolkit.merge(extraToolkit, toolkitProvider.getToolkit());
+
+            const tool = toolkit.toolkit.tools[id];
             if (tool) {
               return tool;
             }
 
-            const {
-              objects: [dbFunction],
-            } = yield* DatabaseService.runQuery(Query.type(FunctionType, { 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(DatabaseService, dbService)),
+            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 makeToolExecutionServiceFromFunctions = (
-  toolkit: Toolkit.Toolkit<any>,
-  handlersLayer: Layer.Layer<Tool.Handler<any>, never, never>,
-): Layer.Layer<ToolExecutionService, never, FunctionInvocationService> => {
-  return Layer.effect(
+export const makeToolExecutionService = <E, R>(opts: {
+  invoke: (tool: Tool.Any, input: unknown) => Effect.Effect<unknown>;
+}): Layer.Layer<ToolExecutionService, never, OpaqueToolkit.OpaqueToolkitProvider> =>
+  Layer.effect(
     ToolExecutionService,
     Effect.gen(function* () {
-      const toolkitHandler = yield* toolkit.pipe(Effect.provide(handlersLayer));
+      const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
+      const toolkit = toolkitProvider.getToolkit();
+
+      const toolkitHandler = yield* toolkit.toolkit.pipe(Effect.provide(toolkit.layer));
       invariant(isHandlerLike(toolkitHandler));
-      const functionInvocationService = yield* FunctionInvocationService;
 
       return {
         handlersFor: (toolkit) => {
@@ -76,15 +77,13 @@ export const makeToolExecutionServiceFromFunctions = (
                 if (Tool.isProviderDefined(tool)) {
                   throw new Error('Attempted to call a provider-defined tool');
                 }
+
                 // TODO(wittjosiah): Everything is `never` here.
-                return yield* (toolkitHandler.handle as any)(tool.name, input);
+                const { result } = yield* (toolkitHandler.handle as any)(tool.name, input);
+                return result;
               }
 
-              const { definition: functionDef } = Context.get(FunctionToolAnnotation)(tool.annotations as any);
-
-              return yield* functionInvocationService
-                .invokeFunction(functionDef, input as any)
-                .pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
+              return yield* opts.invoke(tool, input).pipe(Effect.catchAllDefect((defect) => Effect.fail(defect)));
             });
           };
 
@@ -95,33 +94,56 @@ export const makeToolExecutionServiceFromFunctions = (
       };
     }),
   );
+
+export const makeToolExecutionServiceFromOperationInvoker = (): Layer.Layer<
+  ToolExecutionService,
+  never,
+  Operation.Service | OpaqueToolkit.OpaqueToolkitProvider
+> => {
+  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);
+          }),
+      });
+    }),
+  );
 };
 
+export const ToolExecutionServices = Layer.mergeAll(
+  makeToolResolverFromOperations(),
+  makeToolExecutionServiceFromOperationInvoker(),
+);
+
 class FunctionToolAnnotation extends Context.Tag('@dxos/assistant/FunctionToolAnnotation')<
   FunctionToolAnnotation,
-  { definition: FunctionDefinition<any, any> }
+  { definition: Operation.Definition.Any }
 >() {}
 
-const toolCache = new WeakMap<FunctionDefinition<any, 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, any>): Tool.Any => {
+const projectFunctionToTool = (fn: Operation.Definition.Any): Tool.Any => {
   if (toolCache.has(fn)) {
     return toolCache.get(fn)!;
   }
 
-  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;
@@ -131,8 +153,8 @@ const projectFunctionToTool = (fn: FunctionDefinition<any, any>): Tool.Any => {
  * @returns Tool name produced from function name by escaping invalid characters.
  */
 const makeToolName = (name: string) => {
-  const toolName = name.replace(/[^a-zA-Z0-9]/g, '_');
-  invariant(toolName.match(/^[a-zA-Z_][a-zA-Z0-9-_]*$/));
+  const toolName = name.toLowerCase().replace(/[^a-zA-Z0-9]/g, '-');
+  invariant(toolName.match(/^[a-z_][a-z0-9-_]*$/));
   return toolName;
 };
 
@@ -140,7 +162,9 @@ const makeToolName = (name: string) => {
 const createStructFieldsFromSchema = (schema: Schema.Schema<any, any>): Record<string, Schema.Schema<any, any>> => {
   switch (schema.ast._tag) {
     case 'TypeLiteral':
-      return Object.fromEntries(schema.ast.propertySignatures.map((prop) => [prop.name, Schema.make(prop.type)]));
+      return Object.fromEntries(
+        schema.ast.propertySignatures.map((prop) => [prop.name, Schema.make(mapSchemaTypeForLLM(prop.type))]),
+      );
     case 'VoidKeyword':
       return {};
     default:
@@ -148,6 +172,43 @@ const createStructFieldsFromSchema = (schema: Schema.Schema<any, any>): Record<s
   }
 };
 
+/**
+ * Picks an LLM-friendly schema type for the given schema AST.
+ * The picked schema type decodes to the original schema type.
+ */
+const mapSchemaTypeForLLM = (ast: SchemaAST.AST): SchemaAST.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;
+};
+
 const isHandlerLike = (value: unknown): value is Toolkit.WithHandler<Record<string, Tool.Any>> => {
   return typeof (value as any).tools === 'object' && typeof (value as any).handle === 'function';
 };

package/src/functions.conversations.json

@@ -0,0 +1 @@
+{"conversations":[{"parameters":{"model":"@anthropic/claude-opus-4-6","stream":true,"tools":[{"name":"read-name","description":"Reads the name of an organization.","inputSchema":{"type":"object","required":["org"],"properties":{"org":{"type":"string","description":"The ID of the referenced object. Formats accepted:\n- DXN (dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4). DXNs can be prepended with an @ symbol for compatibility with in-text references.\n- space ID, object ID tuple (spaceID:objectID)\n- Only object ID that is assumed to be in the current space (01KG7R1ZXWFMWQ4DA1Q6TN1DG4)","examples":["dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4","@dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4","BM3FSHFOMJCHCG5QW7JTVKGYABD2GAA7G:01KG7R1ZXWFMWQ4DA1Q6TN1DG4","01KG7R1ZXWFMWQ4DA1Q6TN1DG4"]}},"additionalProperties":false}}]},"prompt":{"content":[{"role":"user","content":"What is the name of the organization? 01JGFJJZ00G0WKQSJGMAKCNT89","options":{"anthropic":{"cacheControl":{"ttl":"5m","type":"ephemeral"}}}}]},"response":[{"type":"response-metadata","id":"msg_01RTYeojYbdVe9QGkcMvKbER","modelId":"claude-opus-4-6","timestamp":"1970-01-01T00:00:00.000Z","metadata":{}},{"type":"reasoning-start","id":"0","metadata":{}},{"type":"reasoning-delta","id":"0","delta":"The","metadata":{}},{"type":"reasoning-delta","id":"0","delta":" user wants to know the name of an organization with ID 01JGFJJZ00G0WKQSJGMAKCNT89.","metadata":{}},{"type":"reasoning-delta","id":"0","delta":"","metadata":{"anthropic":{"type":"thinking","signature":"EpECClkIDRgCKkBhbbtJF+Q+wsAR8giXTK13Eui/M8yFfrB46Vzozj6aWeupuZy0FCx6VSI4FmNelVTGMCsbT5apFxxgVf6A7FAJMg9jbGF1ZGUtb3B1cy00LTY4ABIMHOEtEgcKz5Wb+gpbGgxPG+AOzUXWigifeyUiML7FnkmDoz8pWD5P9R4Wul/DeoJE41ntyU/B/abCz0pQx4PHE8N4i5aoFBhUuQE5hSpmlXcA03Cj9t8LvHSOwMobEUZcnKTZn9x1upUfts+Ez+NsQBXY//niKxqt/E7yE5TKHwDO/nuZ2rteTus79EjTEkPaEUcXQso8YAbQknG7ldRd1Nd2X4D2X+bBJH2AVG7SKLSFW3QAGAE="}}},{"type":"reasoning-end","id":"0","metadata":{}},{"type":"tool-params-start","id":"toolu_01KM7uhfLgRWepvTtotjHME2","name":"read-name","providerExecuted":false,"metadata":{}},{"type":"tool-params-delta","id":"toolu_01KM7uhfLgRWepvTtotjHME2","delta":"","metadata":{}},{"type":"tool-params-delta","id":"toolu_01KM7uhfLgRWepvTtotjHME2","delta":"{\"org\": \"01","metadata":{}},{"type":"tool-params-delta","id":"toolu_01KM7uhfLgRWepvTtotjHME2","delta":"JGFJJZ0","metadata":{}},{"type":"tool-params-delta","id":"toolu_01KM7uhfLgRWepvTtotjHME2","delta":"0G0W","metadata":{}},{"type":"tool-params-delta","id":"toolu_01KM7uhfLgRWepvTtotjHME2","delta":"KQSJGMAKCN","metadata":{}},{"type":"tool-params-delta","id":"toolu_01KM7uhfLgRWepvTtotjHME2","delta":"T89\"}","metadata":{}},{"type":"tool-params-end","id":"toolu_01KM7uhfLgRWepvTtotjHME2","metadata":{}},{"type":"finish","reason":"tool-calls","usage":{"inputTokens":883,"outputTokens":122,"totalTokens":1005},"metadata":{"anthropic":{"usage":{"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":883,"output_tokens":9,"server_tool_use":null,"service_tier":"standard"}}}}]},{"parameters":{"model":"@anthropic/claude-opus-4-6","stream":true,"tools":[{"name":"read-name","description":"Reads the name of an organization.","inputSchema":{"type":"object","required":["org"],"properties":{"org":{"type":"string","description":"The ID of the referenced object. Formats accepted:\n- DXN (dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4). DXNs can be prepended with an @ symbol for compatibility with in-text references.\n- space ID, object ID tuple (spaceID:objectID)\n- Only object ID that is assumed to be in the current space (01KG7R1ZXWFMWQ4DA1Q6TN1DG4)","examples":["dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4","@dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4","BM3FSHFOMJCHCG5QW7JTVKGYABD2GAA7G:01KG7R1ZXWFMWQ4DA1Q6TN1DG4","01KG7R1ZXWFMWQ4DA1Q6TN1DG4"]}},"additionalProperties":false}}]},"prompt":{"content":[{"role":"user","content":"What is the name of the organization? 01JGFJJZ00G0WKQSJGMAKCNT89","options":{}},{"role":"assistant","content":[{"type":"reasoning","text":"The user wants to know the name of an organization with ID 01JGFJJZ00G0WKQSJGMAKCNT89.","options":{}},{"type":"tool-call","id":"toolu_01KM7uhfLgRWepvTtotjHME2","name":"read-name","params":{"org":"01JGFJJZ00G0WKQSJGMAKCNT89"},"providerExecuted":false,"options":{}}],"options":{}},{"role":"tool","content":[{"type":"tool-result","id":"toolu_01KM7uhfLgRWepvTtotjHME2","name":"read-name","isFailure":false,"result":"BlueYard","providerExecuted":false,"options":{}}],"options":{"anthropic":{"cacheControl":{"ttl":"5m","type":"ephemeral"}}}}]},"response":[{"type":"response-metadata","id":"msg_016RCVnGrLXVf4ba4KznSHyr","modelId":"claude-opus-4-6","timestamp":"1970-01-01T00:00:00.000Z","metadata":{}},{"type":"reasoning-start","id":"0","metadata":{}},{"type":"reasoning-delta","id":"0","delta":"The","metadata":{}},{"type":"reasoning-delta","id":"0","delta":" name of the organization is \"BlueYard\".","metadata":{}},{"type":"reasoning-delta","id":"0","delta":"","metadata":{"anthropic":{"type":"thinking","signature":"EuYBClkIDRgCKkA0n2vPrvDwpmiAgWX5raN/PW8EkSgAqlMsO4gsgxIXidyUWiozI8lhzJTYOm5D3BOTMcW+mcfUvAw1rtDVianiMg9jbGF1ZGUtb3B1cy00LTY4ABIMiAi8SSliRognm8yNGgx+gpH0kejwSoiouLAiMBy9umHrGuQCJ92KaaBqRAq50lt7WXRaCyO3vuheveWN1JDryUFhh7GUZ/pogH0m+Co7lZSQmO4ybaE4MmyYbu7S3e/upJcsrQIiMB7LByFcpfSrjsF/VSIPprW5kMMafV1yQ6U2uI+dhUTohKMYAQ=="}}},{"type":"reasoning-end","id":"0","metadata":{}},{"type":"text-start","id":"1","metadata":{}},{"type":"text-delta","id":"1","delta":"The name of the organization with ID `01JGFJJZ00G0WKQSJGMAKCNT89` is","metadata":{}},{"type":"text-delta","id":"1","delta":" **BlueYard**.","metadata":{}},{"type":"text-end","id":"1","metadata":{}},{"type":"finish","reason":"stop","usage":{"inputTokens":973,"outputTokens":66,"totalTokens":1039},"metadata":{"anthropic":{"usage":{"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":973,"output_tokens":8,"server_tool_use":null,"service_tier":"standard"}}}}]}]}

package/src/index.ts

@@ -10,3 +10,4 @@ export * from './functions';
 export * from './session';
 export * from './templates';
 export * from './types';
+export * from './tracing';

package/src/session/artifact-diff.ts

@@ -2,10 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context } from 'effect';
+import * as Context from 'effect/Context';
 
 import { type ObjectVersion } from '@dxos/echo-db';
-import { type ObjectId } from '@dxos/echo-schema';
+import { type ObjectId } from '@dxos/keys';
 
 /**
  * Resolves artifact ids to their versions.

package/src/session/error-handling.ts

@@ -2,9 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AiError } from '@effect/ai';
-import { HttpClientError } from '@effect/platform';
-import { Effect, Schema } from 'effect';
+import * as AiError from '@effect/ai/AiError';
+import * as HttpClientError from '@effect/platform/HttpClientError';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
 import { AiModelError } from '../errors';
 

package/src/session/format.ts

@@ -2,21 +2,22 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Array, Effect, Option, pipe } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
 
-import { Template } from '@dxos/blueprints';
-import { Obj } from '@dxos/echo';
+import { type FunctionNotFoundError, type Operation, type OperationRegistry, Template } from '@dxos/compute';
+import { type Database, Obj } from '@dxos/echo';
 import { ObjectVersion } from '@dxos/echo-db';
-import { type ObjectId } from '@dxos/echo-schema';
-import { DatabaseService } from '@dxos/functions';
+import type { ObjectNotFoundError } from '@dxos/echo/Err';
+import { type ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type ContentBlock, DataType } from '@dxos/schema';
+import { type ContentBlock, Message } from '@dxos/types';
 import { trim } from '@dxos/util';
 
 import { AiAssistantError } from '../errors';
-
 import { ArtifactDiffResolver } from './artifact-diff';
-import { type AiSessionRunParams } from './session';
+import { type AiRequestRunError, type AiRequestRunProps } from './request';
 
 /**
  * Formats the system prompt.
@@ -26,20 +27,24 @@ export const formatSystemPrompt = ({
   system,
   blueprints = [],
   objects = [],
-}: Pick<AiSessionRunParams<any>, 'system' | 'blueprints' | 'objects'>) =>
+}: Pick<AiRequestRunProps, 'system' | 'blueprints' | 'objects'>): Effect.Effect<
+  string,
+  FunctionNotFoundError | ObjectNotFoundError,
+  Database.Service | OperationRegistry.Service | Operation.Service
+> =>
   Effect.gen(function* () {
-    const blueprintDefs = yield* pipe(
+    const blueprintDefs = yield* Function.pipe(
       blueprints,
       Effect.forEach((blueprint) => Effect.succeed(blueprint.instructions)),
-      Effect.flatMap(Effect.forEach((template) => DatabaseService.loadOption(template.source))),
-      Effect.map(Array.filter(Option.isSome)),
-      Effect.map(
-        Array.map(
-          (template) => trim`
+      Effect.flatMap(
+        Effect.forEach((template) =>
+          Effect.gen(function* () {
+            return trim`
             <blueprint>
-              ${Template.process(template.value.content)}
+              ${yield* Template.processTemplate(template)}
             </blueprint>
-          `,
+          `;
+          }),
         ),
       ),
       Effect.map((blueprints) =>
@@ -47,7 +52,7 @@ export const formatSystemPrompt = ({
       ),
     );
 
-    const objectDefs = yield* pipe(
+    const objectDefs = yield* Function.pipe(
       objects,
       Effect.forEach((object) =>
         Effect.succeed(trim`
@@ -60,18 +65,21 @@ export const formatSystemPrompt = ({
       Effect.map((objects) => (objects.length > 0 ? ['## Context Objects', ...objects].join('\n\n') : undefined)),
     );
 
-    return yield* pipe(
+    return yield* Function.pipe(
       Effect.succeed([system, blueprintDefs, objectDefs].filter((def): def is string => def !== undefined)),
       Effect.map((parts) => parts.join('\n\n')),
     );
-  });
+  }).pipe(Effect.withSpan('formatSystemPrompt'));
 
 /**
  * Formats the user prompt.
  */
 // TODO(burdon): Move to AiPreprocessor.
 // TODO(burdon): Convert util below to `Effect.fn` (to preserve stack info)
-export const formatUserPrompt = ({ prompt, history = [] }: Pick<AiSessionRunParams<any>, 'prompt' | 'history'>) =>
+export const formatUserPrompt = ({
+  prompt,
+  history = [],
+}: Pick<AiRequestRunProps, 'prompt' | 'history'>): Effect.Effect<Message.Message, AiRequestRunError> =>
   Effect.gen(function* () {
     const blocks: ContentBlock.Any[] = [];
 
@@ -102,14 +110,14 @@ export const formatUserPrompt = ({ prompt, history = [] }: Pick<AiSessionRunPara
       }
     }
 
-    return Obj.make(DataType.Message, {
+    return Obj.make(Message.Message, {
       created: new Date().toISOString(),
       sender: { role: 'user' },
-      blocks: [...blocks, { _tag: 'text', text: prompt }],
+      blocks: typeof prompt === 'string' ? [...blocks, { _tag: 'text', text: prompt }] : [...blocks, ...prompt],
     });
-  });
+  }).pipe(Effect.withSpan('formatUserPrompt'));
 
-const gatherObjectVersions = (messages: DataType.Message[]): Map<ObjectId, ObjectVersion> => {
+const gatherObjectVersions = (messages: Message.Message[]): Map<ObjectId, ObjectVersion> => {
   const artifactIds = new Map<ObjectId, ObjectVersion>();
   for (const message of messages) {
     for (const block of message.blocks) {
@@ -128,7 +136,7 @@ const createArtifactUpdateBlock = (
   return {
     _tag: 'text',
     // TODO(dmaretskyi): Does this need to be a special content-block?
-    disposition: 'artifact-update',
+    disposition: 'synthetic',
     text: trim`
       The following artifacts have been updated since the last message:
       ${[...artifactDiff.entries()]

package/src/session/index.ts

@@ -4,6 +4,7 @@
 
 export * from './artifact-diff';
 export * from './observer';
-export * from './session';
+export * from './request';
 export * from './toolkit';
 export * from './version-pin';
+export * from './format';

package/src/session/observer.ts

@@ -2,20 +2,24 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Function } from 'effect';
+import type * as Tool from '@effect/ai/Tool';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
 
 import { type AiParser, type ConsolePrinter } from '@dxos/ai';
-import { type DataType } from '@dxos/schema';
+import { type Message } from '@dxos/types';
 
 /**
  * Live observer of the generation process.
  */
-export interface GenerationObserver extends AiParser.ParseResponseCallbacks {
+export interface GenerationObserver<
+  Tools extends Record<string, Tool.Any> = any,
+> extends AiParser.ParseResponseCallbacks<Tools> {
   /**
    * 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>;
+  onMessage: (message: Message.Message) => Effect.Effect<void>;
 }
 
 export const GenerationObserver = Object.freeze({