@dxos/assistant 0.8.2-staging.7ac8446 → 0.8.3-main.672df60

package/src/testing/object-extraction.test.ts

@@ -1,71 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-// import { AnthropicBackend } from '../conversation';
-// import { runLLM } from '../conversation';
-// import { createUserMessage } from '../conversation';
-
-// test('extract objects from the DXOS explainer', async () => {
-//   const result = await runLLM({
-//     model: DEFAULT_EDGE_MODEL,
-//     messages: [
-//       createUserMessage(`
-// # README
-
-// > Welcome to DXOS Composer.
-
-// Here, you can:
-// - Create and organize things
-// - Share and collaborate with others in real-time
-// - Work offline
-
-// Composer is:
-// - Free. Software built with DXOS requires no expensive server infrastructure to operate.
-// - Private. Your data never travels to or lives on any servers. Connections with collaborators are peer-to-peer.
-// - Local-first. Your data is stored entirely in your browser.
-// - Extensible. Add features by building plugins.
-// - Open source.
-
-// Your feedback is most welcome: feature requests, bug reports, questions: [Discord](https://discord.gg/uTYyx6srAW).
-
-// See also:
-// - [DXOS Documentation](https://docs.dxos.org) where you can build your own local-first, collaborative software.
-// `),
-//     ],
-//     system: `
-//       <instructions>
-//        Extract a list of objects that appear in the text.
-//        Objects can include names, places, technologies, people, concepts, etc.
-//        Extracts objects that are interesting or important in the context of the text.
-//       </instructions>
-
-//       <formatting>
-//         Output a list of object names from text, each surrounded with an object <object> tag.
-//       </formatting>
-
-//       <example>
-//         <input>
-//           Czerniaków was born on 30 November 1880 in Warsaw, Poland (then part of the Congress Poland). He studied engineering in Warsaw and Dresden and taught in the Jewish community's vocational school in Warsaw.
-//         </input>
-//         <output>
-//           <object>Czerniaków</object>
-//           <object>30 November 1880</object>
-//           <object>Warsaw</object>
-//           <object>Poland</object>
-//           <object>Congress Poland</object>
-//           <object>engineering</object>
-//           <object>Dresden</object>
-//         </output>
-//       </example>
-//     `,
-//     tools: [],
-//     backend,
-//   });
-
-//   log('result', { result });
-// });
-
-// const backend = new AnthropicBackend({
-//   apiKey: process.env.ANTHROPIC_API_KEY!,
-// });

package/src/testing/ollama.ts

@@ -1,15 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { DEFAULT_OLLAMA_MODEL, OllamaClient, type OllamaClientParams } from '../ai-service';
-
-/**
- * Create a test client with small local model and no temperature for predictable results.
- */
-export const createTestOllamaClient = (options?: Pick<OllamaClientParams, 'tools'>) => {
-  return new OllamaClient({
-    tools: options?.tools,
-    overrides: { model: DEFAULT_OLLAMA_MODEL, temperature: 0 },
-  });
-};

package/src/testing/query-promts.ts

