@dxos/assistant 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/src/testing/query.test.ts

@@ -14,9 +14,10 @@ import { AI_SERVICE_ENDPOINT } from './defs';
 import { createLogger } from './logger';
 import { createCypherTool, createSystemPrompt } from './query-promts';
 import { createTestData, seedTestData } from './test-data';
-import { Contact, Organization, Project, Task } from './test-schema';
+import { Contact, Org, Project, Task } from './test-schema';
 import { AIServiceEdgeClient, DEFAULT_EDGE_MODEL } from '../ai-service';
-import { runLLM, EchoDataSource } from '../experimental';
+import { runLLM } from '../conversation';
+import { EchoDataSource } from '../cypher';
 
 const client = new AIServiceEdgeClient({
   endpoint: AI_SERVICE_ENDPOINT.LOCAL,
@@ -24,26 +25,27 @@ const client = new AIServiceEdgeClient({
 
 test.skip('cypher query', async () => {
   const dataSource = createTestData();
-  const schemaTypes = [Organization, Project, Task, Contact];
+  const schemaTypes = [Org, Project, Task, Contact];
 
   const cypherTool = createCypherTool(dataSource);
 
   const spaceId = SpaceId.random();
   const threadId = ObjectId.random();
 
+  await client.appendMessages([
+    createUserMessage(
+      spaceId,
+      threadId,
+      'Query the database and give me all employees from DXOS organization that work on Composer and what their tasks are.',
+    ),
+  ]);
+
   const result = await runLLM({
     model: DEFAULT_EDGE_MODEL,
     tools: [cypherTool],
     spaceId,
     threadId,
     system: createSystemPrompt(schemaTypes),
-    history: [
-      createUserMessage(
-        spaceId,
-        threadId,
-        'Query the database and give me all employees from DXOS organization that work on Composer and what their tasks are.',
-      ),
-    ],
     client,
     logger: createLogger({ stream: false }),
   });
@@ -55,7 +57,7 @@ test.skip('query ECHO', async () => {
   await using builder = await new EchoTestBuilder().open();
   const { db, graph } = await builder.createDatabase();
 
-  const schemaTypes = [Organization, Project, Task, Contact];
+  const schemaTypes = [Org, Project, Task, Contact];
   graph.schemaRegistry.addSchema(schemaTypes);
 
   seedTestData(db);
@@ -67,6 +69,14 @@ test.skip('query ECHO', async () => {
   const spaceId = SpaceId.random();
   const threadId = ObjectId.random();
 
+  await client.appendMessages([
+    createUserMessage(
+      spaceId,
+      threadId,
+      'Query the database and give me all employees from DXOS organization that work on Composer and what their tasks are.',
+    ),
+  ]);
+
   const result = await runLLM({
     model: DEFAULT_EDGE_MODEL,
     tools: [cypherTool],
@@ -74,13 +84,6 @@ test.skip('query ECHO', async () => {
     threadId,
     system: createSystemPrompt(schemaTypes),
     client,
-    history: [
-      createUserMessage(
-        spaceId,
-        threadId,
-        'Query the database and give me all employees from DXOS organization that work on Composer and what their tasks are.',
-      ),
-    ],
     logger: createLogger({ stream: false }),
   });
 

package/src/testing/test-data.ts

@@ -2,20 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import { type Schema as S } 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,
-  Ref as RefImpl,
-} from '@dxos/echo-schema';
+import { JSON_SCHEMA_ECHO_REF_ID, ObjectId, toJsonSchema, type JsonSchemaType, type Ref } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { live } from '@dxos/live-object';
+import { create, makeRef } from '@dxos/live-object';
 
 import {
   type DataSource,
@@ -23,123 +16,123 @@ import {
   type Relationship,
   formatInferredRelationshipLabel,
   formatNodeLabel,
-} from '../experimental';
-import { Contact, Organization, Project, Task } from '../testing';
+} from '../cypher';
+import { Contact, Org, Project, Task } from '../testing';
 
 export const seedTestData = (db: EchoDatabase) => {
   const contactRich = db.add(
-    live(Contact, {
+    create(Contact, {
       name: 'Rich',
     }),
   );
   const contactJosiah = db.add(
-    live(Contact, {
+    create(Contact, {
       name: 'Josiah',
     }),
   );
   const contactDima = db.add(
-    live(Contact, {
+    create(Contact, {
       name: 'Dima',
     }),
   );
   const contactFred = db.add(
-    live(Contact, {
+    create(Contact, {
       name: 'Fred',
     }),
   );
 
   const projectComposer = db.add(
-    live(Project, {
+    create(Project, {
       name: 'Composer',
     }),
   );
   const projectEcho = db.add(
-    live(Project, {
+    create(Project, {
       name: 'ECHO',
     }),
   );
   const projectDoodles = db.add(
-    live(Project, {
+    create(Project, {
       name: 'Doodles',
     }),
   );
 
   const _taskComposer1 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Optimize startup performance',
-      project: RefImpl.make(projectComposer),
-      assignee: RefImpl.make(contactJosiah),
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactJosiah),
     }),
   );
   const _taskComposer2 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Create form builder',
-      project: RefImpl.make(projectComposer),
-      assignee: RefImpl.make(contactRich),
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactRich),
     }),
   );
   const _taskComposer3 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Add support for custom themes',
-      project: RefImpl.make(projectComposer),
-      assignee: RefImpl.make(contactJosiah),
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactJosiah),
     }),
   );
   const _taskComposer5 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Implement community plugin',
-      project: RefImpl.make(projectComposer),
-      assignee: RefImpl.make(contactFred),
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactFred),
     }),
   );
   const _taskComposer4 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Implement dark mode',
-      project: RefImpl.make(projectComposer),
-      assignee: RefImpl.make(contactRich),
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactRich),
     }),
   );
   const _taskEcho1 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Implement cypher query engine',
-      project: RefImpl.make(projectEcho),
-      assignee: RefImpl.make(contactDima),
+      project: makeRef(projectEcho),
+      assignee: makeRef(contactDima),
     }),
   );
   const _taskEcho2 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Add schema editor',
-      project: RefImpl.make(projectEcho),
-      assignee: RefImpl.make(contactRich),
+      project: makeRef(projectEcho),
+      assignee: makeRef(contactRich),
     }),
   );
   const _taskDoodles1 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Add support for custom themes',
