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

package/src/{functions/discord → blueprints/discord/functions}/fetch-messages.ts

@@ -21,7 +21,7 @@ import * as Schema from 'effect/Schema';
 import { Obj } from '@dxos/echo';
 import { CredentialsService, TracingService, defineFunction } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Message } from '@dxos/types';
 
 // TODO(dmaretskyi): Extract.
 const TimeRange = class extends Schema.String.pipe(Schema.pattern(/\d+(s|m|h|d)/)).annotations({
@@ -71,7 +71,7 @@ const DEFAULT_IGNORE_USERNAMES = ['GitHub', 'Needle'];
 type Thread = {
   discordChannelId: string;
   name?: string;
-  messages: DataType.Message[];
+  messages: Message.Message[];
 };
 
 export default defineFunction({
@@ -133,7 +133,7 @@ export default defineFunction({
         throw new Error('no channels found');
       }
       for (const channel of channels) {
-        console.log(channel.id, 'name' in channel ? channel.name : undefined);
+        log.info('channel', { id: channel.id, name: 'name' in channel ? channel.name : undefined });
       }
 
       yield* TracingService.emitStatus({ message: `Will fetch from channels: ${channels.length}` });
@@ -141,9 +141,9 @@ export default defineFunction({
       const threads = yield* Effect.forEach(
         channels,
         Effect.fnUntraced(function* (channel) {
-          const allMessages: DataType.Message[] = [];
+          const allMessages: Message.Message[] = [];
 
-          let lastMessage: Option.Option<DataType.Message> = Option.none();
+          let lastMessage: Option.Option<Message.Message> = Option.none();
           while (true) {
             const { id: lastId = undefined } = Function.pipe(
               lastMessage,
@@ -188,7 +188,7 @@ export default defineFunction({
             messages: allMessages
               .filter((message) => !message.sender.name || !ignoreUsernames.includes(message.sender.name))
               .filter((message) =>
-                message.blocks.some((block) => block._tag === 'text' && block.text.trim().length > 0),
+                message.blocks.some((block: any) => block._tag === 'text' && block.text.trim().length > 0),
               ),
           } satisfies Thread;
         }),
@@ -222,8 +222,9 @@ const parseSnowflake = (snowflake: string): Date => {
   return new Date(Number((BigInt(snowflake) >> 22n) + discordEpoch));
 };
 
-const makeMessage = (message: MessageResponse): DataType.Message =>
-  Obj.make(DataType.Message, {
+// TODO(burdon): Move to @dxos/types.
+const makeMessage = (message: MessageResponse): Message.Message =>
+  Obj.make(Message.Message, {
     [Obj.Meta]: {
       keys: [
         { id: message.id, source: 'discord.com' },
@@ -243,8 +244,8 @@ const serializeThread = (thread: Thread): string => {
     .map(
       (message) =>
         `  ${message.sender.name}: ${message.blocks
-          .filter((block) => block._tag === 'text')
-          .map((block) => block.text)
+          .filter((block: any) => block._tag === 'text')
+          .map((block: any) => block.text)
           .join(' ')}`,
     )
     .join('\n')}\n</thread>`;

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

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import Fetch from './fetch-messages';
+
+export const DiscordFunctions = {
+  Fetch,
+};

package/src/blueprints/discord/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import blueprint from './discord-blueprint';
-
-export default blueprint;
+export { default as DiscordBlueprint } from './blueprint';

package/src/{functions/github → blueprints/github/functions}/fetch-prs.ts

@@ -6,7 +6,7 @@ import * as HttpClient from '@effect/platform/HttpClient';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { defineFunction, withAuthorization } from '@dxos/functions';
+import { CredentialsService, defineFunction, withAuthorization } from '@dxos/functions';
 
 export default defineFunction({
   key: 'dxos.org/function/github/fetch-prs',
@@ -21,7 +21,8 @@ export default defineFunction({
     }),
   }),
   handler: Effect.fnUntraced(function* ({ data }) {
-    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization({ service: 'github.com' })));
+    const credential = yield* 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/${data.owner}/${data.repo}/pulls`);
     const json: any = yield* response.json;

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

@@ -0,0 +1,9 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { default as FetchPrs } from './fetch-prs';
+
+export const GithubFunctions = {
+  FetchPrs,
+};

package/src/blueprints/github/index.ts

@@ -0,0 +1,3 @@
+//
+// Copyright 2026 DXOS.org
+//

package/src/blueprints/index.ts

@@ -2,9 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-export { default as DesignBlueprint } from './design';
-export { default as DiscordBlueprint } from './discord';
-export { default as LinearBlueprint } from './linear';
-export { default as PlanningBlueprint } from './planning';
-export { default as ResearchBlueprint } from './research';
-export { default as WebSearchBlueprint, WebSearchToolkit } from './websearch';
+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';

package/src/blueprints/linear/blueprint.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ToolId } from '@dxos/ai';
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+import { LinearFunctions } from './functions';
+
+const BLUEPRINT_KEY = 'dxos.org/blueprint/linear';
+
+const functions = Object.values(LinearFunctions);
+
+/**
+ * Agent prompt instructions for managing hierarchical task lists.
+ */
+const instructions = trim`
+  You are able to sync Linear workspaces.
+  Sometimes sync does not complete in one go and you need to call the function again.
+
+  Known workspaces:
+
+  DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
+`;
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Linear',
+    description: 'Syncs Linear workspaces.',
+    instructions: {
+      source: Ref.make(Text.make(instructions)),
+    },
+    tools: functions.map((tool) => ToolId.make(tool.key)),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  functions,
+  make,
+};
+
+export default blueprint;

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

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { default as Sync } from './sync-issues';
+
+export const LinearFunctions = {
+  Sync,
+};

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

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { AssistantTestLayer } from '@dxos/assistant/testing';
+import { Obj, Query } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { FunctionInvocationService } from '@dxos/functions';
+import { Person, Pipeline, Task } from '@dxos/types';
+
+import { LINEAR_ID_KEY, default as fetchLinearIssues } from './sync-issues';
+
+const TestLayer = AssistantTestLayer({
+  functions: [fetchLinearIssues],
+  types: [Task.Task, Person.Person, Pipeline.Pipeline],
+  credentials: [{ service: 'linear.app', apiKey: process.env.LINEAR_API_KEY }],
+  tracing: 'pretty',
+});
+
+describe.skip('Linear', { timeout: 600_000 }, () => {
+  it.effect(
+    'sync',
+    Effect.fnUntraced(
+      function* (_) {
+        yield* Database.flush({ indexes: true });
+
+        yield* FunctionInvocationService.invokeFunction(fetchLinearIssues, {
+          team: '1127c63a-6f77-4725-9229-50f6cd47321c',
+        });
+
+        const persons = yield* Database.runQuery(Query.type(Person.Person));
+        console.log('people', {
+          count: persons.length,
+          people: persons.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
+        });
+        const projects = yield* Database.runQuery(Query.type(Pipeline.Pipeline));
+        console.log('projects', {
+          count: projects.length,
+          projects: projects.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
+        });
+        const tasks = yield* Database.runQuery(Query.type(Task.Task));
+        console.log('tasks', {
+          count: tasks.length,
+          tasks: tasks.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
+        });
+
+        yield* Database.flush({ indexes: true });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.taggedTest('sync'),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/{functions/linear → blueprints/linear/functions}/sync-issues.ts

@@ -10,12 +10,13 @@ import * as Function from 'effect/Function';
 import * as Schema from 'effect/Schema';
 
 import { Filter, Obj, Query, Ref, type Type } from '@dxos/echo';
-import { DatabaseService, defineFunction, withAuthorization } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { CredentialsService, defineFunction, withAuthorization } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Person, Pipeline, Task } from '@dxos/types';
 
-import { syncObjects } from '../../sync';
-import { graphqlRequestBody } from '../../util';
+import { syncObjects } from '../../../sync';
+import { graphqlRequestBody } from '../../../util';
 
 const queryIssues = `
 query Issues($teamId: String!, $after: DateTimeOrDuration!) {
@@ -35,7 +36,7 @@ query Issues($teamId: String!, $after: DateTimeOrDuration!) {
             updatedAt
             description
             assignee { id, name }
-            state { 
+            state {
                 name
             }
             project {
@@ -84,10 +85,11 @@ export default defineFunction({
     }),
   }),
   handler: Effect.fnUntraced(function* ({ data }) {
-    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization({ service: 'linear.app' })));
+    const credential = yield* CredentialsService.getCredential({ service: 'linear.app' });
+    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
 
     // Get the timestamp that was previosly synced.
-    const after = yield* getLatestUpdateTimestamp(data.team, DataType.Task);
+    const after = yield* getLatestUpdateTimestamp(data.team, Task.Task);
     log.info('will fetch', { after });
 
     // Fetch the issues that have changed since the last sync.
@@ -113,9 +115,9 @@ export default defineFunction({
 
 const getLatestUpdateTimestamp: (
   teamId: string,
-  dataType: Type.Obj.Any,
-) => Effect.Effect<string, never, DatabaseService> = Effect.fnUntraced(function* (teamId, dataType) {
-  const { objects: existingTasks } = yield* DatabaseService.runQuery(
+  dataType: Type.AnyObj,
+) => Effect.Effect<string, never, Database.Service> = Effect.fnUntraced(function* (teamId, dataType) {
+  const existingTasks = yield* Database.runQuery(
     Query.type(dataType).select(Filter.foreignKeys(dataType, [{ source: LINEAR_TEAM_ID_KEY, id: teamId }])),
   );
   return Function.pipe(
@@ -126,8 +128,8 @@ const getLatestUpdateTimestamp: (
   );
 });
 
-const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }): DataType.Person =>
-  Obj.make(DataType.Person, {
+const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }): Person.Person =>
+  Obj.make(Person.Person, {
     [Obj.Meta]: {
       keys: [
         {
@@ -143,8 +145,8 @@ const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }):
     nickname: person.name,
   });
 
-const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): DataType.Task =>
-  Obj.make(DataType.Task, {
+const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Task.Task =>
+  Obj.make(Task.Task, {
     [Obj.Meta]: {
       keys: [
         {
@@ -170,7 +172,7 @@ const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Dat
     project: !issue.project
       ? undefined
       : Ref.make(
-          DataType.makeProject({
+          Pipeline.make({
             [Obj.Meta]: {
               keys: [
                 {

package/src/blueprints/linear/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import blueprint from './linear-blueprint';
-
-export default blueprint;
+export { default as LinearBlueprint } from './blueprint';

package/src/blueprints/markdown/blueprint.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+import { MarkdownFunctions } from './functions';
+
+const BLUEPRINT_KEY = 'dxos.org/blueprint/markdown';
+
+const instructions = trim`
+  You read, write & create markdown documents.
+`;
+
+const functions = Object.values(MarkdownFunctions);
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Markdown',
+    description: 'Work with markdown documents.',
+    instructions: {
+      source: Ref.make(Text.make(instructions)),
+    },
+    tools: Blueprint.toolDefinitions({ functions }),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  functions,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/markdown/functions/create.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Database, Ref } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Markdown } from '@dxos/plugin-markdown/types';
+
+export default defineFunction({
+  key: 'dxos.org/function/markdown/create',
+  name: 'Create markdown document',
+  description: 'Creates a new markdown document.',
+  inputSchema: Schema.Struct({
+    name: Schema.String.annotations({
+      description: 'Name of the document.',
+    }),
+    content: Schema.String.annotations({
+      description: 'Content of the document.',
+    }),
+  }),
+  outputSchema: Schema.Void,
+  handler: Effect.fn(function* ({ data: { name, content } }) {
+    const doc = yield* Database.add(Markdown.make({ name, content }));
+    return { document: Ref.make(doc) };
+  }),
+});

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

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { default as Create } from './create';
+import { default as Read } from './read';
+import { default as Update } from './update';
+
+export const MarkdownFunctions = {
+  Create,
+  Read,
+  Update,
+};

package/src/blueprints/markdown/functions/read.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Database, Ref } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Markdown } from '@dxos/plugin-markdown/types';
+
+export default defineFunction({
+  key: 'dxos.org/function/markdown/read',
+  name: 'Read markdown document',
+  description:
+    'Read markdown document. Note that result is a snapshot in time, and might have changed since the document was last read.',
+  inputSchema: Schema.Struct({
+    document: Ref.Ref(Markdown.Document).annotations({
+      description: 'The document to read.',
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    content: Schema.String,
+  }),
+  handler: Effect.fn(function* ({ data: { document } }) {
+    const { content } = yield* document.pipe(
+      Database.load,
+      Effect.flatMap((doc) => doc.content.pipe(Database.load)),
+    );
+    return { content };
+  }),
+});

package/src/{functions/document → blueprints/markdown/functions}/update.ts

@@ -5,8 +5,8 @@
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { ArtifactId } from '@dxos/assistant';
-import { DatabaseService, defineFunction } from '@dxos/functions';
+import { Database, Obj, Ref } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
 import { Markdown } from '@dxos/plugin-markdown/types';
 
 export default defineFunction({
@@ -14,7 +14,7 @@ export default defineFunction({
   name: 'Update markdown',
   description: 'Updates the entire contents of the markdown document.',
   inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
+    doc: Ref.Ref(Markdown.Document).annotations({
       description: 'The ID of the document to write.',
     }),
     content: Schema.String.annotations({
@@ -22,9 +22,11 @@ export default defineFunction({
     }),
   }),
   outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { id, content } }) {
-    const doc = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Markdown.Document);
-    const text = yield* DatabaseService.load(doc.content);
-    text.content = content;
+  handler: Effect.fn(function* ({ data: { doc, content } }) {
+    const document = yield* Database.load(doc);
+    const text = yield* Database.load(document.content);
+    Obj.change(text, (t) => {
+      t.content = content;
+    });
   }),
 });

package/src/blueprints/markdown/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as MarkdownBlueprint } from './blueprint';
+export { MarkdownFunctions } from './functions';

package/src/blueprints/planning/blueprint.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+
+import { PlanningFunctions } from './functions';
+
+const BLUEPRINT_KEY = 'dxos.org/blueprint/planning';
+
+const functions = Object.values(PlanningFunctions);
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Planning',
+    description: 'Plans and tracks complex tasks with artifact management.',
+    tools: Blueprint.toolDefinitions({ functions: [PlanningFunctions.UpdateTasks] }),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  functions,
+  make,
+};
+
+export default blueprint;

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

@@ -0,0 +1,9 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import UpdateTasks from './update-tasks';
+
+export const PlanningFunctions = {
+  UpdateTasks,
+};