@dxos/assistant 0.8.2-main.2f9c567 → 0.8.2-main.36232bc

package/src/session/session.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Option, Schema } from 'effect';
+import { Option, Schema as S } from 'effect';
 
 import {
   defineTool,
@@ -230,7 +230,7 @@ export class AISession {
     } catch (err) {
       log.catch(err);
       if (err instanceof Error && err.message.includes('Overloaded')) {
-        error = new AIServiecOverloadedError('AI service overloaded', { cause: err } as any); // TODO(dmaretskyi): Schema errors cant have cause
+        error = new AIServiecOverloadedError('AI service overloaded', { cause: err });
       } else {
         error = new Error('AI service error', { cause: err });
       }
@@ -287,7 +287,7 @@ export class AISession {
     return defineTool('system', {
       name: 'query_artifact_definitions',
       description: 'Query the available artifact definitions',
-      schema: Schema.Struct({}),
+      schema: S.Struct({}),
       execute: async () => {
         return ToolResult.Success({
           artifactDefinitions: artifacts.map((artifact) => ({
@@ -308,8 +308,8 @@ export class AISession {
       name: 'require_artifact_definitions',
       description:
         'Require the use of specific artifact definitions. This will allow the model to interact with artifact definitions and use their tools.',
-      schema: Schema.Struct({
-        artifactDefinitionIds: Schema.Array(Schema.String).annotations({
+      schema: S.Struct({
+        artifactDefinitionIds: S.Array(S.String).annotations({
           description: 'The ids of the artifact definitions to require',
           examples: [['artifact:dxos.org/example/Test']],
         }),
@@ -336,20 +336,20 @@ export class AISession {
       name: 'create_plan',
       description:
         'Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.',
-      schema: Schema.Struct({
-        goal: Schema.String.annotations({ description: 'The goal that the plan will achieve.' }),
-        steps: Schema.Array(
-          Schema.Struct({
-            action: Schema.String.annotations({
+      schema: S.Struct({
+        goal: S.String.annotations({ description: 'The goal that the plan will achieve.' }),
+        steps: S.Array(
+          S.Struct({
+            action: S.String.annotations({
               description: 'Complete, detailed action to perform.',
             }),
-            input: Schema.String.annotations({
+            input: S.String.annotations({
               description: 'The required input data for this step. First step must not require any data.',
             }),
-            output: Schema.String.annotations({
+            output: S.String.annotations({
               description: 'The output data from this step. This is passed to the next step as input.',
             }),
-            requiredArtifactIds: Schema.Array(Schema.String).annotations({
+            requiredArtifactIds: S.Array(S.String).annotations({
               description: 'The ids of the artifacts required to perform this step.',
               examples: [['artifact:dxos.org/example/Test']],
             }),
@@ -473,7 +473,7 @@ const createBaseInstructions = ({
   ${availableArtifacts.length > 0 ? `Artifacts already in context: ${availableArtifacts.join('\n')}` : ''}
 `;
 
-export class AIServiecOverloadedError extends Schema.TaggedError<AIServiecOverloadedError>()(
+export class AIServiecOverloadedError extends S.TaggedError<AIServiecOverloadedError>()(
   'AIServiecOverloadedError',
   {},
 ) {}
@@ -483,7 +483,7 @@ const gatherObjectVersions = (messages: Message[]): Map<ObjectId, ObjectVersion>
   for (const message of messages) {
     for (const block of message.content) {
       if (block.type === 'json' && block.disposition === VersionPin.DISPOSITION) {
-        const pin = VersionPin.pipe(Schema.decodeOption)(JSON.parse(block.json)).pipe(Option.getOrUndefined);
+        const pin = VersionPin.pipe(S.decodeOption)(JSON.parse(block.json)).pipe(Option.getOrUndefined);
         if (!pin) {
           continue;
         }

package/src/testing/artifacts.test.ts

@@ -3,7 +3,7 @@
 //
 
 /*
-import { Schema } from '@effect/schema';
+import { Schema as S } 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 = Schema.Struct({
-  typename: Schema.String,
-  description: Schema.String,
-  schema: Schema.Any,
-  actions: Schema.Array(Tool),
-}).pipe(Schema.mutable);
+const ArtifactDef = S.Struct({
+  typename: S.String,
+  description: S.String,
+  schema: S.Any,
+  actions: S.Array(Tool),
+}).pipe(S.mutable);
 
-type ArtifactDef = Schema.Schema.Type<typeof ArtifactDef>;
+type ArtifactDef = S.Schema.Type<typeof ArtifactDef>;
 
-const ListItem = Schema.Struct({
-  name: Schema.String,
+const ListItem = S.Struct({
+  name: S.String,
 });
 
-const ListSchema = Schema.Struct({
+const ListSchema = S.Struct({
   id: ObjectId,
-  title: Schema.String,
-  items: Schema.Array(ListItem).pipe(Schema.mutable),
-}).pipe(Schema.mutable);
+  title: S.String,
+  items: S.Array(ListItem).pipe(S.mutable),
+}).pipe(S.mutable);
 
-type ListSchema = Schema.Schema.Type<typeof ListSchema>;
+type ListSchema = S.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: Schema.Struct({}),
+      schema: S.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: Schema.Struct({
+      schema: S.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: Schema.Struct({
+      schema: S.Struct({
         id: ObjectId.annotations({ description: 'The list to add items to' }),
-        items: Schema.Array(ListItem).annotations({ description: 'The items to add to the list' }),
+        items: S.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: Schema.Any,
+  schema: S.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(
-        Schema.Struct({
-          magicWord: Schema.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
+        S.Struct({
+          magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
         }),
       ),
     };

package/src/testing/query-promts.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { defineTool, ToolResult } from '@dxos/artifact';
 import { toJsonSchema } from '@dxos/echo-schema';
@@ -11,14 +11,14 @@ import { log } from '@dxos/log';
 import { executeQuery, formatJsonSchemaForLLM, type DataSource } from '../cypher';
 import { trim } from '../util';
 
-export const createCypherTool = (dataSource: DataSource, schemaTypes: Schema.Schema.Any[] = []) =>
+export const createCypherTool = (dataSource: DataSource, schemaTypes: S.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: Schema.Struct({
-      query: Schema.String.annotations({
+    schema: S.Struct({
+      query: S.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: Schema.Sch
     },
   });
 
-export const createSystemPrompt = (schemaTypes: Schema.Schema.Any[]) => trim`
+export const createSystemPrompt = (schemaTypes: S.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/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 { live, makeRef } from '@dxos/live-object';
 
 import {
   type DataSource,
@@ -67,79 +60,79 @@ export const seedTestData = (db: EchoDatabase) => {
   const _taskComposer1 = db.add(
     live(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, {
       name: 'Create form builder',
-      project: RefImpl.make(projectComposer),
-      assignee: RefImpl.make(contactRich),
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactRich),
     }),
   );
   const _taskComposer3 = db.add(
     live(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, {
       name: 'Implement community plugin',
-      project: RefImpl.make(projectComposer),
-      assignee: RefImpl.make(contactFred),
+      project: makeRef(projectComposer),
+      assignee: makeRef(contactFred),
     }),
   );
   const _taskComposer4 = db.add(
     live(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, {
       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, {
       name: 'Add schema editor',
-      project: RefImpl.make(projectEcho),
-      assignee: RefImpl.make(contactRich),
+      project: makeRef(projectEcho),
+      assignee: makeRef(contactRich),
     }),
   );
   const _taskDoodles1 = db.add(
     live(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, {
       name: 'Implement dark mode',
-      project: RefImpl.make(projectDoodles),
-      assignee: RefImpl.make(contactJosiah),
+      project: makeRef(projectDoodles),
+      assignee: makeRef(contactJosiah),
     }),
   );
 
   const _orgDxos = db.add(
     live(Organization, {
       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, {
       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, {
     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, {
     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,16 +60,15 @@ 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 Organization = 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,
@@ -76,4 +77,4 @@ export const Organization = Schema.Struct({
     },
     description: 'Contact information.',
   });
-export interface Organization extends Schema.Schema.Type<typeof Organization> {}
+export interface Organization extends S.Schema.Type<typeof Organization> {}