@dxos/assistant 0.8.2-main.fbd8ed0 → 0.8.2-staging.4d6ad0f

package/src/experimental/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/experimental/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, Organization, Project, Task } from '../../testing';
-
-test('Organization-Project-Task-Contact schema', async ({ expect }) => {
-  const jsonSchema = [Organization, Project, Task, Contact].map((schema) => toJsonSchema(schema));
-  const result = formatJsonSchemaForLLM(jsonSchema);
-  // log('result', { result });
-  expect(result).toHaveLength(8);
-});

package/src/experimental/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/experimental/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './conversation';
-export * from './cypher';

package/src/experimental/ner/ner.test.ts

@@ -1,163 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { pipeline } from '@xenova/transformers';
-import { beforeAll, describe, expect, test } from 'vitest';
-
-import { log } from '@dxos/log';
-import { createTestData } from '@dxos/schema/testing';
-
-type NerToken = {
-  entity: string;
-  score: number;
-  index: number;
-  word: string;
-  start: number | null;
-  end: number | null;
-};
-
-const createTokenGroups = (tokens: NerToken[]): NerToken[][] => {
-  const tokenGroups: NerToken[][] = [];
-
-  const canBeCombined = (prevToken: NerToken, currentToken: NerToken) => {
-    const [currentState, currentEntity] = currentToken.entity.split('-'); // B, I, O
-    const [prevState, prevEntity] = prevToken.entity.split('-'); // B, I, O
-
-    if (prevEntity !== currentEntity) {
-      return false;
-    }
-
-    if (prevState === 'O') {
-      return false;
-    }
-
-    if (currentState === 'I') {
-      return true;
-    }
-
-    if ((prevState === 'B' || prevState === 'I') && currentState === 'B') {
-      return currentToken.word.startsWith('#');
-    }
-
-    return false;
-  };
-
-  for (const token of tokens) {
-    if (tokenGroups.length === 0) {
-      tokenGroups.push([token]);
-      continue;
-    }
-
-    const lastTokenGroup = tokenGroups.at(-1)!;
-    if (canBeCombined(lastTokenGroup.at(-1)!, token)) {
-      lastTokenGroup.push(token);
-      continue;
-    }
-
-    tokenGroups.push([token]);
-  }
-
-  return tokenGroups;
-};
-
-const combineNerTokens = (group: NerToken[]): NerToken => {
-  const combinedToken: NerToken = {
-    entity: group.at(0)!.entity.split('-')[1],
-    score: group.reduce((acc, token) => acc + token.score, 0) / group.length,
-    index: group.at(0)!.index,
-    word: group.at(0)!.word,
-    start: group.at(0)!.start,
-    end: group.at(-1)!.end,
-  };
-
-  for (const token of group.slice(1)) {
-    if (token.word.startsWith('#')) {
-      combinedToken.word += token.word.replace(/^#+/, '');
-    } else {
-      combinedToken.word += ' ' + token.word;
-    }
-  }
-
-  return combinedToken;
-};
-
-describe.skip('Named Entity Recognition', () => {
-  let ner: any;
-
-  beforeAll(async () => {
-    // Initialize the NER pipeline
-    ner = await pipeline('ner', 'Xenova/bert-base-NER');
-  });
-
-  test.skip('should identify named entities in text', async () => {
-    const text = 'Elon Musk is the CEO of SpaceX and Tesla.';
-    const result = await ner(text);
-
-    // Verify the structure of the result
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.length).toBeGreaterThan(0);
-
-    log.info('ner', { result });
-
-    // Check for specific entities
-    const entities = result.map((item: any) => ({
-      text: item.word,
-      entity: item.entity,
-      score: item.score,
-    }));
-
-    // Verify Elon Musk is recognized as a person
-    const elonMusk = entities.find((e: any) => e.text === 'Elon' || e.text === 'Musk');
-    expect(elonMusk).toBeDefined();
-    expect(elonMusk?.entity).toMatch(/PER/);
-
-    // Verify SpaceX and Tesla are recognized as organizations
-    const companies = entities.filter((e: any) => e.text === 'SpaceX' || e.text === 'Tesla');
-    expect(companies.length).toBe(2);
-    companies.forEach((company: any) => {
-      expect(company.entity).toMatch(/ORG/);
-    });
-  });
-
-  test('own data', async () => {
-    const { transcriptWoflram, transcriptJosiah } = await createTestData();
-
-    const blocks = [...transcriptWoflram, ...transcriptJosiah].flatMap((message) =>
-      message.blocks.flatMap((block) => (block.type === 'transcription' ? [block.text] : [])),
-    );
-
-    for (const block of blocks) {
-      const result = await ner(block);
-      const combinedTokens = createTokenGroups(result).map(combineNerTokens);
-      log.info('ner', { text: block, result: combinedTokens });
-    }
-  });
-
-  test('more own data', async () => {
-    const { transcriptMessages } = await createTestData();
-
-    const blocks = transcriptMessages.flatMap((message) =>
-      message.blocks.flatMap((block) => (block.type === 'transcription' ? [block.text] : [])),
-    );
-
-    for (const block of blocks) {
-      const result = await ner(block);
-      const combinedTokens = createTokenGroups(result).map(combineNerTokens);
-      log.info('ner', { text: block, result: combinedTokens });
-    }
-  });
-
-  test('should handle empty text', async () => {
-    const result = await ner('');
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.length).toBe(0);
-  });
-
-  test('should handle text with no named entities', async () => {
-    const text = 'The weather is nice today.';
-    const result = await ner(text);
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.length).toBe(0);
-  });
-});

