@dxos/assistant-toolkit 0.8.4-main.c85a9c8dae → 0.8.4-main.dfabb4ec29

package/src/blueprints/database/functions/context-add.ts

@@ -3,33 +3,22 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
 import { AiContextService } from '@dxos/assistant';
-import { Obj, Ref } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import { Operation } from '@dxos/compute';
 
-export default defineFunction({
-  key: 'dxos.org/function/database/context-add',
-  name: 'Add to context',
-  description: trim`
-    Adds the object to the chat context.
-    Use this it for objects that are useful long-term for the conversation.
-  `,
-  inputSchema: Schema.Struct({
-    obj: Ref.Ref(Obj.Unknown).annotations({
-      description: 'Object to add to the chat context.',
+import { ContextAdd } from './definitions';
+
+export default ContextAdd.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ obj }) {
+      const { binder } = yield* AiContextService;
+      yield* Effect.promise(() =>
+        binder.bind({
+          blueprints: [],
+          objects: [obj],
+        }),
+      );
     }),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { obj } }) {
-    const { binder } = yield* AiContextService;
-    yield* Effect.promise(() =>
-      binder.bind({
-        blueprints: [],
-        objects: [obj],
-      }),
-    );
-  }, AiContextService.fixFunctionHandlerType),
-});
+  ),
+);

package/src/blueprints/database/functions/context-remove.ts

@@ -3,33 +3,22 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
 import { AiContextService } from '@dxos/assistant';
-import { Obj, Ref } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import { Operation } from '@dxos/compute';
 
-export default defineFunction({
-  key: 'dxos.org/function/database/context-remove',
-  name: 'Remove from context',
-  description: trim`
-    Removes the object from the chat context.
-    Use this it for objects that are no longer useful for the conversation.
-  `,
-  inputSchema: Schema.Struct({
-    obj: Ref.Ref(Obj.Unknown).annotations({
-      description: 'Object to remove from the chat context.',
-    }),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { obj } }) {
-    const { binder } = yield* AiContextService;
-    yield* Effect.promise(() =>
-      binder.unbind({
-        blueprints: [],
-        objects: [obj],
-      }),
-    );
-  }, AiContextService.fixFunctionHandlerType),
-});
+import { ContextRemove } from './definitions';
+
+export default ContextRemove.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ obj }) {
+      const { binder } = yield* AiContextService;
+      yield* Effect.promise(() =>
+        binder.unbind({
+          blueprints: [],
+          objects: [obj],
+        }),
+      );
+    }) as any,
+  ),
+);

package/src/blueprints/database/functions/definitions.ts

