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

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

@@ -3,124 +3,62 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Entity, Filter, Obj, Query } from '@dxos/echo';
+import { Operation } from '@dxos/compute';
+import { Entity, Filter, Obj, Query as EchoQuery } from '@dxos/echo';
 import { Database } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
 
-// TODO(burdon): Move to toolkit (i.e., tool not function).
-export default defineFunction({
-  key: 'dxos.org/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": "dxos.org/type/Task",
-          "text": "cyberdyne bob",
-        }
-      </example>
+import { Query } from './definitions';
 
-      <example description="Financial report Q1 2026">
-        {
-          "typename": "dxos.org/type/Document",
-          "text": "financial report Q1 2026",
-          "includeContent": true
-          "limit": 3
+// TODO(burdon): Move to toolkit (i.e., tool not function).
+export default Query.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ in: parents, typename, text, includeContent = false, limit = 10, includeQueues = false }) {
+      const { db } = yield* Database.Service;
+      let query: EchoQuery.Any;
+      if (text) {
+        query = EchoQuery.all(
+          ...text.split(' ').map((term) => EchoQuery.select(Filter.text(term, { type: 'full-text' }))),
+        );
+        if (typename !== undefined) {
+          const schema = yield* Database.runSchemaQuery({ typename, location: ['database', 'runtime'] });
+          if (schema.length === 0) {
+            return yield* Effect.fail(new Error(`Schema ${typename} not found`));
+          }
+          query = query.select(Filter.type(schema[0]));
         }
-      </example>
-    `,
-  inputSchema: Schema.Struct({
-    typename: Schema.optional(
-      Schema.String.annotations({
-        description: 'The typename of the objects to list.',
-        example: 'dxos.org/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,
-      }),
-    ),
-    // TODO(dmaretskyi): There's a problem with querying queues, that the agent keeps finding message from agent threads.
-    //                   Let's think about a better way to do this.
-    //                   And queues don't have predicatble ids, so queue DXNs blow up the conversation cache.
-    includeQueues: Schema.optional(
-      Schema.Boolean.annotations({
-        description: 'Search in queues as well as spaces. Only use this if searching for emails.',
-        default: false,
-      }),
-    ),
-  }),
-  outputSchema: Schema.Array(Schema.Unknown),
-  handler: Effect.fn(function* ({
-    data: { typename, text, includeContent = false, limit = 10, includeQueues = false },
-  }) {
-    let query: Query.Any;
-    if (text) {
-      query = Query.all(...text.split(' ').map((term) => Query.select(Filter.text(term, { type: 'full-text' }))));
-      if (typename !== undefined) {
+      } else if (typename) {
         const schema = yield* Database.runSchemaQuery({ typename, location: ['database', 'runtime'] });
         if (schema.length === 0) {
           return yield* Effect.fail(new Error(`Schema ${typename} not found`));
         }
-        // NOTE: Query by typename string doesn't work for dynamic schemas.
-        query = query.select(Filter.type(schema[0]));
+        query = EchoQuery.select(Filter.type(schema[0]));
+      } else {
+        query = EchoQuery.select(Filter.everything());
+      }
+
+      if (parents && parents.length > 0) {
+        query = query.select(Filter.childOf(parents));
       }
-    } else if (typename) {
-      query = Query.select(Filter.type(typename));
-    } else {
-      query = Query.select(Filter.everything());
-    }
-    query = query.limit(limit);
-    if (includeQueues) {
-      query = query.from({ allQueuesFromSpaces: true });
-    }
 
-    // Update indexes before querying to make sure we get the latest results.
-    yield* Database.flush({ indexes: true });
-    const results = yield* Database.runQuery(query);
-    if (includeContent) {
-      return results.map((obj) => Entity.toJSON(obj));
-    } else {
-      return results.map((obj) => ({
-        dxn: Obj.getDXN(obj).toString(),
-        typename: Obj.getTypename(obj),
-        label: Obj.getLabel(obj),
-      }));
-    }
-  }),
-});
+      query = query.limit(limit);
+      if (includeQueues) {
+        // Must scope to the current space: `from({ allQueuesFromSpaces: true })` alone has no spaceIds, so the SQL
+        // index returns nothing (see ObjectMetaIndex.buildSourceCondition / early returns when spaceIds are empty).
+        query = query.from(db, { includeFeeds: true });
+      }
+
+      yield* Database.flush();
+      const results = yield* Database.runQuery(query);
+      if (includeContent) {
+        return results.map((obj) => Entity.toJSON(obj));
+      } else {
+        return results.map((obj) => ({
+          dxn: Obj.getDXN(obj).toString(),
+          typename: Obj.getTypename(obj),
+          label: Obj.getLabel(obj),
+        }));
+      }
+    }),
+  ),
+);

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

@@ -3,45 +3,32 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, Entity, Obj, Ref, Relation, Type } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
+import { Operation } from '@dxos/compute';
+import { Database, Entity, Relation, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
-import { trim } from '@dxos/util';
 
-export default defineFunction({
-  key: 'dxos.org/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.
-  `,
-  inputSchema: 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.',
-    }),
-  }),
-  outputSchema: Schema.Unknown,
-  handler: Effect.fn(function* ({ data: { typename, source, target, properties } }) {
-    const { db } = yield* Database.Service;
-    const schema = yield* Effect.promise(() =>
-      db.schemaRegistry.query({ typename, location: ['database', 'runtime'] }).first(),
-    );
-    invariant(Type.isRelationSchema(schema), 'Schema is not a relation schema');
+import { RelationCreate } from './definitions';
+
+export default RelationCreate.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ typename, source, target, properties }) {
+      const { db } = yield* Database.Service;
+      const schema = yield* Effect.promise(() =>
+        db.schemaRegistry.query({ typename, location: ['database', 'runtime'] }).first(),
+      );
+      invariant(Type.isRelationSchema(schema), 'Schema is not a relation schema');
 
-    const sourceObj = yield* Database.load(source);
-    const targetObj = yield* Database.load(target);
-    const relation = db.add(
-      Relation.make(schema, {
-        [Relation.Source]: sourceObj,
-        [Relation.Target]: targetObj,
-        ...properties,
-      }),
-    );
-    return Entity.toJSON(relation);
-  }),
-});
+      const sourceObj = yield* Database.load(source);
+      const targetObj = yield* Database.load(target);
+      const relation = db.add(
+        Relation.make(schema, {
+          [Relation.Source]: sourceObj,
+          [Relation.Target]: targetObj,
+          ...properties,
+        }),
+      );
+      return Entity.toJSON(relation);
+    }),
+  ),
+);

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