-      project: RefImpl.make(projectDoodles),
-      assignee: RefImpl.make(contactFred),
+      project: makeRef(projectDoodles),
+      assignee: makeRef(contactFred),
     }),
   );
   const _taskDoodles2 = db.add(
-    live(Task, {
+    create(Task, {
       name: 'Implement dark mode',
-      project: RefImpl.make(projectDoodles),
-      assignee: RefImpl.make(contactJosiah),
+      project: makeRef(projectDoodles),
+      assignee: makeRef(contactJosiah),
     }),
   );
 
   const _orgDxos = db.add(
-    live(Organization, {
+    create(Org, {
       name: 'DXOS',
-      employees: [RefImpl.make(contactRich), RefImpl.make(contactJosiah), RefImpl.make(contactDima)],
-      projects: [RefImpl.make(projectEcho)],
+      employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
+      projects: [makeRef(projectEcho)],
     }),
   );
   const _orgBraneframe = db.add(
-    live(Organization, {
+    create(Org, {
       name: 'Braneframe',
-      employees: [RefImpl.make(contactJosiah), RefImpl.make(contactRich)],
-      projects: [RefImpl.make(projectComposer)],
+      employees: [makeRef(contactJosiah), makeRef(contactRich)],
+      projects: [makeRef(projectComposer)],
     }),
   );
 };
@@ -181,69 +174,69 @@ export const createTestData = (): MockDataSource => {
   const _taskComposer1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Optimize startup performance',
-    project: RefImpl.make(projectComposer),
-    assignee: RefImpl.make(contactJosiah),
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactJosiah),
   });
   const _taskComposer2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Create form builder',
-    project: RefImpl.make(projectComposer),
-    assignee: RefImpl.make(contactRich),
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactRich),
   });
   const _taskComposer3 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add support for custom themes',
-    project: RefImpl.make(projectComposer),
-    assignee: RefImpl.make(contactJosiah),
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactJosiah),
   });
   const _taskComposer5 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement community plugin',
-    project: RefImpl.make(projectComposer),
-    assignee: RefImpl.make(contactFred),
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactFred),
   });
   const _taskComposer4 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement dark mode',
-    project: RefImpl.make(projectComposer),
-    assignee: RefImpl.make(contactRich),
+    project: makeRef(projectComposer),
+    assignee: makeRef(contactRich),
   });
   const _taskEcho1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement cypher query engine',
-    project: RefImpl.make(projectEcho),
-    assignee: RefImpl.make(contactDima),
+    project: makeRef(projectEcho),
+    assignee: makeRef(contactDima),
   });
   const _taskEcho2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add schema editor',
-    project: RefImpl.make(projectEcho),
-    assignee: RefImpl.make(contactRich),
+    project: makeRef(projectEcho),
+    assignee: makeRef(contactRich),
   });
   const _taskDoodles1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add support for custom themes',
-    project: RefImpl.make(projectDoodles),
-    assignee: RefImpl.make(contactFred),
+    project: makeRef(projectDoodles),
+    assignee: makeRef(contactFred),
   });
   const _taskDoodles2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement dark mode',
-    project: RefImpl.make(projectDoodles),
-    assignee: RefImpl.make(contactJosiah),
+    project: makeRef(projectDoodles),
+    assignee: makeRef(contactJosiah),
   });
 
