@dxos/assistant 0.8.2-main.5885341 → 0.8.2-main.600d381

package/src/{conversation → experimental/conversation}/types.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
 import { type Message, type MessageContentBlock } from '@dxos/artifact';
 import { toJsonSchema, JsonSchemaType, ObjectId } from '@dxos/echo-schema';
@@ -17,11 +17,11 @@ export const createUserMessage = (text: string): Message => ({
 /**
  * @deprecated Use {@link LLMTool} instead.
  */
-export const ToolDefinition = S.Struct({
-  name: S.String,
-  description: S.String,
+export const ToolDefinition = Schema.Struct({
+  name: Schema.String,
+  description: Schema.String,
   parameters: JsonSchemaType,
-  execute: S.Any,
+  execute: Schema.Any,
 });
 
 /**
@@ -83,14 +83,14 @@ export const ToolResult = Object.freeze({
   Break: (result: unknown): ToolResult => ({ kind: 'break', result }),
 });
 
-export type DefineToolParams<Params extends S.Schema.AnyNoContext> = {
+export type DefineToolParams<Params extends Schema.Schema.AnyNoContext> = {
   name: string;
   description: string;
   schema: Params;
-  execute: (params: S.Schema.Type<Params>, context: ToolExecutionContext) => Promise<ToolResult>;
+  execute: (params: Schema.Schema.Type<Params>, context: ToolExecutionContext) => Promise<ToolResult>;
 };
 
-export const defineTool = <Params extends S.Schema.AnyNoContext>({
+export const defineTool = <Params extends Schema.Schema.AnyNoContext>({
   name,
   description,
   schema,
@@ -101,7 +101,7 @@ export const defineTool = <Params extends S.Schema.AnyNoContext>({
     description,
     parameters: toFunctionParameterSchema(schema),
     execute: (params, context) => {
-      const sanitized = S.decodeSync(schema)(params);
+      const sanitized = Schema.decodeSync(schema)(params);
       return execute(sanitized, context);
     },
   };
@@ -110,7 +110,7 @@ export const defineTool = <Params extends S.Schema.AnyNoContext>({
 /**
  * Adapts schems to be able to pass to AI providers.
  */
-const toFunctionParameterSchema = (schema: S.Schema.All) => {
+const toFunctionParameterSchema = (schema: Schema.Schema.All) => {
   const jsonSchema = toJsonSchema(schema);
   log('tool schema', { jsonSchema });
   delete jsonSchema.anyOf;

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

@@ -2,9 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
+import { type Schema } from 'effect';
+
 import { raise } from '@dxos/debug';
-import { type EchoDatabase, Filter, type ReactiveEchoObject } from '@dxos/echo-db';
-import { getSchema, getSchemaTypename, type S, StoredSchema, toJsonSchema } from '@dxos/echo-schema';
+import { type EchoDatabase, Filter, type AnyLiveObject } from '@dxos/echo-db';
+import { getSchema, getSchemaTypename, StoredSchema, toJsonSchema } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
 import type { DataSource, Node, Relationship } from './query-executor';
@@ -62,7 +64,7 @@ export class EchoDataSource implements DataSource {
     ).flat();
   }
 
-  private async _getAllSchema(): Promise<S.Schema.AnyNoContext[]> {
+  private async _getAllSchema(): Promise<Schema.Schema.AnyNoContext[]> {
     return [
       ...(await this._db.schemaRegistry.query().run()),
       // TODO(dmaretskyi): Remove once we can serialize recursive schema.
@@ -70,7 +72,7 @@ export class EchoDataSource implements DataSource {
     ].filter((schema) => getSchemaTypename(schema) !== StoredSchema.typename);
   }
 
-  private _objectToNode(object: ReactiveEchoObject<any>): Node {
+  private _objectToNode(object: AnyLiveObject<any>): Node {
     const { id, ...properties } = object;
     return {
       id,
@@ -80,7 +82,7 @@ export class EchoDataSource implements DataSource {
     };
   }
 
-  private async _projectRefRelationship(object: ReactiveEchoObject<any>, prop: string): Promise<Relationship[]> {
+  private async _projectRefRelationship(object: AnyLiveObject<any>, prop: string): Promise<Relationship[]> {
     if (!object[prop]) {
       return [];
     }

package/src/{cypher → experimental/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();

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

@@ -7,7 +7,7 @@ import { test } from 'vitest';
 import { toJsonSchema } from '@dxos/echo-schema';
 
 import { formatJsonSchemaForLLM } from './schema';
-import { Contact, Organization, Project, Task } from '../testing';
+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));

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

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

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

@@ -0,0 +1,163 @@
+//
+// 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

@@ -0,0 +1,38 @@
+//
+// 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

@@ -0,0 +1,64 @@
+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.
+
+
+
+
+

package/src/experimental/research/research.test.ts

@@ -0,0 +1,263 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Option, Schema, SchemaAST } from 'effect';
+import { describe, test } from 'vitest';
+
+import { structuredOutputParser } from '@dxos/artifact';
+import { isEncodedReference } from '@dxos/echo-protocol';
+import { create, getSchemaDXN, ObjectId, ReferenceAnnotationId } from '@dxos/echo-schema';
+import { mapAst } from '@dxos/effect';
+import { log } from '@dxos/log';
+import { DataType } from '@dxos/schema';
+import { deepMapValues } from '@dxos/util';
+
+import { createExaTool } from './exa';
+import INSTRUCTIONS from './instructions.tpl?raw';
+import { AIServiceEdgeClient, OllamaClient } from '../../ai-service';
+import { AISession } from '../../session';
+import { AI_SERVICE_ENDPOINT, ConsolePrinter } from '../../testing';
+
+const EXA_API_KEY = '9c7e17ff-0c85-4cd5-827a-8b489f139e03';
+const REMOTE_AI = true;
+
+const aiService = REMOTE_AI
+  ? new AIServiceEdgeClient({
+      endpoint: AI_SERVICE_ENDPOINT.REMOTE,
+    })
+  : new OllamaClient({
+      overrides: {
+        model: 'llama3.1:8b',
+      },
+    });
+
+const TYPES = [DataType.Event, DataType.Organization, DataType.Person, DataType.Project, DataType.Task, DataType.Text];
+
+describe.skip('Research', () => {
+  test('should generate a research report', { timeout: 1000000 }, async () => {
+    const searchTool = createExaTool({ apiKey: EXA_API_KEY });
+
+    const session = new AISession({ operationModel: 'configured' });
+
+    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));
+
+    // TODO(dmaretskyi): Consider adding this pattern as the "Graph" output mode for the session.
+    const outputSchema = createExtractionSchema(TYPES);
+    const result = await session.runStructured(outputSchema, {
+      client: aiService,
+      systemPrompt: INSTRUCTIONS,
+      artifacts: [],
+      tools: [searchTool],
+      generationOptions: {
+        model: '@anthropic/claude-3-5-sonnet-20241022',
+      },
+      history: [],
+      prompt: 'Find projects that are in the space of AI and personal knowledge management',
+    });
+    const data = sanitizeObjects(TYPES, result as any);
+
+    log.info('result', { data });
+  });
+});
+
+describe.skip('misc', () => {
+  test('createExtractionSchema', () => {
+    const schema = createExtractionSchema(TYPES);
+    log.info('schema', { schema });
+  });
+
+  test('extract schema json schema', () => {
+    const schema = createExtractionSchema(TYPES);
+    const parser = structuredOutputParser(schema);
+    log.info('schema', { json: parser.tool.parameters });
+  });
+
+  test('getSanitizedSchemaName', () => {
+    const names = TYPES.map(getSanitizedSchemaName);
+    log.info('names', { names });
+  });
+
+  test('getTypeAnnotation', () => {
+    for (const schema of TYPES) {
+      const dxn = getSchemaDXN(schema);
+      log.info('dxn', { schema, dxn });
+    }
+  });
+
+  test('sanitizeObjects', () => {
+    const TEST_DATA = {
+      objects_dxos_org_type_Project: [
+        {
+          name: 'Reor',
+          description:
+            'A private & local AI personal knowledge management app focused on high entropy thinkers. Features include Q&A chat with full context of notes, automatic connection of ideas, semantic search, and local-first architecture with LLMs and vector databases.',
+          image: 'https://reorhomepage-2-cwy0zagzg-reor-team.vercel.app/opengraph-image.jpg',
+          id: 'reor-project-01',
+        },
+        {
+          name: 'Personal AI',
+          description:
+            'A platform for creating personal AI models with unlimited memory capabilities. Features include memory stacking, data uploads, and personalized language models that can be trained on individual knowledge bases.',
+          image: 'https://cdn.prod.website-files.com/5ff65c460ce39f5ec5681c6a/663d12aab1b425e1ad40d3a6_Memory-min.jpg',
+          id: 'personal-ai-project-01',
+        },
+        {
+          name: 'IKI AI',
+          description:
+            'An AI-native workspace for research, strategy, and creative work. Offers features like AI summarization, content analysis, and team knowledge sharing capabilities.',
+          image: 'https://framerusercontent.com/assets/cI6Uo7x4q0W3uxzOt2preXjv6aE.jpg',
+          id: 'iki-ai-project-01',
+        },
+        {
+          name: 'Forethink',
+          description:
+            'A privacy-first, on-device AI system that proactively links current activities to relevant knowledge. Features real-time learning across teams and local data processing.',
+          image: 'https://framerusercontent.com/assets/XDhN6tICnlElB134JWcWXOuXc.jpeg',
+          id: 'forethink-project-01',
+        },
+        {
+          name: 'Amurex',
+          description:
+            'An invisible AI companion that handles tasks, remembers important information, and supports workflow. Includes features for meeting automation, email categorization, and cross-platform search.',
+          image: 'https://amurex.ai/ogimages/og_amurex.jpg',
+          id: 'amurex-project-01',
+        },
+      ],
+      objects_dxos_org_type_Organization: [
+        {
+          name: 'Reor',
+          description:
+            'A technology company focused on developing local-first AI solutions for personal knowledge management.',
+          status: 'active',
+          website: 'https://www.reorproject.org',
+          id: 'reor-org-01',
+        },
+        {
+          name: 'Personal.ai',
+          description: 'A company specializing in personal AI development and memory management solutions.',
+          status: 'active',
+          website: 'https://www.personal.ai',
+          id: 'personal-ai-org-01',
+        },
+        {
+          name: 'IKI AI',
+          description: 'A startup backed by 500 Global, developing AI-native workspaces for knowledge workers.',
+          status: 'active',
+          website: 'https://iki.ai',
+          id: 'iki-ai-org-01',
+        },
+        {
+          name: 'Forethink.ai',
+          description:
+            'A company focused on privacy-first AI solutions for knowledge management and team collaboration.',
+          status: 'active',
+          website: 'https://www.forethink.ai',
+          id: 'forethink-org-01',
+        },
+      ],
+      objects_dxos_org_type_Text: [
+        {
+          content:
+            'Current trends in AI-powered Personal Knowledge Management (PKM) systems include: 1) Shift from document-based to graph-based systems for better knowledge connection, 2) Integration of large language models for enhanced content understanding and retrieval, 3) Focus on privacy-first and local-first architectures, 4) Emphasis on automatic knowledge connection and discovery, 5) Implementation of semantic search capabilities.',
+          id: 'pkm-trends-text-01',
+        },
+        {
+          content:
+            'Key features emerging across modern PKM tools include: automated content categorization, semantic analysis and linking, personalized AI models that learn from user interaction, integration with existing workflows, and robust privacy protection. These tools are increasingly focusing on proactive knowledge surfacing rather than passive storage.',
+          id: 'pkm-features-text-01',
+        },
+      ],
+    };
+
+    const data = sanitizeObjects(TYPES, TEST_DATA);
+    log.info('data', { data });
+  });
+});
+
+const createExtractionSchema = (types: Schema.Schema.AnyNoContext[]) => {
+  return Schema.Struct({
+    ...Object.fromEntries(
+      types.map(preprocessSchema).map((schema, index) => [
+        `objects_${getSanitizedSchemaName(types[index])}`,
+        Schema.optional(Schema.Array(schema)).annotations({
+          description: `The objects to answer the query of type: ${getSchemaDXN(types[index])?.asTypeDXN()!.type}`,
+        }),
+      ]),
+    ),
+  });
+};
+
+const getSanitizedSchemaName = (schema: Schema.Schema.AnyNoContext) => {
+  return getSchemaDXN(schema)!
+    .asTypeDXN()!
+    .type.replaceAll(/[^a-zA-Z0-9]+/g, '_');
+};
+
+const sanitizeObjects = (types: Schema.Schema.AnyNoContext[], data: Record<string, readonly unknown[]>) => {
+  const entries = types
+    .map(
+      (type) =>
+        data[`objects_${getSanitizedSchemaName(type)}`]?.map((object: any) => ({
+          data: object,
+          schema: type,
+        })) ?? [],
+    )
+    .flat();
+
+  const idMap = new Map<string, string>();
+
+  return entries
+    .map((entry) => {
+      idMap.set(entry.data.id, ObjectId.random());
+      entry.data.id = idMap.get(entry.data.id);
+      return entry;
+    })
+    .map((entry) => {
+      const data = deepMapValues(entry.data, (value, recurse) => {
+        if (isEncodedReference(value)) {
+          const ref = value['/'];
+          if (idMap.has(ref)) {
+            // TODO(dmaretskyi): Whats the best way to represent a local url.
+            return { '/': `dxn:echo:@:${idMap.get(ref)}` };
+          } else {
+            // Search URIs?
+            return { '/': `search:?q=${encodeURIComponent(ref)}` };
+          }
+        }
+
+        return recurse(value);
+      });
+
+      return create(entry.schema, data);
+    });
+};
+
+const SoftRef = Schema.Struct({
+  '/': Schema.String,
+}).annotations({
+  description: 'Reference to another object.',
+});
+
+const preprocessSchema = (schema: Schema.Schema.AnyNoContext) => {
+  const go = (ast: SchemaAST.AST): SchemaAST.AST => {
+    if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome)) {
+      return SoftRef.ast;
+    }
+
+    return mapAst(ast, go);
+  };
+
+  const processed = Schema.make<any, any, never>(mapAst(schema.ast, go));
+  return Schema.extend(
+    processed.pipe(Schema.omit('id')),
+    Schema.Struct({
+      id: Schema.String.annotations({
+        description: 'The id of this object. Come up with a unique id based on your judgement.',
+      }),
+    }),
+  );
+};

package/src/index.ts

@@ -3,6 +3,7 @@
 //
 
 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

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