package/src/experimental/research/exa.ts

@@ -1,38 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-import Exa from 'exa-js';
-
-import { defineTool, ToolResult } from '@dxos/artifact';
-import { log } from '@dxos/log';
-
-type CreateExaToolOptions = {
-  apiKey: string;
-};
-
-export const createExaTool = ({ apiKey }: CreateExaToolOptions) => {
-  const exa = new Exa(apiKey);
-
-  return defineTool('search', {
-    name: 'web_search',
-    description: 'Search the web for information',
-    schema: Schema.Struct({
-      query: Schema.String.annotations({ description: 'The query to search for' }),
-    }),
-    execute: async ({ query }) => {
-      const context = await exa.searchAndContents(query, {
-        type: 'auto',
-        text: {
-          maxCharacters: 3_000,
-        },
-        livecrawl: 'always',
-      });
-
-      log.info('exa search', { query, costDollars: context.costDollars });
-
-      return ToolResult.Success(context);
-    },
-  });
-};

package/src/experimental/research/instructions.tpl

@@ -1,64 +0,0 @@
-You are an expert research agent. Your job is to assist a user by conducting in-depth research using real-time web search.
-You output the results in a structured format matching the schema provided.
-
-You are equipped with the ability to:
-
-- Generate precise and effective search queries.
-- Request web pages by query (through a `web_search` tool).
-- Read the full content of retrieved pages.
-- Synthesize accurate, clear, and structured answers using reliable information from the retrieved content.
-
-Always follow these principles:
-
-- Relevance First: Only return facts that are supported by content in the retrieved web pages. Never fabricate or guess information.
-- Summarize, Don't Copy: Synthesize and rephrase content in your own words. Quote only when necessary.
-- Multiple Sources: Cross-reference at least 2 sources before drawing conclusions, unless the information is directly stated and non-controversial.
-- Transparency: Mention which sources were used and explain how you arrived at your conclusions.
-- Accuracy Over Brevity: Prefer detailed, technically accurate explanations over shallow summaries.
-- If uncertain, say so. It's better to admit uncertainty than to mislead.
-- Pick the most concrete schema types for the extracted information.
-- Fill the schema fields as completely as possible with the information you are confident about, do not fill the fields that you are not confident about.
-- When outputting results, you can add extra data that isn't directly related to the user's question but fits the schema.
-
-The user may ask for:
-
-- Technical explanations
-- Literature reviews
-- Comparisons
-- Emerging trends
-- Implementation strategies
-
-Begin by interpreting the user's request, then:
-
-Break it into sub-questions (if applicable).
-
-For each sub-question, generate a clear, concise web search query.
-
-Use `web_search`(query) to retrieve information.
-
-Extract and synthesize relevant answers.
-
-Output should include:
-
-- A clear, structured answer to the user’s question.
-- A citation list or link list of the sources used.
-
-Optionally, follow-up suggestions or questions for deeper inquiry.
-
-Here's your operational instructions:
-
-1. Analyze user's request and identify key topics to search for (3 or more). Print them out.
-2. Perform a web search for each topic.
-3. Read and analyze the results, cross reference information from multiple sources, in case of conflict, represent the information as a range of possible values.
-4. Create a list of follow-up topics to research. Print them out.
-5. Perform a web search for each follow-up topic.
-6. Read and analyze the results, cross reference information from multiple sources, in case of conflict, represent the information as a range of possible values.
-9. Create a clear, structured answer to the user's question.
-10. Create a citation list or link list of the sources used.
-11. Select the most concrete schema types for the extracted information. You can use multiple different schema types. Print your decision and reasoning.
-12. Submit the results using the specific schema.
-
-
-
-
-