@dxos/assistant 0.8.2-main.f11618f → 0.8.2-main.fbd8ed0

package/src/testing/artifacts.test.ts

@@ -3,7 +3,7 @@
 //
 
 /*
-import { Schema as S } from '@effect/schema';
+import { Schema } from '@effect/schema';
 import { describe, test } from 'vitest';
 
 import { ObjectId, toJsonSchema } from '@dxos/echo-schema';
@@ -15,26 +15,26 @@ import { AIServiceEdgeClient, Tool } from '../ai-service';
 import { defineTool, ToolResult } from '../conversation';
 
 // TODO(dmaretskyi): Effect schema.
-const ArtifactDef = S.Struct({
-  typename: S.String,
-  description: S.String,
-  schema: S.Any,
-  actions: S.Array(Tool),
-}).pipe(S.mutable);
+const ArtifactDef = Schema.Struct({
+  typename: Schema.String,
+  description: Schema.String,
+  schema: Schema.Any,
+  actions: Schema.Array(Tool),
+}).pipe(Schema.mutable);
 
-type ArtifactDef = S.Schema.Type<typeof ArtifactDef>;
+type ArtifactDef = Schema.Schema.Type<typeof ArtifactDef>;
 
-const ListItem = S.Struct({
-  name: S.String,
+const ListItem = Schema.Struct({
+  name: Schema.String,
 });
 
-const ListSchema = S.Struct({
+const ListSchema = Schema.Struct({
   id: ObjectId,
-  title: S.String,
-  items: S.Array(ListItem).pipe(S.mutable),
-}).pipe(S.mutable);
+  title: Schema.String,
+  items: Schema.Array(ListItem).pipe(Schema.mutable),
+}).pipe(Schema.mutable);
 
-type ListSchema = S.Schema.Type<typeof ListSchema>;
+type ListSchema = Schema.Schema.Type<typeof ListSchema>;
 
 const list: ArtifactDef = {
   typename: 'example.com/type/List',
@@ -44,7 +44,7 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'query',
       description: 'Query all lists',
-      schema: S.Struct({}),
+      schema: Schema.Struct({}),
       execute: async ({}, context) => {
         return ToolResult.Success(LISTS[id]);
       },
@@ -52,7 +52,7 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'inspect',
       description: 'Get contents of the list',
-      schema: S.Struct({
+      schema: Schema.Struct({
         id: ObjectId.annotations({ description: 'The list to inspect' }),
       }),
       execute: async ({ id }, context) => {
@@ -62,9 +62,9 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'create',
       description: 'Add one or more items to an existing list',
-      schema: S.Struct({
+      schema: Schema.Struct({
         id: ObjectId.annotations({ description: 'The list to add items to' }),
-        items: S.Array(ListItem).annotations({ description: 'The items to add to the list' }),
+        items: Schema.Array(ListItem).annotations({ description: 'The items to add to the list' }),
       }),
       execute: async ({ id, items }, context) => {
         LISTS[id].items.push(...items);
@@ -81,7 +81,7 @@ const artifacts = [list];
 const getArtifactDefinitions = defineTool('system', {
   name: 'getArtifactDefinitions',
   description: 'Queries the definitions and metadata of artifacts defined in the system',
-  schema: S.Any,
+  schema: Schema.Any,
   execute: async (_, context) => {
     return ToolResult.Success(
       artifacts.map((artifact) => ({
@@ -116,8 +116,8 @@ describe('Artifacts', () => {
       name: 'custodian',
       description: 'Custodian can tell you the password if you say the magic word',
       parameters: toJsonSchema(
-        S.Struct({
-          magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
+        Schema.Struct({
+          magicWord: Schema.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
         }),
       ),
     };

package/src/testing/index.ts

@@ -5,6 +5,7 @@
 export * from './defs';
 export * from './logger';
 export * from './ollama';
+export * from './printer';
 export * from './query-promts';
 export * from './test-data';
 export * from './test-schema';

package/src/testing/logger.ts

@@ -4,7 +4,7 @@
 
 import type { ImageSource, MessageContentBlock } from '@dxos/artifact';
 
-import type { ConversationEvent } from '../conversation';
+import type { ConversationEvent } from '../experimental';
 
 export const createLogger = ({
   stream,

package/src/testing/printer.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { inspect } from 'node:util';
+
+import type { Message, MessageContentBlock } from '@dxos/artifact';
+
+export class ConsolePrinter {
+  printMessage = (message: Message) => {
+    // eslint-disable-next-line no-console
+    console.log(`${message.role.toUpperCase()}\n`);
+    for (const content of message.content) {
+      this.printContentBlock(content);
+    }
+  };
+
+  printContentBlock = (content: MessageContentBlock) => {
+    switch (content.type) {
+      case 'text':
+        // eslint-disable-next-line no-console
+        console.log(content.text);
+        break;
+      case 'tool_use':
+        // eslint-disable-next-line no-console
+        console.log(`⚙️ [Tool Use] ${content.name} ${inspect(content.input, { depth: null, colors: true })}`);
+        break;
+      case 'tool_result': {
+        let data: any;
+        try {
+          data = JSON.parse(content.content);
+        } catch {
+          data = content.content;
+        }
+        // eslint-disable-next-line no-console
+        console.log(`⚙️ [Tool Result] ${content.toolUseId} ${inspect(data, { depth: null, colors: true })}`);
+        break;
+      }
+    }
+  };
+}

package/src/testing/query-promts.ts

@@ -2,23 +2,23 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
 import { defineTool, ToolResult } from '@dxos/artifact';
 import { toJsonSchema } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
-import { executeQuery, formatJsonSchemaForLLM, type DataSource } from '../cypher';
+import { executeQuery, formatJsonSchemaForLLM, type DataSource } from '../experimental';
 import { trim } from '../util';
 
-export const createCypherTool = (dataSource: DataSource, schemaTypes: S.Schema.Any[] = []) =>
+export const createCypherTool = (dataSource: DataSource, schemaTypes: Schema.Schema.Any[] = []) =>
   defineTool('dxos.org/echo', {
     name: 'query',
     description:
       'Query the ECHO graph database in cypher query language. Returns data from the database.' +
       (schemaTypes.length > 0 ? `\n\n${createSystemPrompt(schemaTypes)}` : ''),
-    schema: S.Struct({
-      query: S.String.annotations({
+    schema: Schema.Struct({
+      query: Schema.String.annotations({
         description: `
           A valid cypher query string to execute.
           Query must have one MATCH clause.
@@ -55,7 +55,7 @@ export const createCypherTool = (dataSource: DataSource, schemaTypes: S.Schema.A
     },
   });
 
-export const createSystemPrompt = (schemaTypes: S.Schema.Any[]) => trim`
+export const createSystemPrompt = (schemaTypes: Schema.Schema.Any[]) => trim`
   You have access to ECHO graph database. You can query the database to get data to satisfy user prompts.
 
   Database schema is defined in pseud-cypher syntax. The schema is:

package/src/testing/query.test.ts

@@ -16,8 +16,7 @@ import { createCypherTool, createSystemPrompt } from './query-promts';
 import { createTestData, seedTestData } from './test-data';
 import { Contact, Organization, Project, Task } from './test-schema';
 import { AIServiceEdgeClient, DEFAULT_EDGE_MODEL } from '../ai-service';
-import { runLLM } from '../conversation';
-import { EchoDataSource } from '../cypher';
+import { runLLM, EchoDataSource } from '../experimental';
 
 const client = new AIServiceEdgeClient({
   endpoint: AI_SERVICE_ENDPOINT.LOCAL,

package/src/testing/test-data.ts

@@ -2,13 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Schema as S } from 'effect';
+import { type Schema } from 'effect';
 
 import { raise } from '@dxos/debug';
 import type { EchoDatabase } from '@dxos/echo-db';
-import { JSON_SCHEMA_ECHO_REF_ID, ObjectId, toJsonSchema, type JsonSchemaType, type Ref } from '@dxos/echo-schema';
+import {
+  JSON_SCHEMA_ECHO_REF_ID,
+  ObjectId,
+  toJsonSchema,
+  type JsonSchemaType,
+  type Ref,
+  Ref as RefImpl,
+} from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { live, makeRef } from '@dxos/live-object';
+import { live } from '@dxos/live-object';
 
 import {
   type DataSource,
@@ -16,7 +23,7 @@ import {
   type Relationship,
   formatInferredRelationshipLabel,
   formatNodeLabel,
-} from '../cypher';
+} from '../experimental';
 import { Contact, Organization, Project, Task } from '../testing';
 
 export const seedTestData = (db: EchoDatabase) => {
@@ -60,79 +67,79 @@ export const seedTestData = (db: EchoDatabase) => {
   const _taskComposer1 = db.add(
     live(Task, {
       name: 'Optimize startup performance',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactJosiah),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactJosiah),
     }),
   );
   const _taskComposer2 = db.add(
     live(Task, {
       name: 'Create form builder',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactRich),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactRich),
     }),
   );
   const _taskComposer3 = db.add(
     live(Task, {
       name: 'Add support for custom themes',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactJosiah),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactJosiah),
     }),
   );
   const _taskComposer5 = db.add(
     live(Task, {
       name: 'Implement community plugin',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactFred),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactFred),
     }),
   );
   const _taskComposer4 = db.add(
     live(Task, {
       name: 'Implement dark mode',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactRich),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactRich),
     }),
   );
   const _taskEcho1 = db.add(
     live(Task, {
       name: 'Implement cypher query engine',
-      project: makeRef(projectEcho),
-      assignee: makeRef(contactDima),
+      project: RefImpl.make(projectEcho),
+      assignee: RefImpl.make(contactDima),
     }),
   );
   const _taskEcho2 = db.add(
     live(Task, {
       name: 'Add schema editor',
-      project: makeRef(projectEcho),
-      assignee: makeRef(contactRich),
+      project: RefImpl.make(projectEcho),
+      assignee: RefImpl.make(contactRich),
     }),
   );
   const _taskDoodles1 = db.add(
     live(Task, {
       name: 'Add support for custom themes',
-      project: makeRef(projectDoodles),
-      assignee: makeRef(contactFred),
+      project: RefImpl.make(projectDoodles),
+      assignee: RefImpl.make(contactFred),
     }),
   );
   const _taskDoodles2 = db.add(
     live(Task, {
       name: 'Implement dark mode',
-      project: makeRef(projectDoodles),
-      assignee: makeRef(contactJosiah),
+      project: RefImpl.make(projectDoodles),
+      assignee: RefImpl.make(contactJosiah),
     }),
   );
 
   const _orgDxos = db.add(
     live(Organization, {
       name: 'DXOS',
-      employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
-      projects: [makeRef(projectEcho)],
+      employees: [RefImpl.make(contactRich), RefImpl.make(contactJosiah), RefImpl.make(contactDima)],
+      projects: [RefImpl.make(projectEcho)],
     }),
   );
   const _orgBraneframe = db.add(
     live(Organization, {
       name: 'Braneframe',
-      employees: [makeRef(contactJosiah), makeRef(contactRich)],
-      projects: [makeRef(projectComposer)],
+      employees: [RefImpl.make(contactJosiah), RefImpl.make(contactRich)],
+      projects: [RefImpl.make(projectComposer)],
     }),
   );
 };
@@ -174,69 +181,69 @@ export const createTestData = (): MockDataSource => {
   const _taskComposer1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Optimize startup performance',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactJosiah),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactJosiah),
   });
   const _taskComposer2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Create form builder',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactRich),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactRich),
   });
   const _taskComposer3 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add support for custom themes',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactJosiah),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactJosiah),
   });
   const _taskComposer5 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement community plugin',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactFred),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactFred),
   });
   const _taskComposer4 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement dark mode',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactRich),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactRich),
   });
   const _taskEcho1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement cypher query engine',
-    project: makeRef(projectEcho),
-    assignee: makeRef(contactDima),
+    project: RefImpl.make(projectEcho),
+    assignee: RefImpl.make(contactDima),
   });
   const _taskEcho2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add schema editor',
-    project: makeRef(projectEcho),
-    assignee: makeRef(contactRich),
+    project: RefImpl.make(projectEcho),
+    assignee: RefImpl.make(contactRich),
   });
   const _taskDoodles1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add support for custom themes',
-    project: makeRef(projectDoodles),
-    assignee: makeRef(contactFred),
+    project: RefImpl.make(projectDoodles),
+    assignee: RefImpl.make(contactFred),
   });
   const _taskDoodles2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement dark mode',
-    project: makeRef(projectDoodles),
-    assignee: makeRef(contactJosiah),
+    project: RefImpl.make(projectDoodles),
+    assignee: RefImpl.make(contactJosiah),
   });
 
   const _orgDxos = dataSource.add(Organization, {
     id: ObjectId.random(),
     name: 'DXOS',
-    employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
-    projects: [makeRef(projectEcho)],
+    employees: [RefImpl.make(contactRich), RefImpl.make(contactJosiah), RefImpl.make(contactDima)],
+    projects: [RefImpl.make(projectEcho)],
   });
   const _orgBraneframe = dataSource.add(Organization, {
     id: ObjectId.random(),
     name: 'Braneframe',
-    employees: [makeRef(contactJosiah), makeRef(contactRich)],
-    projects: [makeRef(projectComposer)],
+    employees: [RefImpl.make(contactJosiah), RefImpl.make(contactRich)],
+    projects: [RefImpl.make(projectComposer)],
   });
   dataSource.computeGraph();
 
@@ -247,7 +254,7 @@ export class MockDataSource implements DataSource {
   objects: Record<
     string,
     {
-      schema: S.Schema.All;
+      schema: Schema.Schema.All;
       typeDxn: string;
       id: string;
       data: unknown;
@@ -258,7 +265,7 @@ export class MockDataSource implements DataSource {
     string,
     {
       json: JsonSchemaType;
-      instance: S.Schema.All;
+      instance: Schema.Schema.All;
     }
   > = {};
 
@@ -273,7 +280,7 @@ export class MockDataSource implements DataSource {
     return this.relationships.filter((relationship) => !label || relationship.label === label);
   }
 
-  add<S extends S.Schema.All>(schema: S, data: S.Schema.Type<S>) {
+  add<S extends Schema.Schema.All>(schema: S, data: Schema.Schema.Type<S>) {
     invariant(typeof data.id === 'string', 'Data must have an id');
     const jsonSchema = toJsonSchema(schema);
     if (!this.schema[jsonSchema.$id!]) {

package/src/testing/test-schema.ts

@@ -2,22 +2,19 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
-import { EntityKind, TypeAnnotationId, Ref } from '@dxos/echo-schema';
+import { EntityKind, TypeAnnotationId, Ref, ObjectId } from '@dxos/echo-schema';
 
-// TODO(burdon): Reconcile with sdk/schema/testing.
-// TODO(burdon): Convert interface to type.
+// TODO(burdon): Remove (use @dxos/schema DataType).
 
-// TODO(dmaretskyi): Extract.
-export const ObjectId = S.String.annotations({ description: 'The unique object identifier.' });
-
-export const Contact = S.Struct({
+/** @deprecated */
+export const Contact = Schema.Struct({
   id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the person.' }),
-  email: S.optional(S.String).annotations({ description: 'Email address.' }),
+  name: Schema.String.annotations({ description: 'The name of the person.' }),
+  email: Schema.optional(Schema.String).annotations({ description: 'Email address.' }),
 })