@@ -0,0 +1,318 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { AiContextService } from '@dxos/assistant';
+import { Operation } from '@dxos/compute';
+import { Database, Obj, Ref, Relation, Tag } from '@dxos/echo';
+import { trim } from '@dxos/util';
+
+export const Query = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.query',
+    name: 'Query',
+    description: trim`
+      Query for objects in ECHO.
+      Use this tool when searching for information in the space (both automerge and queues).
+      Currently, two types of queries are supported:
+        - Full-text search - terms may appear anywhere in the object.
+        - Type-based search - objects of a specific type.
+      You can use them together, for example, to search for objects of a specific type that match a full-text query.
+      Important: Whem querying by typename, make sure to list the schema first, to get the exact typename.
+
+      Omit both typename and text to search for all objects.
+
+      <output_format>
+        You can choose to either return the full object data, or just the DXN, type and label.
+        When expecting a lot of results, run with includeContent=false to not pollute the context, and then load specific objects using the load tool.
+
+        You can choose to get the content right away, if you don't expect a lot of results.
+        To load content right away, run with includeContent=true.
+        When loading content, set an appropriate limit on the number of results to avoid overwhelming the context.
+      </output_format>
+
+      <example description="All tasks related to Cyberdyne and Bob">
+        {
+          "typename": "org.dxos.type.task",
+          "text": "cyberdyne bob",
+        }
+      </example>
+
+      <example description="Financial report Q1 2026">
+        {
+          "typename": "org.dxos.type.document",
+          "text": "financial report Q1 2026",
+          "includeContent": true
+          "limit": 3
+        }
+      </example>
+
+      <example description="Emails from specific mailboxes">
+        {
+          "in": [{"/" : "dxn:echo:@:YYYYYY"}, {"/" : "dxn:echo:@:XXXXXXX"}],
+          "typename": "org.dxos.type.email",
+          "includeContent": true,
+          "limit": 20
+        }
+      </example>
+    `,
+  },
+  input: Schema.Struct({
+    in: Schema.optional(
+      Schema.Array(Ref.Ref(Obj.Unknown)).annotations({
+        description:
+          'Scope the query to children of specific objects (transitively). ' +
+          'Use this to query items within containers such as feeds or folders. ' +
+          'For example, to find emails use `in: [mailbox1.feed, mailbox2.feed]`.',
+      }),
+    ),
+    typename: Schema.optional(
+      Schema.String.annotations({
+        description: 'The typename of the objects to list.',
+        example: 'org.dxos.type.task',
+      }),
+    ),
+    text: Schema.optional(
+      Schema.String.annotations({
+        description: 'Full text search query.',
+        example: 'email cyberdyne bob',
+      }),
+    ),
+    includeContent: Schema.optional(
+      Schema.Boolean.annotations({
+        description: 'Include the full object data in the response.',
+        default: false,
+      }),
+    ),
+    limit: Schema.optional(
+      Schema.Number.annotations({
+        description: 'The maximum number of results to return.',
+        default: 10,
+      }),
+    ),
+    includeQueues: Schema.optional(
+      Schema.Boolean.annotations({
+        description: 'Search in queues as well as spaces. Only use this if searching for emails.',
+        default: false,
+      }),
+    ),
+  }),
+  output: Schema.Array(Schema.Unknown),
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const Load = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.load',
+    name: 'Load object',
+    description: trim`
+      Loads the object or relation content.
+      Can load multiple objects at at time.
+      Use the to read the data when you have a DXN.
+      Call this tool with an array of one or more DXNs or object IDs.
+      When use see a reference ({ '/': 'dxn:...' }), you can call this function to load the object.
+      Note that returned data is only a snapshot in time, and might have changed since the object was last loaded.
+    `,
+  },
+  input: Schema.Struct({
+    refs: Schema.Array(Ref.Ref(Obj.Unknown)),
+  }),
+  output: Schema.Unknown,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const ObjectCreate = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.object-create',
+    name: 'Create object',
+    description: trim`
+      Creates a new object and adds it to the current space.
+      Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
+      References are provided in the following format: { "/": "dxn:..." }.
+      Reference examples: { "/": "dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4" }, { "/": "dxn:queue:data:01KG7R1ZXWFMWQ4DA1Q6TN1DG4:01KG7R1ZXWFMWQ4DA1Q6TN1DG4" }
+    `,
+  },
+  input: Schema.Struct({
+    typename: Schema.String,
+    data: Schema.Any,
+  }),
+  output: Schema.Unknown,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const ObjectUpdate = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.object-update',
+    name: 'Update object',
+    description: trim`
+      Updates the object properties.
+      References are provided in the following format: { "/": "dxn:..." }.
+      Reference examples: { "/": "dxn:echo:@:01KG7R1ZXWFMWQ4DA1Q6TN1DG4" }, { "/": "dxn:queue:data:01KG7R1ZXWFMWQ4DA1Q6TN1DG4:01KG7R1ZXWFMWQ4DA1Q6TN1DG4" }
+    `,
+  },
+  input: Schema.Struct({
+    obj: Ref.Ref(Obj.Unknown),
+    properties: Schema.Record({ key: Schema.String, value: Schema.Any }),
+  }),
+  output: Schema.Unknown,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const ObjectDelete = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.object-delete',
+    name: 'Delete object',
+    description: trim`
+      Deletes the object.
+    `,
+  },
+  input: Schema.Struct({
+    obj: Ref.Ref(Obj.Unknown),
+  }),
+  output: Schema.Void,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const SchemaAdd = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.schema-add',
+    name: 'Add schema',
+    description: trim`
+      Adds a schema to the space.
+      The name will be used when displayed to the user.
+    `,
+  },
+  input: Schema.Struct({
+    name: Schema.String,
+    typename: Schema.String.annotations({
+      description: 'The typename of the schema in the format of "com.example.type.type".',
+    }),
+    jsonSchema: Schema.Any,
+  }),
+  output: Schema.Void,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const SchemaList = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.schema-list',
+    name: 'List schemas',
+    description: trim`
+      Lists schemas definitions.
+    `,
+  },
+  input: Schema.Struct({
+    limit: Schema.optional(Schema.Number),
+  }),
+  output: Schema.Array(Schema.Unknown),
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const ContextAdd = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.context-add',
+    name: 'Add to context',
+    description: trim`
+      Adds the object to the chat context.
+      Use this it for objects that are useful long-term for the conversation.
+    `,
+  },
+  input: Schema.Struct({
+    obj: Ref.Ref(Obj.Unknown).annotations({
+      description: 'Object to add to the chat context.',
+    }),
+  }),
+  output: Schema.Void,
+  services: [AiContextService],
+}).pipe(Operation.intrinsic);
+
+export const ContextRemove = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.context-remove',
+    name: 'Remove from context',
+    description: trim`
+      Removes the object from the chat context.
+      Use this it for objects that are no longer useful for the conversation.
+    `,
+  },
+  input: Schema.Struct({
+    obj: Ref.Ref(Obj.Unknown).annotations({
+      description: 'Object to remove from the chat context.',
+    }),
+  }),
+  output: Schema.Void,
+  services: [AiContextService],
+}).pipe(Operation.intrinsic);
+
+export const RelationCreate = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.relation-create',
+    name: 'Create relation',
+    description: trim`
+      Creates a new relation and adds it to the current space.
+      Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
+    `,
+  },
+  input: Schema.Struct({
+    typename: Schema.String,
+    source: Ref.Ref(Obj.Unknown),
+    target: Ref.Ref(Obj.Unknown),
+    properties: Schema.Any.annotations({
+      description: 'The data to be stored in the relation.',
+    }),
+  }),
+  output: Schema.Unknown,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const RelationDelete = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.relation-delete',
+    name: 'Delete relation',
+    description: trim`
+      Deletes the relation.
+    `,
+  },
+  input: Schema.Struct({
+    rel: Ref.Ref(Relation.Unknown),
+  }),
+  output: Schema.Void,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const TagAdd = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.tag-add',
+    name: 'Add tag',
+    description: trim`
+      Adds a tag to an object.
+      Tags are objects of type ${Tag.Tag.typename}.
+      You must search database for available tags, or create a new one.
+    `,
+  },
+  input: Schema.Struct({
+    tag: Ref.Ref(Obj.Unknown),
+    obj: Ref.Ref(Obj.Unknown),
+  }),
+  output: Schema.Unknown,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);
+
+export const TagRemove = Operation.make({
+  meta: {
+    key: 'org.dxos.function.database.tag-remove',
+    name: 'Remove tag',
+    description: trim`
+      Removes a tag from an object.
+      Tags are objects of type ${Tag.Tag.typename}.
+    `,
+  },
+  input: Schema.Struct({
+    tag: Ref.Ref(Obj.Unknown),
+    obj: Ref.Ref(Obj.Unknown),
+  }),
+  output: Schema.Unknown,
+  services: [Database.Service],
+}).pipe(Operation.intrinsic);