@@ -3,26 +3,19 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, Ref, Relation } 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/relation-delete',
-  name: 'Delete relation',
-  description: trim`
-    Deletes the relation.
-  `,
-  inputSchema: Schema.Struct({
-    rel: Ref.Ref(Relation.Unknown),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { rel } }) {
-    const { db } = yield* Database.Service;
-    const relation = yield* Database.load(rel);
-    // TODO(dmaretskyi): Echo types broken.
-    db.remove(relation as any);
-  }),
-});
+import { RelationDelete } from './definitions';
+
+export default RelationDelete.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ rel }) {
+      const { db } = yield* Database.Service;
+      const relation = yield* Database.load(rel);
+      // TODO(dmaretskyi): Echo types broken.
+      db.remove(relation as any);
+    }),
+  ),
+);

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

@@ -3,38 +3,26 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
+import { Operation } from '@dxos/compute';
 import { Database } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
 
-export default defineFunction({
-  key: 'dxos.org/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.
-  `,
-  inputSchema: Schema.Struct({
-    name: Schema.String,
-    typename: Schema.String.annotations({
-      description: 'The typename of the schema in the format of "example.com/type/Type".',
+import { SchemaAdd } from './definitions';
+
+export default SchemaAdd.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ name, typename, jsonSchema }) {
+      const { db } = yield* Database.Service;
+      yield* Effect.promise(() =>
+        db.schemaRegistry.register([
+          {
+            typename,
+            version: '0.1.0',
+            jsonSchema,
+            name,
+          },
+        ]),
+      );
     }),
-    jsonSchema: Schema.Any,
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { name, typename, jsonSchema } }) {
-    const { db } = yield* Database.Service;
-    yield* Effect.promise(() =>
-      db.schemaRegistry.register([
-        {
-          typename,
-          version: '0.1.0',
-          jsonSchema,
-          name,
-        },
-      ]),
-    );
-  }),
-});
+  ),
+);

package/src/blueprints/database/functions/schema-list.ts

@@ -3,32 +3,31 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, JsonSchema, Type } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import { Routine, Blueprint, Operation } from '@dxos/compute';
+import { Database, Feed, JsonSchema, Type, View } from '@dxos/echo';
 
-export default defineFunction({
-  key: 'dxos.org/function/database/schema-list',
-  name: 'List schemas',
-  description: trim`
-    Lists schemas definitions.
-  `,
-  inputSchema: Schema.Struct({
-    limit: Schema.optional(Schema.Number),
-  }),
-  outputSchema: Schema.Array(Schema.Unknown),
-  handler: Effect.fn(function* () {
-    const { db } = yield* Database.Service;
-    const schema = yield* Effect.promise(() => db.schemaRegistry.query({ location: ['database', 'runtime'] }).run());
-    return schema.map((schema) => {
-      const meta = Type.getMeta(schema);
-      return {
-        typename: Type.getTypename(schema),
-        jsonSchema: JsonSchema.toJsonSchema(schema),
-        kind: meta?.sourceSchema ? 'relation' : 'record',
-      };
-    });
-  }),
-});
+import { SchemaList } from './definitions';
+
+// TODO(dmaretskyi): This is a balance between not filling the agent's context with too many types and not excluding important types.
+const EXCLUDED_TYPES = [Type.PersistentType, View.View, Routine.Routine, Blueprint.Blueprint, Feed.Feed];
+const excludedTypenames = EXCLUDED_TYPES.map((type) => Type.getTypename(type));
+
+export default SchemaList.pipe(
+  Operation.withHandler(
+    Effect.fn(function* () {
+      const { db } = yield* Database.Service;
+      const schema = yield* Effect.promise(() => db.schemaRegistry.query({ location: ['database', 'runtime'] }).run());
+      return schema
+        .filter((schema) => !excludedTypenames.includes(Type.getTypename(schema)))
+        .map((schema) => {
+          const meta = Type.getMeta(schema);
+          return {
+            typename: Type.getTypename(schema),
+            jsonSchema: JsonSchema.toJsonSchema(schema),
+            kind: meta?.sourceSchema ? 'relation' : 'record',
+          };
+        });
+    }),
+  ),
+);

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

@@ -3,29 +3,19 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, Entity, Obj, Ref, Tag } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import { Operation } from '@dxos/compute';
+import { Database, Entity, Obj } from '@dxos/echo';
 
-export default defineFunction({
-  key: 'dxos.org/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.
-  `,
-  inputSchema: Schema.Struct({
-    tag: Ref.Ref(Obj.Unknown),
-    obj: Ref.Ref(Obj.Unknown),
-  }),
-  outputSchema: Schema.Unknown,
-  handler: Effect.fn(function* ({ data: { tag, obj } }) {
-    const object = yield* Database.load(obj);
-    const tagObj = yield* Database.load(tag);
-    Entity.change(object, (obj) => Entity.addTag(obj, Obj.getDXN(tagObj).toString()));
-    return Entity.toJSON(object);
-  }),
-});
+import { TagAdd } from './definitions';
+
+export default TagAdd.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ tag, obj }) {
+      const object = yield* Database.load(obj);
+      const tagObj = yield* Database.load(tag);
+      Entity.update(object, (object) => Entity.addTag(object, Obj.getDXN(tagObj).toString()));
+      return Entity.toJSON(object);
+    }),
+  ),
+);

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

