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

package/src/blueprints/discord/functions/fetch-messages.test.ts

@@ -8,30 +8,21 @@ import * as Config from 'effect/Config';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { AiService } from '@dxos/ai';
-import { GenericToolkit } from '@dxos/ai';
-import { AiServiceTestingPreset } from '@dxos/ai/testing';
-import { ToolExecutionServices } from '@dxos/assistant';
+import { Operation, OperationHandlerSet } from '@dxos/compute';
 import { TestHelpers } from '@dxos/effect/testing';
-import { CredentialsService, FunctionInvocationService, TracingService } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTestMocked, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
+import { credentialsLayerConfig } from '@dxos/functions';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
 import { default as fetchMessages } from './fetch-messages';
 
-const TestLayer = Layer.mergeAll(AiService.model('@anthropic/claude-opus-4-0'), ToolExecutionServices).pipe(
-  Layer.provideMerge(
-    Layer.mergeAll(
-      GenericToolkit.providerEmpty,
-      AiServiceTestingPreset('direct'),
-      TestDatabaseLayer({}),
-      CredentialsService.layerConfig([{ service: 'discord.com', apiKey: Config.redacted('DISCORD_TOKEN') }]),
-      FetchHttpClient.layer,
-      FunctionInvocationServiceLayerTestMocked({ functions: [fetchMessages] }).pipe(
-        Layer.provideMerge(TracingService.layerNoop),
-      ),
-    ),
-  ),
-);
+const TestLayer = AssistantTestLayer({
+  operationHandlers: OperationHandlerSet.make(fetchMessages),
+});
+
+const TestLayerWithCredentials = Layer.mergeAll(
+  credentialsLayerConfig([{ service: 'discord.com', apiKey: Config.redacted('DISCORD_TOKEN') }]),
+  FetchHttpClient.layer,
+).pipe(Layer.provideMerge(TestLayer));
 
 const DXOS_SERVER_ID = '837138313172353095';
 
@@ -40,16 +31,15 @@ describe('Feed', { timeout: 600_000 }, () => {
     'fetch discord messages',
     Effect.fnUntraced(
       function* (_) {
-        const messages = yield* FunctionInvocationService.invokeFunction(fetchMessages, {
+        const messages = yield* Operation.invoke(fetchMessages, {
           serverId: DXOS_SERVER_ID,
-          // channelId: '1404487604761526423',
           last: '7d',
-        });
+        }).pipe(Effect.orDie);
         console.log(messages);
       },
-      Effect.provide(TestLayer),
+      Effect.provide(TestLayerWithCredentials),
       TestHelpers.provideTestContext,
-      TestHelpers.taggedTest('sync'),
     ),
+    { tags: ['sync'] },
   );
 });

package/src/blueprints/discord/functions/fetch-messages.ts

@@ -16,44 +16,18 @@ import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 import * as Layer from 'effect/Layer';
 import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
 
+import { Credential, Trace, Operation } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
-import { CredentialsService, TracingService, defineFunction } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { Message } from '@dxos/types';
 