@@ -1,75 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema as S } 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 { trim } from '../util';
-
-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: S.Struct({
-      query: S.String.annotations({
-        description: `
-          A valid cypher query string to execute.
-          Query must have one MATCH clause.
-          Match clause can have multiple patterns but they must all be connected via a relationship chain.
-          Query might have zero or one WHERE clauses.
-          Query must have one RETURN clause.
-          RETURN clause can have multiple expressions separated by commas.
-          DISTINCT keyword is not allowed.
-
-          <example>
-          MATCH (n:Person) RETURN n.name
-          </example>
-
-          <example>
-          MATCH (s:Studio)-[:PRODUCED]->(m:Movie)-[:PRODUCED_IN]->(c:City {name: "Las Vegas"}) RETURN s
-          </example>
-          
-          <example>
-          MATCH (a:Actor)-[:STARRED_IN]->(m:Movie)<-[:PRODUCED]-(s:Studio {name: "Cinema Pictures"}) WHERE m.name = "Once upon a time" RETURN m.name, a.name
-          </example>
-        `,
-      }),
-    }),
-    execute: async ({ query }) => {
-      try {
-        log('cypher query', { query });
-        const results = await executeQuery(dataSource, query);
-        log('query complete', { results });
-        return ToolResult.Success(results);
-      } catch (e: any) {
-        log.catch(e);
-        return ToolResult.Error(e.message);
-      }
-    },
-  });
-
-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:
-
-  <schema>
-    ${formatJsonSchemaForLLM(schemaTypes.map((schema) => toJsonSchema(schema)))}
-  <schema>
-
-  Before replying always think step-by-step on how to proceed.
-  Print your thoughts inside <cot> tags.
-  
-  <example>
-    <cot>To answer the question I need to ...</cot>
-  </example>
-
-  Before answering the user's question, decide what tools you need to use to answer the question.
-`;

package/src/testing/query.test.ts

@@ -1,91 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { test } from 'vitest';
-
-import { createUserMessage } from '@dxos/artifact';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
-import { ObjectId } from '@dxos/echo-schema';
-import { SpaceId } from '@dxos/keys';
-import { log } from '@dxos/log';
-
-import { AI_SERVICE_ENDPOINT } from './defs';
-import { createLogger } from './logger';
-import { createCypherTool, createSystemPrompt } from './query-promts';
-import { createTestData, seedTestData } from './test-data';
-import { Contact, Org, Project, Task } from './test-schema';
-import { AIServiceEdgeClient, DEFAULT_EDGE_MODEL } from '../ai-service';
-import { runLLM } from '../conversation';
-import { EchoDataSource } from '../cypher';
-
-const client = new AIServiceEdgeClient({
-  endpoint: AI_SERVICE_ENDPOINT.LOCAL,
-});
-
-test.skip('cypher query', async () => {
-  const dataSource = createTestData();
-  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),
-    client,
-    logger: createLogger({ stream: false }),
-  });
-
-  log('DONE', { result: result.result });
-});
-
-test.skip('query ECHO', async () => {
-  await using builder = await new EchoTestBuilder().open();
-  const { db, graph } = await builder.createDatabase();
-
-  const schemaTypes = [Org, Project, Task, Contact];
-  graph.schemaRegistry.addSchema(schemaTypes);
-
-  seedTestData(db);
-  await db.flush({ indexes: true });
-
-  const dataSource = new EchoDataSource(db);
-  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),
-    client,
-    logger: createLogger({ stream: false }),
-  });
-
-  log('DONE', { result: result.result });
-});

package/src/testing/test-data.ts

@@ -1,372 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-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 } from '@dxos/echo-schema';
-import { invariant } from '@dxos/invariant';
-import { create, makeRef } from '@dxos/live-object';
-
-import {
-  type DataSource,
-  type Node,
-  type Relationship,
-  formatInferredRelationshipLabel,
-  formatNodeLabel,
-} from '../cypher';
-import { Contact, Org, Project, Task } from '../testing';
-
-export const seedTestData = (db: EchoDatabase) => {
-  const contactRich = db.add(
-    create(Contact, {
-      name: 'Rich',
-    }),
-  );
-  const contactJosiah = db.add(
-    create(Contact, {
-      name: 'Josiah',
-    }),
-  );
-  const contactDima = db.add(
-    create(Contact, {
-      name: 'Dima',
-    }),
-  );
-  const contactFred = db.add(
-    create(Contact, {
-      name: 'Fred',
-    }),
-  );
-
-  const projectComposer = db.add(
-    create(Project, {
-      name: 'Composer',
-    }),
-  );
-  const projectEcho = db.add(
-    create(Project, {
-      name: 'ECHO',
-    }),
-  );
-  const projectDoodles = db.add(
-    create(Project, {
-      name: 'Doodles',
-    }),
-  );
-
-  const _taskComposer1 = db.add(
-    create(Task, {
-      name: 'Optimize startup performance',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactJosiah),
-    }),
-  );
-  const _taskComposer2 = db.add(
-    create(Task, {
-      name: 'Create form builder',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactRich),
-    }),
-  );
-  const _taskComposer3 = db.add(
-    create(Task, {
-      name: 'Add support for custom themes',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactJosiah),
-    }),
-  );
-  const _taskComposer5 = db.add(
-    create(Task, {
-      name: 'Implement community plugin',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactFred),
-    }),
-  );
-  const _taskComposer4 = db.add(
-    create(Task, {
-      name: 'Implement dark mode',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactRich),
-    }),
-  );
-  const _taskEcho1 = db.add(
-    create(Task, {
-      name: 'Implement cypher query engine',
-      project: makeRef(projectEcho),
-      assignee: makeRef(contactDima),
-    }),
-  );
-  const _taskEcho2 = db.add(
-    create(Task, {
-      name: 'Add schema editor',
-      project: makeRef(projectEcho),
-      assignee: makeRef(contactRich),
-    }),
-  );
-  const _taskDoodles1 = db.add(
-    create(Task, {
-      name: 'Add support for custom themes',
-      project: makeRef(projectDoodles),
-      assignee: makeRef(contactFred),
-    }),
-  );
-  const _taskDoodles2 = db.add(
-    create(Task, {
-      name: 'Implement dark mode',
-      project: makeRef(projectDoodles),
-      assignee: makeRef(contactJosiah),
-    }),
-  );
-
-  const _orgDxos = db.add(
-    create(Org, {
-      name: 'DXOS',
-      employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
-      projects: [makeRef(projectEcho)],
-    }),
-  );
-  const _orgBraneframe = db.add(
-    create(Org, {
-      name: 'Braneframe',
-      employees: [makeRef(contactJosiah), makeRef(contactRich)],
-      projects: [makeRef(projectComposer)],
-    }),
-  );
-};
-
-// TODO(burdon): Use schema/testing.
-export const createTestData = (): MockDataSource => {
-  const dataSource = new MockDataSource();
-
-  const contactRich = dataSource.add(Contact, {
-    id: ObjectId.random(),
-    name: 'Rich',
-  });
-  const contactJosiah = dataSource.add(Contact, {
-    id: ObjectId.random(),
-    name: 'Josiah',
-  });
-  const contactDima = dataSource.add(Contact, {
-    id: ObjectId.random(),
-    name: 'Dima',
-  });
-  const contactFred = dataSource.add(Contact, {
-    id: ObjectId.random(),
-    name: 'Fred',
-  });
-
-  const projectComposer = dataSource.add(Project, {
-    id: ObjectId.random(),
-    name: 'Composer',
-  });
-  const projectEcho = dataSource.add(Project, {
-    id: ObjectId.random(),
-    name: 'ECHO',
-  });
-  const projectDoodles = dataSource.add(Project, {
-    id: ObjectId.random(),
-    name: 'Doodles',
-  });
-
-  const _taskComposer1 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Optimize startup performance',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactJosiah),
-  });
-  const _taskComposer2 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Create form builder',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactRich),
-  });
-  const _taskComposer3 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Add support for custom themes',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactJosiah),
-  });
-  const _taskComposer5 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Implement community plugin',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactFred),
-  });
-  const _taskComposer4 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Implement dark mode',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactRich),
-  });
-  const _taskEcho1 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Implement cypher query engine',
-    project: makeRef(projectEcho),
-    assignee: makeRef(contactDima),
-  });
-  const _taskEcho2 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Add schema editor',
-    project: makeRef(projectEcho),
-    assignee: makeRef(contactRich),
-  });
-  const _taskDoodles1 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Add support for custom themes',
-    project: makeRef(projectDoodles),
-    assignee: makeRef(contactFred),
-  });
-  const _taskDoodles2 = dataSource.add(Task, {
-    id: ObjectId.random(),
-    name: 'Implement dark mode',
-    project: makeRef(projectDoodles),
-    assignee: makeRef(contactJosiah),
-  });
-
-  const _orgDxos = dataSource.add(Org, {
-    id: ObjectId.random(),
-    name: 'DXOS',
-    employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
-    projects: [makeRef(projectEcho)],
-  });
-  const _orgBraneframe = dataSource.add(Org, {
-    id: ObjectId.random(),
-    name: 'Braneframe',
-    employees: [makeRef(contactJosiah), makeRef(contactRich)],
-    projects: [makeRef(projectComposer)],
-  });
-  dataSource.computeGraph();
-
-  return dataSource;
-};
-
-export class MockDataSource implements DataSource {
-  objects: Record<
-    string,
-    {
-      schema: S.Schema.All;
-      typeDxn: string;
-      id: string;
-      data: unknown;
-    }
-  > = {};
-
-  schema: Record<
-    string,
-    {
-      json: JsonSchemaType;
-      instance: S.Schema.All;
-    }
-  > = {};
-
-  nodes: Node[] = [];
-  relationships: Relationship[] = [];
-
-  async getNodes({ label }: { label?: string }) {
-    return this.nodes.filter((node) => !label || node.label === label);
-  }
-
-  async getRelationships({ label }: { label?: string }) {
-    return this.relationships.filter((relationship) => !label || relationship.label === label);
-  }
-
-  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!]) {
-      this.schema[jsonSchema.$id!] = {
-        json: jsonSchema,
-        instance: schema,
-      };
-    }
-
-    const typenameDxn = jsonSchema.$id ?? raise(new Error('Schema must have $id'));
-
-    this.objects[data.id] = {
-      schema,
-      id: data.id,
-      typeDxn: typenameDxn,
-      data,
-    };
-
-    return data;
-  }
-
-  computeGraph() {
-    this.nodes = [];
-    this.relationships = [];
-
-    for (const object of Object.values(this.objects)) {
-      this.nodes.push({
-        kind: 'node',
-        id: object.id,
-        label: formatNodeLabel(object.typeDxn),
-        properties: object.data as any,
-      });
-    }
-
-    for (const object of Object.values(this.objects)) {
-      const schema = this.schema[object.typeDxn].json;
-      const typenameDxn = schema.$id ?? raise(new Error('Schema must have $id'));
-
-      for (const [name, propSchema] of Object.entries(schema.properties!)) {
-        if (propSchema.$id === JSON_SCHEMA_ECHO_REF_ID) {
-          const label = formatInferredRelationshipLabel(typenameDxn, name);
-
-          const source = this.nodes.find((node) => node.id === object.id);
-          if (!source) {
-            continue;
-          }
-
-          const { id: targetId } = (object.data as any)[name].target;
-
-          const target = this.nodes.find((node) => node.id === targetId);
-          if (!target) {
-            continue;
-          }
-
-          this.relationships.push({
-            kind: 'relationship',
-            id: `${object.id}-${name}-${target.id}`,
-            label,
-            properties: {},
-            source,
-            target,
-          });
-        } else if (
-          propSchema.type === 'array' &&
-          propSchema.items &&
-          typeof propSchema.items === 'object' &&
-          '$id' in propSchema.items &&
-          propSchema.items.$id === JSON_SCHEMA_ECHO_REF_ID
-        ) {
-          const label = formatInferredRelationshipLabel(typenameDxn, name);
-
-          const source = this.nodes.find((node) => node.id === object.id);
-          if (!source) {
-            continue;
-          }
-
-          for (const { id: targetId } of (object.data as any)[name].map((x: Ref<any>) => x.target)) {
-            const target = this.nodes.find((node) => node.id === targetId);
-            if (!target) {
-              continue;
-            }
-
-            this.relationships.push({
-              kind: 'relationship',
-              id: `${object.id}-${name}-${targetId}`,
-              label,
-              properties: {},
-              source,
-              target,
-            });
-          }
-        }
-      }
-    }
-  }
-}

package/src/testing/test-schema.ts

@@ -1,80 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema as S } from 'effect';
-
-import { EntityKind, TypeAnnotationId, Ref } from '@dxos/echo-schema';
-
-// TODO(burdon): Reconcile with sdk/schema/testing.
-// TODO(burdon): Convert interface to type.
-
-// TODO(dmaretskyi): Extract.
-export const ObjectId = S.String.annotations({ description: 'The unique object identifier.' });
-
-export const Contact = S.Struct({
-  id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the person.' }),
-  email: S.optional(S.String).annotations({ description: 'Email address.' }),
-})
-  .pipe(S.mutable)
-  .annotations({
-    [TypeAnnotationId]: {
-      kind: EntityKind.Object,
-      typename: 'example.com/type/Contact',
-      version: '0.1.0',
-    },
-    description: 'Contact information.',
-  });
-export interface Contact extends S.Schema.Type<typeof Contact> {}
-
-export const Project = S.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.' }),
-})
-  .pipe(S.mutable)
-  .annotations({
-    [TypeAnnotationId]: {
-      kind: EntityKind.Object,
-      typename: 'example.com/type/Project',
-      version: '0.1.0',
-    },
-    description: 'Contact information.',
-  });
-export interface Project extends S.Schema.Type<typeof Project> {}
-
-export const Task = S.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.' }),
-  project: Ref(Project),
-  assignee: Ref(Contact),
-})
-  .pipe(S.mutable)
-  .annotations({
-    [TypeAnnotationId]: {
-      kind: EntityKind.Object,
-      typename: 'example.com/type/Task',
-      version: '0.1.0',
-    },
-    description: 'Contact information.',
-  });
-export interface Task extends S.Schema.Type<typeof Task> {}
-
-export const Org = S.Struct({
-  id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the organization.' }),
-  projects: S.Array(Ref(Project)),
-  employees: S.Array(Ref(Contact)),
-})
-  .pipe(S.mutable)
-  .annotations({
-    [TypeAnnotationId]: {
-      kind: EntityKind.Object,
-      typename: 'example.com/type/Org',
-      version: '0.1.0',
-    },
-    description: 'Contact information.',
-  });
-export interface Org extends S.Schema.Type<typeof Org> {}