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

package/src/cypher/query-executor.test.ts

@@ -1,47 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { test } from 'vitest';
-
-import { log } from '@dxos/log';
-
-import { executeQuery } from './query-executor';
-import { createTestData } from '../testing';
-
-test.skip('run', async ({ expect }) => {
-  const dataSource = createTestData();
-  // for (const node of dataSource.nodes) {
-  //   log('node', { id: node.id, label: node.label, name: node.properties.name });
-  // }
-  // for (const relationship of dataSource.relationships) {
-  //   log('relationship', {
-  //     source: relationship.source.id,
-  //     target: relationship.target.id,
-  //     label: relationship.label,
-  //   });
-  // }
-
-  const result = await executeQuery(
-    dataSource,
-    `
-      MATCH (org:Org {name: 'DXOS'})-[:ORG_EMPLOYEES]->(c:Contact)<-[:TASK_ASSIGNEE]-(t:Task)-[:TASK_PROJECT]->(p:Project {name: 'Composer'})
-      RETURN c.name, t.name
-    `,
-  );
-
-  expect(result).toEqual([
-    { c_name: 'Rich', t_name: 'Create form builder' },
-    {
-      c_name: 'Josiah',
-      t_name: 'Optimize startup performance',
-    },
-    { c_name: 'Rich', t_name: 'Implement dark mode' },
-    {
-      c_name: 'Josiah',
-      t_name: 'Add support for custom themes',
-    },
-  ]);
-
-  log('result', { result });
-});

package/src/cypher/query-executor.ts

@@ -1,145 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import type { JsonPath } from '@dxos/echo-schema';
-import { log } from '@dxos/log';
-import { mapValues } from '@dxos/util';
-
-import { createExecutionPlan, type ExecutionPlan, type VariableName } from './execution-plan';
-import { parseCypherQuery } from './parser';
-
-export interface DataSource {
-  getNodes: (params: { label?: string }) => Promise<Node[]>;
-  getRelationships: (params: { label?: string }) => Promise<Relationship[]>;
-}
-
-export type Node = {
-  id: string;
-  kind: 'node';
-  label: string;
-  properties: Record<string, unknown>;
-};
-
-export type Relationship = {
-  id: string;
-  kind: 'relationship';
-  label: string;
-  properties: Record<string, unknown>;
-  source: Node;
-  target: Node;
-};
-
-export const executeQueryPlan = async (
-  dataSource: DataSource,
-  plan: ExecutionPlan,
-): Promise<Record<string, unknown>[]> => {
-  let buffer: Record<VariableName, Node | Relationship>[] = [];
-  const results: Record<string, unknown>[] = [];
-
-  for (const step of plan.steps) {
-    log('begin step', { step });
-
-    switch (step.type) {
-      case 'NodeScan': {
-        const nodes = await dataSource.getNodes({ label: step.label });
-        buffer.push(...nodes.map((node) => ({ [step.into]: node })));
-        break;
-      }
-      case 'FilterByLabel': {
-        buffer = buffer.filter((item) => {
-          const node = item[step.variable];
-          return node && node.kind === 'node' && node.label === step.label;
-        });
-        break;
-      }
-      case 'FilterByProperty': {
-        buffer = buffer.filter((item) => {
-          const node = item[step.variable];
-          return node && node.kind === 'node' && node.properties[step.property] === step.value;
-        });
-        break;
-      }
-      case 'RelationshipScan': {
-        const relationships = await dataSource.getRelationships({ label: step.label });
-        for (const tuple of [...buffer]) {
-          if (tuple[step.anchor].kind !== 'node') {
-            continue;
-          }
-          const filteredRelationships = relationships.filter((relationship) => {
-            switch (step.direction) {
-              case 'in':
-                return relationship.target.id === tuple[step.anchor].id;
-              case 'out':
-                return relationship.source.id === tuple[step.anchor].id;
-              case 'both':
-                return (
-                  relationship.source.id === tuple[step.anchor].id || relationship.target.id === tuple[step.anchor].id
-                );
-              default:
-                throw new Error(`Unknown direction: ${step.direction}`);
-            }
-          });
-          for (let i = 0; i < filteredRelationships.length; i++) {
-            const relationship = filteredRelationships[i];
-            const newTuple = i === 0 ? tuple : { ...tuple };
-            if (newTuple !== tuple) {
-              buffer.push(newTuple);
-            }
-            newTuple[step.relationshipInto] = relationship;
-            switch (step.direction) {
-              case 'in':
-                newTuple[step.nodeInto] = relationship.source;
-                break;
-              case 'out':
-                newTuple[step.nodeInto] = relationship.target;
-                break;
-              case 'both':
-                newTuple[step.nodeInto] =
-                  relationship.source.id === newTuple[step.anchor].id ? relationship.target : relationship.source;
-                break;
-            }
-          }
-        }
-        break;
-      }
-      case 'ProduceResults': {
-        for (const tuple of buffer) {
-          const result: Record<string, unknown> = {};
-          for (const field of step.fields) {
-            result[field.name] = jsonPathGet(tuple[field.variable].properties, field.path);
-          }
-          results.push(result);
-        }
-        break;
-      }
-    }
-
-    log('finish step', { buffer: buffer.map((tuple) => mapValues(tuple, (x) => x.id)), results });
-  }
-
-  return results;
-};
-
-export const executeQuery = (dataSource: DataSource, query: string): Promise<Record<string, unknown>[]> => {
-  const plan = createExecutionPlan(parseCypherQuery(query));
-  return executeQueryPlan(dataSource, plan);
-};
-
-// TODO(dmaretskyi): Extract.
-const jsonPathGet = (obj: Record<string, unknown>, path: JsonPath): unknown => {
-  if (path === '' || path === '$') {
-    return obj;
-  }
-
-  const parts = path.split('.');
-  if (parts[0] === '$') {
-    parts.shift();
-  }
-
-  let result: any = obj;
-  for (const part of parts) {
-    result = result?.[part];
-  }
-  return result;
-};