-// TODO(dmaretskyi): Extract.
-const TimeRange = class extends 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'],
-}) {
-  static toSeconds(timeRange: Schema.Schema.Type<typeof TimeRange>) {
-    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}`);
-    }
-  }
-};
-type TimeRange = Schema.Schema.Type<typeof TimeRange>;
+import { FetchMessages, TimeRange } from './definitions';
 
 const DiscordConfigFromCredential = Layer.unwrapEffect(
   Effect.gen(function* () {
     return DiscordConfig.layer({
-      token: yield* CredentialsService.getApiKey({ service: 'discord.com' }),
+      token: yield* Credential.CredentialsService.getApiKey({ service: 'discord.com' }),
       rest: {
         baseUrl: 'https://api-proxy.dxos.workers.dev/discord.com/api/v10',
       },
@@ -74,38 +48,10 @@ type Thread = {
   messages: Message.Message[];
 };
 
-export default defineFunction({
-  key: 'dxos.org/function/fetch-discord-messages',
-  name: 'Sync Discord messages',
-  inputSchema: 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.',
-    }),
-  }),
-  handler: Effect.fnUntraced(
-    function* ({
-      data: {
+export default FetchMessages.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({
         serverId,
         channelId,
         after,
@@ -113,101 +59,101 @@ export default defineFunction({
         pageSize = 100,
         limit = DEFAULT_LIMIT,
         ignoreUsernames = DEFAULT_IGNORE_USERNAMES,
-      },
-    }) {
-      if (!after && !last) {
-        throw new Error('cannot specify both `after` and `last`');
-      }
-      const afterTs = last ? Date.now() / 1000 - TimeRange.toSeconds(last) : (after ?? DEFAULT_AFTER);
-
-      const rest = yield* DiscordREST;
-
-      let channels: DiscordChannel[] = [];
-      channels.push(...(yield* rest.listGuildChannels(serverId)));
-      const { threads: guildThreads } = yield* rest.getActiveGuildThreads(serverId);
-      channels.push(...guildThreads);
-      if (channelId) {
-        channels = channels.filter((channel) => channel.id === channelId);
-      }
-      if (channels.length === 0) {
-        throw new Error('no channels found');
-      }
-      for (const channel of channels) {
-        log.info('channel', { id: channel.id, name: 'name' in channel ? channel.name : undefined });
-      }
-
-      yield* TracingService.emitStatus({ message: `Will fetch from channels: ${channels.length}` });
-
-      const threads = yield* Effect.forEach(
-        channels,
-        Effect.fnUntraced(function* (channel) {
-          const allMessages: Message.Message[] = [];
-
-          let lastMessage: Option.Option<Message.Message> = Option.none();
-          while (true) {
-            const { id: lastId = undefined } = Function.pipe(
-              lastMessage,
-              Option.map(Obj.getKeys('discord.com')),
-              Option.flatMap(Option.fromIterable),
-              Option.getOrElse(() => ({ id: undefined })),
-            );
-
-            const options = {
-              after: !lastId ? `${generateSnowflake(afterTs)}` : lastId,
-              limit: pageSize,
-            };
-            log.info('fetching messages', {
-              lastId,
-              afterTs,
-              afterSnowflake: options.after,
-              after: parseSnowflake(options.after),
-              limit: options.limit,
-            });
-            const messages = yield* rest.listMessages(channel.id, options).pipe(
-              Effect.map(Array.map(makeMessage)),
-              Effect.map(Array.reverse),
-              Effect.catchTag('ErrorResponse', (err) =>
-                err.cause.code === 50001 ? Effect.succeed([]) : Effect.fail(err),
-              ),
-            );
-            if (messages.length > 0) {
-              lastMessage = Option.fromNullable(messages.at(-1));
-              allMessages.push(...messages);
-            } else {
-              break;
-            }
-            yield* TracingService.emitStatus({ message: `Fetched messages: ${allMessages.length}` });
-            if (allMessages.length >= limit) {
-              break;
+      }) {
+        if (!after && !last) {
+          throw new Error('cannot specify both `after` and `last`');
+        }
+        const afterTs = last ? Date.now() / 1000 - TimeRange.toSeconds(last) : (after ?? DEFAULT_AFTER);
+
+        const rest = yield* DiscordREST;
+
+        let channels: DiscordChannel[] = [];
+        channels.push(...(yield* rest.listGuildChannels(serverId)));
+        const { threads: guildThreads } = yield* rest.getActiveGuildThreads(serverId);
+        channels.push(...guildThreads);
+        if (channelId) {
+          channels = channels.filter((channel) => channel.id === channelId);
+        }
+        if (channels.length === 0) {
+          throw new Error('no channels found');
+        }
+        for (const channel of channels) {
+          log.info('channel', { id: channel.id, name: 'name' in channel ? channel.name : undefined });
+        }
+
+        yield* Trace.emitStatus(`Will fetch from channels: ${channels.length}`);
+
+        const threads = yield* Effect.forEach(
+          channels,
+          Effect.fnUntraced(function* (channel) {
+            const allMessages: Message.Message[] = [];
+
+            let lastMessage: Option.Option<Message.Message> = Option.none();
+            while (true) {
+              const { id: lastId = undefined } = Function.pipe(
+                lastMessage,
+                Option.map(Obj.getKeys('discord.com')),
+                Option.flatMap(Option.fromIterable),
+                Option.getOrElse(() => ({ id: undefined })),
+              );
+
+              const options = {
+                after: !lastId ? `${generateSnowflake(afterTs)}` : lastId,
+                limit: pageSize,
+              };
+              log.info('fetching messages', {
+                lastId,
+                afterTs,
+                afterSnowflake: options.after,
+                after: parseSnowflake(options.after),
+                limit: options.limit,
+              });
+              const messages = yield* rest.listMessages(channel.id, options).pipe(
+                Effect.map(Array.map(makeMessage)),
+                Effect.map(Array.reverse),
+                Effect.catchTag('ErrorResponse', (err) =>
+                  err.cause.code === 50001 ? Effect.succeed([]) : Effect.fail(err),
+                ),
+              );
+              if (messages.length > 0) {
+                lastMessage = Option.fromNullable(messages.at(-1));
+                allMessages.push(...messages);
+              } else {
+                break;
+              }
+              yield* Trace.emitStatus(`Fetched messages: ${allMessages.length}`);
+              if (allMessages.length >= limit) {
+                break;
+              }
             }
-          }
-
-          return {
-            discordChannelId: channel.id,
-            name: 'name' in channel ? (channel.name ?? undefined) : undefined,
-            messages: allMessages
-              .filter((message) => !message.sender.name || !ignoreUsernames.includes(message.sender.name))
-              .filter((message) =>
-                message.blocks.some((block: any) => block._tag === 'text' && block.text.trim().length > 0),
-              ),
-          } satisfies Thread;
-        }),
-        { concurrency: 10 },
-      );
-
-      return threads
-        .filter((thread) => thread.messages.length > 0)
-        .map(serializeThread)
-        .join('\n');
-    },
-    Effect.provide(
-      DiscordRESTMemoryLive.pipe(Layer.provideMerge(DiscordConfigFromCredential)).pipe(
-        Layer.provide(FetchHttpClient.layer),
+
+            return {
+              discordChannelId: channel.id,
+              name: 'name' in channel ? (channel.name ?? undefined) : undefined,
+              messages: allMessages
+                .filter((message) => !message.sender.name || !ignoreUsernames.includes(message.sender.name))
+                .filter((message) =>
+                  message.blocks.some((block: any) => block._tag === 'text' && block.text.trim().length > 0),
+                ),
+            } satisfies Thread;
+          }),
+          { concurrency: 10 },
+        );
+
+        return threads
+          .filter((thread) => thread.messages.length > 0)
+          .map(serializeThread)
+          .join('\n');
+      },
+      Effect.provide(
+        DiscordRESTMemoryLive.pipe(Layer.provideMerge(DiscordConfigFromCredential)).pipe(
+          Layer.provide(FetchHttpClient.layer),
+        ),
       ),
+      Effect.orDie,
     ),
-    Effect.orDie,
   ),
-});
+);
 
 /**
  * @param unixTimestamp in seconds

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

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import Fetch from './fetch-messages';
+import { OperationHandlerSet } from '@dxos/compute';
 
-export const DiscordFunctions = {
-  Fetch,
-};
+export * from './definitions';
+
+export const DiscordHandlers = OperationHandlerSet.lazy(() => import('./fetch-messages'));

package/src/blueprints/discord/index.ts

@@ -3,3 +3,4 @@
 //
 
 export { default as DiscordBlueprint } from './blueprint';
+export { FetchMessages, DiscordHandlers } from './functions';

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

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as Schema from 'effect/Schema';
+
+import { Credential, Operation } from '@dxos/compute';
+
+export const FetchPrs = Operation.make({
+  meta: {
+    key: 'org.dxos.function.github.fetch-prs',
+    name: 'Fetch PRs',
+    description: 'Fetches PRs from GitHub.',
+  },
+  input: Schema.Struct({
+    owner: Schema.String.annotations({
+      description: 'GitHub owner.',
+    }),
+    repo: Schema.String.annotations({
+      description: 'GitHub repository.',
+    }),
+  }),
+  output: Schema.Any,
+  services: [Credential.CredentialsService, HttpClient.HttpClient],
+});

package/src/blueprints/github/functions/fetch-prs.ts

@@ -4,28 +4,21 @@
 
 import * as HttpClient from '@effect/platform/HttpClient';
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { CredentialsService, defineFunction, withAuthorization } from '@dxos/functions';
+import { Credential, Operation } from '@dxos/compute';
+import { withAuthorization } from '@dxos/functions';
 
-export default defineFunction({
-  key: 'dxos.org/function/github/fetch-prs',
-  name: 'Fetch PRs',
-  description: 'Fetches PRs from GitHub.',
-  inputSchema: Schema.Struct({
-    owner: Schema.String.annotations({
-      description: 'GitHub owner.',
-    }),
-    repo: Schema.String.annotations({
-      description: 'GitHub repository.',
-    }),
-  }),
-  handler: Effect.fnUntraced(function* ({ data }) {
-    const credential = yield* CredentialsService.getCredential({ service: 'github.com' });
-    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
+import { FetchPrs } from './definitions';
 
-    const response = yield* client.get(`https://api.github.com/repos/${data.owner}/${data.repo}/pulls`);
-    const json: any = yield* response.json;
-    return json;
-  }),
-});
+export default FetchPrs.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ owner, repo }) {
+      const credential = yield* Credential.CredentialsService.getCredential({ service: 'github.com' });
+      const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
+
+      const response = yield* client.get(`https://api.github.com/repos/${owner}/${repo}/pulls`);
+      const json: any = yield* response.json;
+      return json;
+    }),
+  ),
+);

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

