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

package/src/{experimental/cypher → cypher}/echo-data-source.ts

@@ -2,11 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
-
 import { raise } from '@dxos/debug';
-import { type EchoDatabase, Filter, type AnyLiveObject } from '@dxos/echo-db';
-import { getSchema, getSchemaTypename, StoredSchema, toJsonSchema } from '@dxos/echo-schema';
+import { type EchoDatabase, Filter, type ReactiveEchoObject } from '@dxos/echo-db';
+import { type S, getSchemaTypename, StoredSchema, toJsonSchema } from '@dxos/echo-schema';
+import { getSchema } from '@dxos/live-object';
 import { log } from '@dxos/log';
 
 import type { DataSource, Node, Relationship } from './query-executor';
@@ -22,12 +21,13 @@ export class EchoDataSource implements DataSource {
       return objects.map(this._objectToNode);
     }
 
-    const schema = (await this._getAllSchema()).find((schema) => getSchemaTypename(schema)?.endsWith(label));
+    const schema = (await this._getAllSchema()).find((s) => getSchemaTypename(s)?.endsWith(label));
+
     if (!schema) {
       return [];
     }
 
-    const { objects } = await this._db.query(Filter.type(schema)).run();
+    const { objects } = await this._db.query(Filter.schema(schema)).run();
     return objects.map(this._objectToNode);
   }
 
@@ -57,21 +57,21 @@ export class EchoDataSource implements DataSource {
       return []; // TODO(dmaretskyi): Handle real relationships.
     }
 
-    const { objects } = await this._db.query(Filter.type(relationship.schema)).run();
+    const { objects } = await this._db.query(Filter.schema(relationship.schema)).run();
     return (
       await Promise.all(objects.map((object) => this._projectRefRelationship(object, relationship.property)))
     ).flat();
   }
 