-  const _orgDxos = dataSource.add(Organization, {
+  const _orgDxos = dataSource.add(Org, {
     id: ObjectId.random(),
     name: 'DXOS',
-    employees: [RefImpl.make(contactRich), RefImpl.make(contactJosiah), RefImpl.make(contactDima)],
-    projects: [RefImpl.make(projectEcho)],
+    employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
+    projects: [makeRef(projectEcho)],
   });
-  const _orgBraneframe = dataSource.add(Organization, {
+  const _orgBraneframe = dataSource.add(Org, {
     id: ObjectId.random(),
     name: 'Braneframe',
-    employees: [RefImpl.make(contactJosiah), RefImpl.make(contactRich)],
-    projects: [RefImpl.make(projectComposer)],
+    employees: [makeRef(contactJosiah), makeRef(contactRich)],
+    projects: [makeRef(projectComposer)],
   });
   dataSource.computeGraph();
 
@@ -254,7 +247,7 @@ export class MockDataSource implements DataSource {
   objects: Record<
     string,
     {
-      schema: Schema.Schema.All;
+      schema: S.Schema.All;
       typeDxn: string;
       id: string;
       data: unknown;
@@ -265,7 +258,7 @@ export class MockDataSource implements DataSource {
     string,
     {
       json: JsonSchemaType;
-      instance: Schema.Schema.All;
+      instance: S.Schema.All;
     }
   > = {};
 
@@ -280,7 +273,7 @@ export class MockDataSource implements DataSource {
     return this.relationships.filter((relationship) => !label || relationship.label === label);
   }
 
-  add<S extends Schema.Schema.All>(schema: S, data: Schema.Schema.Type<S>) {
+  add<S extends S.Schema.All>(schema: S, data: S.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,19 +2,22 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
-import { EntityKind, TypeAnnotationId, Ref, ObjectId } from '@dxos/echo-schema';
+import { EntityKind, TypeAnnotationId, Ref } from '@dxos/echo-schema';
 
-// TODO(burdon): Remove (use @dxos/schema DataType).
+// TODO(burdon): Reconcile with sdk/schema/testing.
+// TODO(burdon): Convert interface to type.
 
-/** @deprecated */
-export const Contact = Schema.Struct({
+// TODO(dmaretskyi): Extract.
+export const ObjectId = S.String.annotations({ description: 'The unique object identifier.' });
+
+export const Contact = S.Struct({
   id: ObjectId,
-  name: Schema.String.annotations({ description: 'The name of the person.' }),
-  email: Schema.optional(Schema.String).annotations({ description: 'Email address.' }),
+  name: S.String.annotations({ description: 'The name of the person.' }),
+  email: S.optional(S.String).annotations({ description: 'Email address.' }),
 })
-  .pipe(Schema.mutable)
+  .pipe(S.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -23,15 +26,14 @@ export const Contact = Schema.Struct({
     },
     description: 'Contact information.',
   });
-export interface Contact extends Schema.Schema.Type<typeof Contact> {}
+export interface Contact extends S.Schema.Type<typeof Contact> {}
 
-/** @deprecated */
-export const Project = Schema.Struct({
+export const Project = S.Struct({
   id: ObjectId,
-  name: Schema.String.annotations({ description: 'The name of the project.' }),
-  description: Schema.optional(Schema.String).annotations({ description: 'The description of the project.' }),
+  name: S.String.annotations({ description: 'The name of the project.' }),
+  description: S.optional(S.String).annotations({ description: 'The description of the project.' }),
 })
-  .pipe(Schema.mutable)
+  .pipe(S.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -40,16 +42,16 @@ export const Project = Schema.Struct({
     },
     description: 'Contact information.',
   });
-export interface Project extends Schema.Schema.Type<typeof Project> {}
+export interface Project extends S.Schema.Type<typeof Project> {}
 
-export const Task = Schema.Struct({
+export const Task = S.Struct({
   id: ObjectId,
-  name: Schema.String.annotations({ description: 'The name of the task.' }),
-  description: Schema.optional(Schema.String).annotations({ description: 'The description of the task.' }),
+  name: S.String.annotations({ description: 'The name of the task.' }),
+  description: S.optional(S.String).annotations({ description: 'The description of the task.' }),
   project: Ref(Project),
   assignee: Ref(Contact),
 })
-  .pipe(Schema.mutable)
+  .pipe(S.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -58,22 +60,21 @@ export const Task = Schema.Struct({
     },
     description: 'Contact information.',
   });
-export interface Task extends Schema.Schema.Type<typeof Task> {}
+export interface Task extends S.Schema.Type<typeof Task> {}
 
-/** @deprecated */
-export const Organization = Schema.Struct({
+export const Org = S.Struct({
   id: ObjectId,
-  name: Schema.String.annotations({ description: 'The name of the organization.' }),
-  projects: Schema.Array(Ref(Project)),
-  employees: Schema.Array(Ref(Contact)),
+  name: S.String.annotations({ description: 'The name of the organization.' }),
+  projects: S.Array(Ref(Project)),
+  employees: S.Array(Ref(Contact)),
 })
-  .pipe(Schema.mutable)
+  .pipe(S.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
-      typename: 'example.com/type/Organization',
+      typename: 'example.com/type/Org',
       version: '0.1.0',
     },
     description: 'Contact information.',
   });
-export interface Organization extends Schema.Schema.Type<typeof Organization> {}
+export interface Org extends S.Schema.Type<typeof Org> {}