@@ -2,8 +2,8 @@
 // Copyright 2026 DXOS.org
 //
 
-import { default as FetchPrs } from './fetch-prs';
+import { OperationHandlerSet } from '@dxos/compute';
 
-export const GithubFunctions = {
-  FetchPrs,
-};
+export * from './definitions';
+
+export const GithubHandlers = OperationHandlerSet.lazy(() => import('./fetch-prs'));

package/src/blueprints/github/index.ts

@@ -1,3 +1,5 @@
 //
 // Copyright 2026 DXOS.org
 //
+
+export { FetchPrs, GithubHandlers } from './functions';

package/src/blueprints/index.ts

@@ -2,13 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './design';
 export * from './discord';
 export * from './project';
 export * from './linear';
-export * from './markdown';
 export * from './planning';
-export * from './research';
 export * from './websearch';
 export * from './browser';
 export * from './database';
+export * from './memory';
+export * from './automation';
+export * from './blueprint-manager';
+export * from './project-wizard';

package/src/blueprints/linear/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 { LinearFunctions } from './functions';
+import { SyncIssues } from './functions';
 
-const BLUEPRINT_KEY = 'dxos.org/blueprint/linear';
-
-const functions = Object.values(LinearFunctions);
+const BLUEPRINT_KEY = 'org.dxos.blueprint.linear';
 
 /**
  * Agent prompt instructions for managing hierarchical task lists.
@@ -33,14 +29,13 @@ const make = () =>
     name: 'Linear',
     description: 'Syncs Linear workspaces.',
     instructions: {
-      source: Ref.make(Text.make(instructions)),
+      source: Ref.make(Text.make({ content: instructions })),
     },
-    tools: functions.map((tool) => ToolId.make(tool.key)),
+    tools: Blueprint.toolDefinitions({ operations: [SyncIssues] }),
   });
 
-const blueprint: AppCapabilities.BlueprintDefinition = {
+const blueprint: Blueprint.Definition = {
   key: BLUEPRINT_KEY,
-  functions,
   make,
 };
 

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

@@ -0,0 +1,23 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Credential, Operation } from '@dxos/compute';
+import { Database } from '@dxos/echo';
+
+export const SyncIssues = Operation.make({
+  meta: {
+    key: 'org.dxos.function.linear.sync-issues',
+    name: 'Linear',
+    description: 'Sync issues from Linear.',
+  },
+  input: Schema.Struct({
+    team: Schema.String.annotations({
+      description: 'Linear team id.',
+    }),
+  }),
+  output: Schema.Any,
+  services: [Credential.CredentialsService, Database.Service],
+});

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

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { default as Sync } from './sync-issues';
+import { OperationHandlerSet } from '@dxos/compute';
 
-export const LinearFunctions = {
-  Sync,
-};
+export * from './definitions';
+
+export const LinearHandlers = OperationHandlerSet.lazy(() => import('./sync-issues'));

package/src/blueprints/linear/functions/linear.test.ts

@@ -5,17 +5,17 @@
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
-import { AssistantTestLayer } from '@dxos/assistant/testing';
+import { Operation, OperationHandlerSet } from '@dxos/compute';
 import { Obj, Query } from '@dxos/echo';
 import { Database } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { FunctionInvocationService } from '@dxos/functions';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { Person, Pipeline, Task } from '@dxos/types';
 
 import { LINEAR_ID_KEY, default as fetchLinearIssues } from './sync-issues';
 
 const TestLayer = AssistantTestLayer({
-  functions: [fetchLinearIssues],
+  operationHandlers: OperationHandlerSet.make(fetchLinearIssues),
   types: [Task.Task, Person.Person, Pipeline.Pipeline],
   credentials: [{ service: 'linear.app', apiKey: process.env.LINEAR_API_KEY }],
   tracing: 'pretty',
@@ -26,9 +26,9 @@ describe.skip('Linear', { timeout: 600_000 }, () => {
     'sync',
     Effect.fnUntraced(
       function* (_) {
-        yield* Database.flush({ indexes: true });
+        yield* Database.flush();
 
-        yield* FunctionInvocationService.invokeFunction(fetchLinearIssues, {
+        yield* Operation.invoke(fetchLinearIssues, {
           team: '1127c63a-6f77-4725-9229-50f6cd47321c',
         });
 
@@ -48,11 +48,11 @@ describe.skip('Linear', { timeout: 600_000 }, () => {
           tasks: tasks.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
         });
 
-        yield* Database.flush({ indexes: true });
+        yield* Database.flush();
       },
       Effect.provide(TestLayer),
-      TestHelpers.taggedTest('sync'),
       TestHelpers.provideTestContext,
     ),
+    { tags: ['sync'] },
   );
 });