package/src/blueprints/database/functions/index.ts

@@ -2,32 +2,22 @@
 // Copyright 2025 DXOS.org
 //
 
-import { default as ContextAdd } from './context-add';
-import { default as ContextRemove } from './context-remove';
-import { default as Load } from './load';
-import { default as ObjectCreate } from './object-create';
-import { default as ObjectDelete } from './object-delete';
-import { default as ObjectUpdate } from './object-update';
-import { default as Query } from './query';
-import { default as RelationCreate } from './relation-create';
-import { default as RelationDelete } from './relation-delete';
-import { default as SchemaAdd } from './schema-add';
-import { default as SchemaList } from './schema-list';
-import { default as TagAdd } from './tag-add';
-import { default as TagRemove } from './tag-remove';
+import { OperationHandlerSet } from '@dxos/compute';
 
-export const DatabaseFunctions = {
-  ContextAdd,
-  ContextRemove,
-  Load,
-  ObjectCreate,
-  ObjectDelete,
-  ObjectUpdate,
-  Query,
-  RelationCreate,
-  RelationDelete,
-  SchemaAdd,
-  SchemaList,
-  TagAdd,
-  TagRemove,
-};
+export * from './definitions';
+
+export const DatabaseHandlers = OperationHandlerSet.lazy(
+  () => import('./context-add'),
+  () => import('./context-remove'),
+  () => import('./load'),
+  () => import('./object-create'),
+  () => import('./object-delete'),
+  () => import('./object-update'),
+  () => import('./query'),
+  () => import('./relation-create'),
+  () => import('./relation-delete'),
+  () => import('./schema-add'),
+  () => import('./schema-list'),
+  () => import('./tag-add'),
+  () => import('./tag-remove'),
+);

package/src/blueprints/database/functions/load.ts

@@ -4,28 +4,16 @@
 
 import * as Array from 'effect/Array';
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, Entity, Obj, Ref } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import { Operation } from '@dxos/compute';
+import { Database, Entity } from '@dxos/echo';
 
-export default defineFunction({
-  key: 'dxos.org/function/database/load',
-  name: 'Load object',
-  description: trim`
-    Loads the object or relation content.
-    Can load multiple objects at at time.
-    Use the to read the data when you have a DXN.
-    Call this tool with an array of one or more DXNs or object IDs.
-    When use see a reference ({ '/': 'dxn:...' }), you can call this function to load the object.
-    Note that returned data is only a snapshot in time, and might have changed since the object was last loaded.
-  `,
-  inputSchema: Schema.Struct({
-    refs: Schema.Array(Ref.Ref(Obj.Unknown)),
-  }),
-  outputSchema: Schema.Unknown,
-  handler: Effect.fn(function* ({ data: { refs } }) {
-    return yield* Effect.forEach(refs, Database.load).pipe(Effect.map(Array.map(Entity.toJSON)));
-  }),
-});
+import { Load } from './definitions';
+
+export default Load.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ refs }) {
+      return yield* Effect.forEach(refs, Database.load).pipe(Effect.map(Array.map(Entity.toJSON)));
+    }),
+  ),
+);