-  .pipe(S.mutable)
+  .pipe(Schema.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -26,14 +23,15 @@ export const Contact = S.Struct({
     },
     description: 'Contact information.',
   });
-export interface Contact extends S.Schema.Type<typeof Contact> {}
+export interface Contact extends Schema.Schema.Type<typeof Contact> {}
 
-export const Project = S.Struct({
+/** @deprecated */
+export const Project = Schema.Struct({
   id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the project.' }),
-  description: S.optional(S.String).annotations({ description: 'The description of the project.' }),
+  name: Schema.String.annotations({ description: 'The name of the project.' }),
+  description: Schema.optional(Schema.String).annotations({ description: 'The description of the project.' }),
 })
-  .pipe(S.mutable)
+  .pipe(Schema.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -42,16 +40,16 @@ export const Project = S.Struct({
     },
     description: 'Contact information.',
   });
-export interface Project extends S.Schema.Type<typeof Project> {}
+export interface Project extends Schema.Schema.Type<typeof Project> {}
 
-export const Task = S.Struct({
+export const Task = Schema.Struct({
   id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the task.' }),
-  description: S.optional(S.String).annotations({ description: 'The description of the task.' }),
+  name: Schema.String.annotations({ description: 'The name of the task.' }),
+  description: Schema.optional(Schema.String).annotations({ description: 'The description of the task.' }),
   project: Ref(Project),
   assignee: Ref(Contact),
 })
-  .pipe(S.mutable)
+  .pipe(Schema.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -60,15 +58,16 @@ export const Task = S.Struct({
     },
     description: 'Contact information.',
   });
-export interface Task extends S.Schema.Type<typeof Task> {}
+export interface Task extends Schema.Schema.Type<typeof Task> {}
 
-export const Organization = S.Struct({
+/** @deprecated */
+export const Organization = Schema.Struct({
   id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the organization.' }),
-  projects: S.Array(Ref(Project)),
-  employees: S.Array(Ref(Contact)),
+  name: Schema.String.annotations({ description: 'The name of the organization.' }),
+  projects: Schema.Array(Ref(Project)),
+  employees: Schema.Array(Ref(Contact)),
 })
-  .pipe(S.mutable)
+  .pipe(Schema.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -77,4 +76,4 @@ export const Organization = S.Struct({
     },
     description: 'Contact information.',
   });
-export interface Organization extends S.Schema.Type<typeof Organization> {}
+export interface Organization extends Schema.Schema.Type<typeof Organization> {}

package/src/typedefs.d.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+declare module '*?raw' {
+  const content: string;
+  export default content;
+}