@@ -3,28 +3,19 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { Database, Entity, Obj, Ref, Tag } from '@dxos/echo';
-import { defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
+import { Operation } from '@dxos/compute';
+import { Database, Entity, Obj } from '@dxos/echo';
 
-export default defineFunction({
-  key: 'dxos.org/function/database/tag-remove',
-  name: 'Remove tag',
-  description: trim`
-    Removes a tag from an object.
-    Tags are objects of type ${Tag.Tag.typename}.
-  `,
-  inputSchema: Schema.Struct({
-    tag: Ref.Ref(Obj.Unknown),
-    obj: Ref.Ref(Obj.Unknown),
-  }),
-  outputSchema: Schema.Unknown,
-  handler: Effect.fn(function* ({ data: { tag, obj } }) {
-    const object = yield* Database.load(obj);
-    const tagObj = yield* Database.load(tag);
-    Entity.change(object, (obj) => Entity.removeTag(obj, Obj.getDXN(tagObj).toString()));
-    return Entity.toJSON(object);
-  }),
-});
+import { TagRemove } from './definitions';
+
+export default TagRemove.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ tag, obj }) {
+      const object = yield* Database.load(obj);
+      const tagObj = yield* Database.load(tag);
+      Entity.update(object, (object) => Entity.removeTag(object, Obj.getDXN(tagObj).toString()));
+      return Entity.toJSON(object);
+    }),
+  ),
+);

package/src/blueprints/database/index.ts

@@ -3,4 +3,19 @@
 //
 
 export { default as DatabaseBlueprint } from './blueprint';