package/src/blueprints/database/functions/object-create.ts

@@ -3,33 +3,36 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
+import { Operation } from '@dxos/compute';
 import { Database, Entity, Obj, Type } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
+import { EncodedReference } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
-import { trim } from '@dxos/util';
+import { deepMapValues } from '@dxos/util';
 
-export default defineFunction({
-  key: 'dxos.org/function/database/object-create',
-  name: 'Create object',
-  description: trim`
-    Creates a new object and adds it to the current space.
-    Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
-  `,
-  inputSchema: Schema.Struct({
-    typename: Schema.String,
-    data: Schema.Any,
-  }),
-  outputSchema: Schema.Unknown,
-  handler: Effect.fn(function* ({ data: { typename, data } }) {
-    const { db } = yield* Database.Service;
-    const schema = yield* Effect.promise(() =>
-      db.schemaRegistry.query({ typename, location: ['database', 'runtime'] }).first(),
-    );
-    invariant(Type.isObjectSchema(schema), 'Schema is not an object schema');
+import { ObjectCreate } from './definitions';
 
-    const object = db.add(Obj.make(schema, data));
-    return Entity.toJSON(object);
-  }),
-});
+export default ObjectCreate.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ typename, data }) {
+      const { db } = yield* Database.Service;
+      const schema = yield* Effect.promise(() =>
+        db.schemaRegistry.query({ typename, location: ['database', 'runtime'] }).first(),
+      );
+      invariant(Type.isObjectSchema(schema), 'Schema is not an object schema');
+
+      const object = db.add(
+        Obj.make(
+          schema,
+          deepMapValues(data, (value, recurse) => {
+            if (EncodedReference.isEncodedReference(value)) {
+              return db.makeRef(EncodedReference.toDXN(value));
+            }
+            return recurse(value);
+          }),
+        ),
+      );
+      return Entity.toJSON(object);
+    }),
+  ),
+);

package/src/blueprints/database/functions/object-delete.ts

@@ -3,25 +3,18 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, Obj, Ref } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import { Operation } from '@dxos/compute';
+import { Database } from '@dxos/echo';
 
-export default defineFunction({
-  key: 'dxos.org/function/database/object-delete',
-  name: 'Delete object',
-  description: trim`
-    Deletes the object.
-  `,
-  inputSchema: Schema.Struct({
-    obj: Ref.Ref(Obj.Unknown),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { obj } }) {
-    const { db } = yield* Database.Service;
-    const object = yield* Database.load(obj);
-    db.remove(object);
-  }),
-});
+import { ObjectDelete } from './definitions';
+
+export default ObjectDelete.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ obj }) {
+      const { db } = yield* Database.Service;
+      const object = yield* Database.load(obj);
+      db.remove(object);
+    }),
+  ),
+);

package/src/blueprints/database/functions/object-update.ts

@@ -3,30 +3,28 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, Entity, Obj, Ref } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import { Operation } from '@dxos/compute';
+import { Database, Entity } from '@dxos/echo';
+import { EncodedReference } from '@dxos/echo-protocol';
 
-export default defineFunction({
-  key: 'dxos.org/function/database/object-update',
-  name: 'Update object',
-  description: trim`
-    Updates the object properties.
-  `,
-  inputSchema: Schema.Struct({
-    obj: Ref.Ref(Obj.Unknown),
-    properties: Schema.Record({ key: Schema.String, value: Schema.Any }),
-  }),
-  outputSchema: Schema.Unknown,
-  handler: Effect.fn(function* ({ data: { obj, properties } }) {
-    const object = yield* Database.load(obj);
-    Entity.change(object as Entity.Any, (obj) => {
-      for (const [key, value] of Object.entries(properties)) {
-        obj[key] = value;
-      }
-    });
-    return Entity.toJSON(object);
-  }),
-});
+import { ObjectUpdate } from './definitions';
+
+export default ObjectUpdate.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ obj, properties }) {
+      const { db } = yield* Database.Service;
+      const object = yield* Database.load(obj);
+      Entity.update(object as Entity.Any, (obj) => {
+        for (const [key, value] of Object.entries(properties)) {
+          if (EncodedReference.isEncodedReference(value)) {
+            obj[key] = db.makeRef(EncodedReference.toDXN(value));
+          } else {
+            obj[key] = value;
+          }
+        }
+      });
+      return Entity.toJSON(object);
+    }),
+  ),
+);