package/src/cypher/schema.test.ts

@@ -1,17 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { test } from 'vitest';
-
-import { toJsonSchema } from '@dxos/echo-schema';
-
-import { formatJsonSchemaForLLM } from './schema';
-import { Contact, Org, Project, Task } from '../testing';
-
-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/cypher/schema.ts

@@ -1,86 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { raise } from '@dxos/debug';
-import { JSON_SCHEMA_ECHO_REF_ID, type JsonSchemaType } from '@dxos/echo-schema';
-
-import { trim } from '../util';
-
-/**
- * Formats ECHO schema to be consumed by LLM.
- * Schema is formatted in cypher format.
- * Objects are represented as nodes.
- * References are represented as relationships.
- */
-export const formatJsonSchemaForLLM = (schemaTypes: JsonSchemaType[]): string[] => {
-  return schemaTypes.flatMap((schema) => [
-    formatNodeSchema(schema),
-    ...formatInferredRelationships(schema, schemaTypes),
-  ]);
-};
-
-const formatNodeSchema = (schema: JsonSchemaType) => {
-  const label = formatNodeLabel(schema.typename ?? raise(new Error('Schema must have $id')));
-  const properties = Object.entries(schema.properties!).filter(([key, prop]) => key !== 'id' && !isReference(prop));
-
-  return trim`
-    <node>
-      (:${label})
-
-      <description>${schema.description}</description>
-
-      <properties>
-        ${properties.map(([key, value]) => {
-          return trim`
-            <${key}>
-              <type>${value.type}</type>
-              <description>${value.description}</description>
-            </${key}>
-          `;
-        })}
-      </properties>
-    </node>
-  `;
-};
-
-const formatInferredRelationships = (schema: JsonSchemaType, allSchema: JsonSchemaType[]): string[] => {
-  const nodeLabel = formatNodeLabel(schema.typename ?? raise(new Error('Schema must have $id')));
-  const relationships = Object.entries(schema.properties!).filter(([key, prop]) => isReference(prop));
-
-  return relationships.map(([key, value]) => {
-    const relationshipLabel = formatInferredRelationshipLabel(
-      schema.typename ?? raise(new Error('Schema must have $id')),
-      key,
-    );
-
-    // TODO(dmaretskyi): Registered schema don't get reference types updated.
-    const targetSchema = allSchema.find((schema) => `dxn:type/${schema.typename}` === value.reference?.schema.$ref);
-    const targetLabel = targetSchema ? formatNodeLabel(targetSchema?.typename ?? '') : '';
-
-    return trim`
-      <relationship>
-        (:${nodeLabel})-[:${relationshipLabel}]->(:${targetLabel})
-
-        <description>${value.description}</description>
-      </relationship>
-    `;
-  });
-};
-
-export const formatNodeLabel = (typename: string) => {
-  return typename.replace(/^example\.com\/type\//g, '');
-};
-
-export const formatInferredRelationshipLabel = (typename: string, property: string) => {
-  const nodeLabel = formatNodeLabel(typename);
-  return `${nodeLabel}_${property}`.toUpperCase();
-};
-
-export const isReference = (schema: JsonSchemaType) =>
-  schema.$id === JSON_SCHEMA_ECHO_REF_ID ||
-  (schema.type === 'array' &&
-    !Array.isArray(schema.items) &&
-    typeof schema.items === 'object' &&
-    '$id' in schema.items &&
-    schema.items.$id === JSON_SCHEMA_ECHO_REF_ID);

package/src/testing/artifacts.test.ts

@@ -1,182 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-/*
-import { Schema as S } from '@effect/schema';
-import { describe, test } from 'vitest';
-
-import { ObjectId, toJsonSchema } from '@dxos/echo-schema';
-import { invariant } from '@dxos/invariant';
-import { SpaceId } from '@dxos/keys';
-import { log } from '@dxos/log';
-
-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);
-
-type ArtifactDef = S.Schema.Type<typeof ArtifactDef>;
-
-const ListItem = S.Struct({
-  name: S.String,
-});
-
-const ListSchema = S.Struct({
-  id: ObjectId,
-  title: S.String,
-  items: S.Array(ListItem).pipe(S.mutable),
-}).pipe(S.mutable);
-
-type ListSchema = S.Schema.Type<typeof ListSchema>;
-
-const list: ArtifactDef = {
-  typename: 'example.com/type/List',
-  description: 'Ordered set of text items.',
-  schema: ListSchema,
-  actions: [
-    defineTool('list', {
-      name: 'query',
-      description: 'Query all lists',
-      schema: S.Struct({}),
-      execute: async ({}, context) => {
-        return ToolResult.Success(LISTS[id]);
-      },
-    }),
-    defineTool('list', {
-      name: 'inspect',
-      description: 'Get contents of the list',
-      schema: S.Struct({
-        id: ObjectId.annotations({ description: 'The list to inspect' }),
-      }),
-      execute: async ({ id }, context) => {
-        return ToolResult.Success(LISTS[id]);
-      },
-    }),
-    defineTool('list', {
-      name: 'create',
-      description: 'Add one or more items to an existing list',
-      schema: S.Struct({
-        id: ObjectId.annotations({ description: 'The list to add items to' }),
-        items: S.Array(ListItem).annotations({ description: 'The items to add to the list' }),
-      }),
-      execute: async ({ id, items }, context) => {
-        LISTS[id].items.push(...items);
-        return ToolResult.Success(LISTS[id]);
-      },
-    }),
-  ],
-};
-
-const LISTS: Record<ObjectId, ListSchema> = {};
-
-const artifacts = [list];
-
-const getArtifactDefinitions = defineTool('system', {
-  name: 'getArtifactDefinitions',
-  description: 'Queries the definitions and metadata of artifacts defined in the system',
-  schema: S.Any,
-  execute: async (_, context) => {
-    return ToolResult.Success(
-      artifacts.map((artifact) => ({
-        typename: artifact.typename,
-        description: artifact.description,
-        schema: toJsonSchema(artifact.schema),
-        actions: artifact.actions.map((action) => ({
-          name: action.name,
-          description: action.description,
-        })),
-      })),
-    );
-  },
-});
-
-const ARTIFACT_INSTRUCTIONS = `
-You have ability to interact with artifacts.
-Artifacts are persistent structured objects that have actions associated with them.
-
-Before replying to the user you should first query the artifact definitions and metadata.
-If there's
-
-`;
-
-describe('Artifacts', () => {
-  test('shopping list', async () => {
-    const client = new AIServiceEdgeClient({
-      endpoint: ENDPOINT,
-    });
-
-    const custodian: Tool = {
-      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"' }),
-        }),
-      ),
-    };
-
-    const spaceId = SpaceId.random();
-    const threadId = ObjectId.random();
-
-    await client.appendMessages([
-      {
-        id: ObjectId.random(),
-        spaceId,
-        threadId,
-        role: 'user',
-        content: [{ type: 'text', text: 'What is the password? Ask the custodian' }],
-      },
-    ]);
-
-    const stream = await client.generate({
-      model: DEFAULT_EDGE_MODEL,
-      spaceId,
-      threadId,
-      systemPrompt: 'You are a helpful assistant.',
-      tools: [custodian],
-    });
-    for await (const event of stream) {
-      log('event', event);
-    }
-    const [message] = await stream.complete();
-    log('full message', {
-      message,
-    });
-    await client.appendMessages([message]);
-
-    const toolUse = message.content.find(({ type }) => type === 'tool_use')!;
-    invariant(toolUse.type === 'tool_use');
-    await client.appendMessages([
-      {
-        id: ObjectId.random(),
-        spaceId,
-        threadId,
-        role: 'user',
-        content: [{ type: 'tool_result', toolUseId: toolUse.id, content: 'password="The sky is gray"' }],
-      },
-    ]);
-
-    const stream2 = await client.generate({
-      model: DEFAULT_EDGE_MODEL,
-      spaceId,
-      threadId,
-      systemPrompt: 'You are a helpful assistant.',
-      tools: [custodian],
-    });
-    for await (const event of stream2) {
-      log('event', event);
-    }
-    const [message2] = await stream2.complete();
-    log('full message', {
-      message: message2,
-    });
-  });
-});
-*/

package/src/testing/data.ts

@@ -1,13 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export const DATA_MESSAGES = [
-  `
-  <cot>
-  ${Array.from({ length: 5 })
-    .map((_, i) => `${i + 1}. Step`)
-    .join('\n')}
-  </cot>
-  `,
-];

package/src/testing/defs.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// TODO(burdon): Remove/Reconcile with @dxos/assistant-testing.
-export const AI_SERVICE_ENDPOINT = {
-  LOCAL: 'http://localhost:8788',
-  REMOTE: 'https://ai-service.dxos.workers.dev',
-};

package/src/testing/logger.ts

@@ -1,129 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import type { ImageSource, MessageContentBlock } from '@dxos/artifact';
-
-import type { ConversationEvent } from '../conversation';
-
-export const createLogger = ({
-  stream,
-  filter,
-  onImage,
-}: {
-  stream?: boolean;
-  filter?: (event: ConversationEvent) => boolean;
-  onImage?: (img: { id: string; description?: string; source: ImageSource }) => void;
-} = {}) => {
-  const images: Record<string, any> = {};
-  let currentText = '';
-
-  return (event: ConversationEvent) => {
-    if (typeof filter === 'function' && !filter(event)) {
-      return;
-    }
-
-    const printContentBlock = (content: MessageContentBlock) => {
-      switch (content.type) {
-        case 'text':
-          process.stdout.write(content.text);
-          break;
-        case 'tool_use':
-          process.stdout.write(`⚙️ [Tool Use] ${content.name}\n`);
-          break;
-        case 'image': {
-          if (content.id && content.source) {
-            images[content.id] = content.source;
-          }
-          process.stdout.write(`[Image id=${content.id} mediaType=${content.source?.mediaType}]`);
-          break;
-        }
-      }
-    };
-
-    const onTextBlockPrinted = (text: string) => {
-      const imageMatch = text.match(/<image id="([^"]+)"(?:\s+prompt="([^"]+)")?\s*\/>/);
-      if (imageMatch && onImage && images[imageMatch[1]]) {
-        onImage({
-          id: imageMatch[1],
-          description: imageMatch[2], // Extract prompt as description if present
-          source: images[imageMatch[1]],
-        });
-      }
-    };
-
-    if (stream) {
-      switch (event.type) {
-        case 'message_start': {
-          process.stdout.write(`${event.message.role.toUpperCase()}\n\n`);
-          for (const content of event.message.content) {
-            printContentBlock(content);
-          }
-          break;
-        }
-        case 'content_block_start': {
-          currentText = '';
-          printContentBlock(event.content);
-          break;
-        }
-        case 'content_block_delta': {
-          switch (event.delta.type) {
-            case 'text_delta': {
-              currentText += event.delta.text;
-              process.stdout.write(event.delta.text);
-              break;
-            }
-            case 'input_json_delta': {
-              process.stdout.write(event.delta.partial_json);
-              break;
-            }
-          }
-          break;
-        }
-        case 'content_block_stop': {
-          process.stdout.write('\n');
-          onTextBlockPrinted(currentText);
-          currentText = '';
-          break;
-        }
-        case 'message_delta': {
-          break;
-        }
-        case 'message_stop': {
-          process.stdout.write('\n\n');
-          break;
-        }
-      }
-    }
-
-    switch (event.type) {
-      case 'message': {
-        if (!stream || event.message.role !== 'assistant') {
-          process.stdout.write(`${event.message.role.toUpperCase()}\n\n`);
-          for (const block of event.message.content) {
-            switch (block.type) {
-              case 'text':
-                process.stdout.write(block.text + '\n');
-                onTextBlockPrinted(block.text);
-                break;
-              case 'tool_use':
-                process.stdout.write(`⚙️ [Tool Use] ${block.name}\n`);
-                process.stdout.write(`  ${JSON.stringify(block.input)}\n`);
-                break;
-              case 'tool_result':
-                if (block.isError) {
-                  process.stdout.write('❌ [Tool Error]\n');
-                  process.stdout.write(block.content + '\n');
-                } else {
-                  process.stdout.write('✅ [Tool Success]\n');
-                  process.stdout.write(block.content + '\n');
-                }
-            }
-            process.stdout.write('\n\n');
-          }
-        }
-        break;
-      }
-    }
-  };
-};