-  private async _getAllSchema(): Promise<Schema.Schema.AnyNoContext[]> {
+  private async _getAllSchema(): Promise<S.Schema.AnyNoContext[]> {
     return [
       ...(await this._db.schemaRegistry.query().run()),
       // TODO(dmaretskyi): Remove once we can serialize recursive schema.
-      ...this._db.graph.schemaRegistry.schemas.filter((schema) => getSchemaTypename(schema)?.startsWith('example.org')),
+      ...this._db.graph.schemaRegistry.schemas.filter((s) => getSchemaTypename(s)?.startsWith('example.org')),
     ].filter((schema) => getSchemaTypename(schema) !== StoredSchema.typename);
   }
 
-  private _objectToNode(object: AnyLiveObject<any>): Node {
+  private _objectToNode(object: ReactiveEchoObject<any>): Node {
     const { id, ...properties } = object;
     return {
       id,
@@ -81,7 +81,7 @@ export class EchoDataSource implements DataSource {
     };
   }
 
-  private async _projectRefRelationship(object: AnyLiveObject<any>, prop: string): Promise<Relationship[]> {
+  private async _projectRefRelationship(object: ReactiveEchoObject<any>, prop: string): Promise<Relationship[]> {
     if (!object[prop]) {
       return [];
     }

package/src/{experimental/cypher → cypher}/execution-plan.test.ts

@@ -21,7 +21,7 @@ describe('Execution Plan', () => {
   test('complex query', ({ expect }) => {
     const plan = createExecutionPlan(
       parseCypherQuery(
-        "MATCH (org:Organization {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'}) RETURN c.name",
+        "MATCH (org:Org {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'}) RETURN c.name",
       ),
     );
     log('', { plan });

package/src/{experimental/cypher → cypher}/query-executor.test.ts

@@ -7,7 +7,7 @@ import { test } from 'vitest';
 import { log } from '@dxos/log';
 
 import { executeQuery } from './query-executor';
-import { createTestData } from '../../testing';
+import { createTestData } from '../testing';
 
 test.skip('run', async ({ expect }) => {
   const dataSource = createTestData();
@@ -25,7 +25,7 @@ test.skip('run', async ({ expect }) => {
   const result = await executeQuery(
     dataSource,
     `
-      MATCH (org:Organization {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'})
+      MATCH (org:Org {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'})
       RETURN c.name, t.name
     `,
   );

package/src/{experimental/cypher → cypher}/schema.test.ts

@@ -7,10 +7,10 @@ import { test } from 'vitest';
 import { toJsonSchema } from '@dxos/echo-schema';
 
 import { formatJsonSchemaForLLM } from './schema';
-import { Contact, Organization, Project, Task } from '../../testing';
+import { Contact, Org, Project, Task } from '../testing';
 
-test('Organization-Project-Task-Contact schema', async ({ expect }) => {
-  const jsonSchema = [Organization, Project, Task, Contact].map((schema) => toJsonSchema(schema));
+test('Org-Project-Task-Contact schema', async ({ expect }) => {
+  const jsonSchema = [Org, Project, Task, Contact].map((schema) => toJsonSchema(schema));
   const result = formatJsonSchemaForLLM(jsonSchema);
   // log('result', { result });
   expect(result).toHaveLength(8);

package/src/{experimental/cypher → cypher}/schema.ts

@@ -5,7 +5,7 @@
 import { raise } from '@dxos/debug';
 import { JSON_SCHEMA_ECHO_REF_ID, type JsonSchemaType } from '@dxos/echo-schema';
 
-import { trim } from '../../util';
+import { trim } from '../util';
 
 /**
  * Formats ECHO schema to be consumed by LLM.

package/src/index.ts

@@ -3,7 +3,6 @@
 //
 
 export * from './ai-service';
+export * from './cypher';
+export * from './conversation';
 export * from './session';
-
-// TODO(dmaretskyi): Separate entrypoint for experimental features.
-export * from './experimental';

package/src/session/index.ts

@@ -3,5 +3,3 @@
 //
 
 export * from './session';
-export * from './version-pin';
-export * from './tools';

package/src/session/session.test.ts

@@ -2,33 +2,35 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
+import { inspect } from 'node:util';
 import { describe, test } from 'vitest';
 
-import { ArtifactId, defineArtifact, defineTool, ToolResult } from '@dxos/artifact';
+import {
+  ArtifactId,
+  defineArtifact,
+  defineTool,
+  ToolResult,
+  type Message,
+  type MessageContentBlock,
+} from '@dxos/artifact';
 import { AIServiceEdgeClient } from '@dxos/assistant';
-import { Type } from '@dxos/echo';
-import { create, ObjectId } from '@dxos/echo-schema';
+import { createStatic, EchoObject, ObjectId } from '@dxos/echo-schema';
 import { DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
 
 import { AISession } from './session';
-import { AI_SERVICE_ENDPOINT, ConsolePrinter } from '../testing';
+import { AI_SERVICE_ENDPOINT } from '../testing';
 
 // Define a calendar event artifact schema.
-const CalendarEventSchema = Schema.Struct({
-  title: Schema.String,
-  startTime: Schema.String,
-  endTime: Schema.String,
-  description: Schema.String,
-}).pipe(
-  Type.def({
-    typename: 'example.com/type/CalendarEvent',
-    version: '0.1.0',
-  }),
-);
+const CalendarEventSchema = S.Struct({
+  title: S.String,
+  startTime: S.String,
+  endTime: S.String,
+  description: S.String,
+}).pipe(EchoObject({ typename: 'example.com/type/CalendarEvent', version: '0.1.0' }));
 
-type CalendarEvent = Schema.Schema.Type<typeof CalendarEventSchema>;
+type CalendarEvent = S.Schema.Type<typeof CalendarEventSchema>;
 
 // TODO(burdon): Flaky.
 describe.skip('AISession with Ollama', () => {
@@ -37,7 +39,7 @@ describe.skip('AISession with Ollama', () => {
     // const aiClient = new OllamaClient({
     //   overrides: { model: 'llama3.1:8b' },
     // });
-    const session = new AISession({ operationModel: 'configured' });
+    const session = new AISession({ operationModel: 'immediate' });
 
     const objects = new Set<string>();
 
@@ -51,7 +53,7 @@ describe.skip('AISession with Ollama', () => {
         defineTool('calendar', {
           name: 'query',
           description: 'Query the calendar for events',
-          schema: Schema.Struct({}),
+          schema: S.Struct({}),
           execute: async () => {
             return ToolResult.Success(CALENDAR_EVENTS);
           },
@@ -63,13 +65,13 @@ describe.skip('AISession with Ollama', () => {
       id: 'artifact:dxos.org/plugin/table',
       name: 'Table',
       instructions: 'Use this to create and manage tables. Each table has a unique id.',
-      schema: Schema.Struct({}),
+      schema: S.Struct({}),
       tools: [
         defineTool('table', {
           name: 'create',
           description: 'Create a table',
-          schema: Schema.Struct({
-            data: Schema.Array(Schema.Any).annotations({ description: 'Array of data payloads to add as rows' }),
+          schema: S.Struct({
+            data: S.Array(S.Any).annotations({ description: 'Array of data payloads to add as rows' }),
           }),
           execute: async ({ data }) => {
             log('create table', { data });
@@ -87,12 +89,12 @@ describe.skip('AISession with Ollama', () => {
       name: 'Map',
       instructions:
         'Use this to create and manage maps. Maps source data from tables. Table id is required to create a map.',
-      schema: Schema.Struct({}),
+      schema: S.Struct({}),
       tools: [
         defineTool('map', {
           name: 'create',
           description: 'Create a map',
-          schema: Schema.Struct({
+          schema: S.Struct({
             source: ArtifactId.annotations({
               description: 'The table that will be used as the source of the map',
             }),
@@ -117,7 +119,7 @@ describe.skip('AISession with Ollama', () => {
       id: 'artifact:dxos.org/plugin/script',
       name: 'Script',
       instructions: 'Use this to create and manage scripts',
-      schema: Schema.Struct({}),
+      schema: S.Struct({}),
       tools: [],
     });
 
@@ -125,10 +127,9 @@ describe.skip('AISession with Ollama', () => {
     //   printStreamEvent(event);
     // });
 
-    const printer = new ConsolePrinter();
-    session.message.on((message) => printer.printMessage(message));
-    session.userMessage.on((message) => printer.printMessage(message));
-    session.block.on((block) => printer.printContentBlock(block));
+    session.message.on(printMessage);
+    session.userMessage.on(printMessage);
+    session.block.on(printContentBlock);
 
     // session.update.on((update) => {
     //   log('update', { update });
@@ -139,7 +140,6 @@ describe.skip('AISession with Ollama', () => {
       client: aiClient,
       tools: [],
       artifacts: [calendarArtifact, tableArtifact, mapArtifact, scriptArtifact],
-      requiredArtifactIds: [calendarArtifact.id, tableArtifact.id, mapArtifact.id, scriptArtifact.id],
       history: [],
       generationOptions: {
         model: '@anthropic/claude-3-5-haiku-20241022',
@@ -156,31 +156,31 @@ describe.skip('AISession with Ollama', () => {
 
 // Travel to rome, florence, livorno, siena, madrid for conferences
 const CALENDAR_EVENTS: CalendarEvent[] = [
-  create(CalendarEventSchema, {
+  createStatic(CalendarEventSchema, {
     title: 'Exploring Ancient Ruins in Rome',
     startTime: '2024-01-01T10:00:00Z',
     endTime: '2024-01-01T11:00:00Z',
     description: 'Tech conference at the historic Colosseum with networking opportunities',
   }),
-  create(CalendarEventSchema, {
+  createStatic(CalendarEventSchema, {
     title: 'Renaissance Tech Summit in Florence',
     startTime: '2024-01-01T11:00:00Z',
     endTime: '2024-01-01T12:00:00Z',
     description: 'Discussing AI innovations surrounded by Renaissance art',
   }),
-  create(CalendarEventSchema, {
+  createStatic(CalendarEventSchema, {
     title: 'Travel to Livorno',
     startTime: '2024-01-01T12:00:00Z',
     endTime: '2024-01-01T13:00:00Z',
     description: 'Travel to Livorno',
   }),
-  create(CalendarEventSchema, {
+  createStatic(CalendarEventSchema, {
     title: 'Travel to Siena',
     startTime: '2024-01-01T13:00:00Z',
     endTime: '2024-01-01T14:00:00Z',
     description: 'Travel to Siena',
   }),
-  create(CalendarEventSchema, {
+  createStatic(CalendarEventSchema, {
     title: 'Travel to Madrid',
     startTime: '2024-01-01T14:00:00Z',
     endTime: '2024-01-01T15:00:00Z',
@@ -188,6 +188,34 @@ const CALENDAR_EVENTS: CalendarEvent[] = [
   }),
 ];
 
+const printMessage = (message: Message) => {
+  console.log(`${message.role.toUpperCase()}\n`);
+  for (const content of message.content) {
+    printContentBlock(content);
+  }
+};
+
+const printContentBlock = (content: MessageContentBlock) => {
+  switch (content.type) {
+    case 'text':
+      console.log(content.text);
+      break;
+    case 'tool_use':
+      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;
+      }
+      console.log(`⚙️ [Tool Result] ${content.toolUseId} ${inspect(data, { depth: null, colors: true })}`);
+      break;
+    }
+  }
+};
+
 // const printStreamEvent = (event: GenerationStreamEvent) => {
 //   switch (event.type) {
 //     case 'message_start': {