-export { DatabaseFunctions } from './functions';
+export {
+  Query as DatabaseQuery,
+  Load as DatabaseLoad,
+  ObjectCreate,
+  ObjectUpdate,
+  ObjectDelete,
+  SchemaAdd,
+  SchemaList,
+  ContextAdd,
+  ContextRemove,
+  RelationCreate,
+  RelationDelete,
+  TagAdd,
+  TagRemove,
+  DatabaseHandlers,
+} from './functions';

package/src/blueprints/discord/blueprint.ts

@@ -2,18 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ToolId } from '@dxos/ai';
-import { type AppCapabilities } from '@dxos/app-toolkit';
-import { Blueprint } from '@dxos/blueprints';
+import { Blueprint } from '@dxos/compute';
 import { Ref } from '@dxos/echo';
 import { Text } from '@dxos/schema';
 import { trim } from '@dxos/util';
 
-import { DiscordFunctions } from './functions';
+import { FetchMessages } from './functions';
 
-const BLUEPRINT_KEY = 'dxos.org/blueprint/discord';
-
-const functions = Object.values(DiscordFunctions);
+const BLUEPRINT_KEY = 'org.dxos.blueprint.discord';
 
 /**
  * Agent prompt instructions for managing hierarchical task lists.
@@ -32,14 +28,13 @@ const make = () =>
     name: 'Discord',
     description: 'Discord integration.',
     instructions: {
-      source: Ref.make(Text.make(instructions)),
+      source: Ref.make(Text.make({ content: instructions })),
     },
-    tools: [ToolId.make(DiscordFunctions.Fetch.key)],
+    tools: Blueprint.toolDefinitions({ operations: [FetchMessages] }),
   });
 
-const blueprint: AppCapabilities.BlueprintDefinition = {
+const blueprint: Blueprint.Definition = {
   key: BLUEPRINT_KEY,
-  functions,
   make,
 };
 

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

@@ -0,0 +1,70 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Credential, Trace, Operation } from '@dxos/compute';
+
+// TODO(dmaretskyi): Extract.
+const TimeRangeSchema = Schema.String.pipe(Schema.pattern(/\d+(s|m|h|d)/)).annotations({
+  description: 'Time range. 1d - 1 day, 2h - 2 hours, 30m - 30 minutes, 15s - 15 seconds.',
+  examples: ['1d', '2h', '30m', '15s'],
+});
+
+export const TimeRange = Object.assign(TimeRangeSchema, {
+  toSeconds(timeRange: string) {
+    const match = timeRange.match(/(\d+)(s|m|h|d)/);
+    if (!match) {
+      throw new Error(`Invalid time range: ${timeRange}`);
+    }
+    const [_, amount, unit] = match;
+    switch (unit) {
+      case 's':
+        return Number(amount);
+      case 'm':
+        return Number(amount) * 60;
+      case 'h':
+        return Number(amount) * 60 * 60;
+      case 'd':
+        return Number(amount) * 24 * 60 * 60;
+      default:
+        throw new Error(`Invalid time range unit: ${unit}`);
+    }
+  },
+});
+
+export const FetchMessages = Operation.make({
+  meta: {
+    key: 'org.dxos.function.fetch-discord-messages',
+    name: 'Sync Discord messages',
+  },
+  input: Schema.Struct({
+    serverId: Schema.String.annotations({
+      description: 'The ID of the server to fetch messages from.',
+    }),
+    channelId: Schema.optional(Schema.String).annotations({
+      description:
+        'The ID of the channel to fetch messages from. Will crawl all channels from the server if not specified.',
+    }),
+    after: Schema.optional(Schema.Number).annotations({
+      description:
+        'Fetch messages that were sent after a given date. Unix timestamp in seconds. Exclusive with `last`.',
+    }),
+    last: TimeRange.annotations({
+      description:
+        'Time range to fetch most recent messages. Specifies the range in the past, from now. "1d" would fetch messages from the last 24 hours.',
+    }),
+    limit: Schema.optional(Schema.Number).annotations({
+      description: 'The maximum number of messages to fetch.',
+    }),
+    pageSize: Schema.optional(Schema.Number).annotations({
+      description: 'The number of messages to fetch per page.',
+    }),
+    ignoreUsernames: Schema.optional(Schema.Array(Schema.String)).annotations({
+      description: 'Exclude messages from these usernames.',
+    }),
+  }),
+  output: Schema.Any,
+  services: [Credential.CredentialsService, Trace.TraceService],
+});