@dxos/assistant 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/src/extraction/extraction-ner-function/extraction-ner-function.test.ts

@@ -1,116 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { beforeAll, describe, test } from 'vitest';
-
-import { type Database } from '@dxos/echo';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
-import { FunctionExecutor, ServiceContainer } from '@dxos/functions-runtime';
-import { log } from '@dxos/log';
-import { TestSchema } from '@dxos/schema/testing';
-import { type Message, Organization, Person } from '@dxos/types';
-import { createTestData } from '@dxos/types/testing';
-import { range } from '@dxos/util';
-
-import { processTranscriptMessage } from '../extraction';
-
-import { extractionNerFunction } from './extraction-ner-function';
-
-describe.skip('NER EntityExtraction', () => {
-  let builder: EchoTestBuilder;
-  let db: Database.Database;
-  let executor: FunctionExecutor;
-  let testData: {
-    transcriptJosiah: Message.Message[];
-    transcriptWoflram: Message.Message[];
-    transcriptMessages: Message.Message[];
-    documents: TestSchema.DocumentType[];
-    contacts: Record<string, Person.Person>;
-    organizations: Record<string, Organization.Organization>;
-  };
-
-  const TYPES = [Organization.Organization, Person.Person, TestSchema.Person, TestSchema.DocumentType];
-
-  beforeAll(async () => {
-    // TODO(dmaretskyi): Helper to scaffold this from a config.
-    builder = await new EchoTestBuilder().open();
-    const { db: db1 } = await builder.createDatabase({ indexing: { vector: true } });
-    db = db1;
-    await db.graph.schemaRegistry.register(TYPES);
-    const data = createTestData();
-    testData = {
-      transcriptJosiah: data.transcriptJosiah,
-      transcriptWoflram: data.transcriptWoflram,
-      transcriptMessages: data.transcriptMessages,
-      documents: data.documents.map((document) => db.add(document)),
-      contacts: Object.fromEntries(Object.entries(data.contacts).map(([key, value]) => [key, db.add(value)])),
-      organizations: Object.fromEntries(Object.entries(data.organizations).map(([key, value]) => [key, db.add(value)])),
-    };
-
-    await db.flush();
-    executor = new FunctionExecutor(
-      new ServiceContainer().setServices({
-        database: { db },
-      }),
-    );
-  }, 30_000);
-
-  test('should process a transcript block', async () => {
-    const { transcriptMessages, documents, contacts } = testData;
-    log.info('context', { documents, contacts });
-
-    for (const message of transcriptMessages) {
-      log.info('input', message);
-      const { message: enhancedMessage } = await processTranscriptMessage({
-        input: {
-          message,
-          objects: [...documents, ...Object.values(contacts)],
-        },
-        function: extractionNerFunction,
-        executor,
-      });
-      log.info('output', enhancedMessage);
-    }
-  });
-
-  test('computational irreducibility', async () => {
-    const { transcriptWoflram, documents, contacts } = testData;
-    log.info('context', { documents, contacts });
-    const message = transcriptWoflram[0];
-    log.info('input', message);
-
-    await Promise.all(
-      range(10).map(async () => {
-        const { message: enhancedMessage, timeElapsed } = await processTranscriptMessage({
-          input: {
-            message,
-            objects: [...documents, ...Object.values(contacts)],
-          },
-          function: extractionNerFunction,
-          executor,
-        });
-        log.info('output', { message: enhancedMessage.blocks[0], timeElapsed });
-      }),
-    );
-  });
-
-  test('org and document linking', async () => {
-    const { transcriptJosiah, documents, contacts, organizations } = testData;
-    log.info('context', { contacts, organizations, documents });
-
-    for (const message of transcriptJosiah) {
-      log.info('input', message);
-
-      const { message: enhancedMessage } = await processTranscriptMessage({
-        input: {
-          message,
-          objects: [...documents, ...Object.values(contacts), ...Object.values(organizations)],
-        },
-        function: extractionNerFunction,
-        executor,
-      });
-      log.info('output', enhancedMessage);
-    }
-  });
-});

package/src/extraction/extraction-ner-function/extraction-ner-function.ts

@@ -1,56 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineFunction } from '@dxos/functions';
-
-import { ExtractionInput, ExtractionOutput } from '../extraction';
-
-/**
- * Named Entity Recognition model
- */
-// TODO(mykola): Make it use vector index to query objects and not pass objects as input.
-export const extractionNerFunction = defineFunction({
-  key: 'dxos.org/function/extraction/extract-entities',
-  name: 'Extract Entities',
-  description: 'Extracts named entities from a text',
-  inputSchema: ExtractionInput,
-  outputSchema: ExtractionOutput,
-  handler: async ({ data: { message, options }, context }) => {
-    throw new Error('not implemented');
-    // log.info('input', { message, options });
-    // const startTime = performance.now();
-    // const { db } = context.getService(Database.Service);
-    // const { extractFullEntities } = await import('./named-entity-recognition');
-
-    // const entitiesPromise = Promise.all(
-    //   message.blocks.map(async (block) => {
-    //     invariant(block._tag === 'transcript' || block._tag === 'text');
-    //     return extractFullEntities(block.text);
-    //   }),
-    // ).then((entities) => entities.flat());
-    // const entities = options?.timeout ? await asyncTimeout(entitiesPromise, options.timeout) : await entitiesPromise;
-
-    // log.info('entities', { entities });
-    // const quoteReferences = await findQuotes(
-    //   entities.map((entity) => entity.word),
-    //   db,
-    // );
-
-    // const blocksWithReferences = message.blocks.map((block) => {
-    //   invariant(block._tag === 'transcript' || block._tag === 'text');
-    //   return { ...block, text: insertReferences(block._tag, quoteReferences) };
-    // });
-
-    // const messageWithReferences = create(Message.Message, {
-    //   ...message,
-    //   blocks: blocksWithReferences,
-    // });
-
-    // log.info('output', { messageWithReferences });
-    // return {
-    //   message: messageWithReferences,
-    //   timeElapsed: performance.now() - startTime,
-    // };
-  },
-});

package/src/session/GenericToolkit.ts

@@ -1,131 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import type * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Pipeable from 'effect/Pipeable';
-import type * as Schema from 'effect/Schema';
-import type * as SchemaAST from 'effect/SchemaAST';
-
-/**
- * Unique identifier for generic toolkit instances.
- */
-export const TypeId = '~@dxos/assistant/GenericToolkit';
-
-/**
- * Type-level representation of the generic toolkit identifier.
- */
-export type TypeId = typeof TypeId;
-
-/**
- * Type-safe way to define toolkits where we don't know specific types of tools,
- * and we want to bundle definition and handlers together.
- *
- * Usefull for plugin-based systems, where tools are dynamically added.
- *
- * @param TR requirements type to the tool invocation.
- * @param E failure type to the handlers layer.
- * @param R requirements type to the handlers layer.
- */
-export interface GenericToolkit<TR = never, E = never, R = never> extends Pipeable.Pipeable {
-  readonly [TypeId]: TypeId;
-
-  /**
-   * Toolkit definition.
-   */
-  readonly toolkit: Toolkit.Toolkit<GenericTools<TR>>;
-
-  /**
-   * Handlers layer.
-   */
-  readonly layer: Layer.Layer<unknown, E, R>;
-
-  /**
-   * Handlers effect.
-   */
-  readonly handlers: Effect.Effect<Toolkit.WithHandler<GenericTools<TR>>, E, R>;
-}
-
-/**
- * Generic constraint.
- *
- * NOTE: Only use in place of `T extends PortableToolkit.Any`. Not suitable for standalone use.
- */
-export interface Any {
-  readonly [TypeId]: TypeId;
-  readonly toolkit: Toolkit.Toolkit<any>;
-  readonly layer: Layer.Layer<unknown, any, any>;
-}
-
-export type InvocationRequirements<T extends Any> = T extends GenericToolkit<infer TR, infer _E, infer _R> ? TR : never;
-export type Failure<T extends Any> = T extends GenericToolkit<infer _TR, infer E, infer _R> ? E : never;
-export type Requirements<T extends Any> = T extends GenericToolkit<infer _TR, infer _E, infer R> ? R : never;
-
-/**
- * Creates a portable toolkit from toolkit definition and handlers layer.
- */
-export const make = <Tools extends Record<string, Tool.Any>, E, R>(
-  toolkit: Toolkit.Toolkit<Tools>,
-  layer: Layer.Layer<Tool.HandlersFor<Tools>, E, R>,
-): GenericToolkit<E, R> => {
-  return {
-    [TypeId]: TypeId,
-    toolkit: toolkit as any,
-    layer: layer as any,
-    handlers: toolkit.pipe(Effect.provide(layer)) as any,
-    pipe() {
-      // eslint-disable-next-line prefer-rest-params
-      return Pipeable.pipeArguments(this, arguments);
-    },
-  };
-};
-
-/**
- * Merges multiple portable toolkits into a single portable toolkit.
- */
-export const merge = <const Toolkits extends ReadonlyArray<Any>>(
-  /**
-   * The toolkits to merge together.
-   */
-  ...toolkits: Toolkits
-): GenericToolkit<
-  InvocationRequirements<Toolkits[number]>,
-  Failure<Toolkits[number]>,
-  Requirements<Toolkits[number]>
-> => {
-  return make(
-    Toolkit.merge(...toolkits.map((t) => t.toolkit)),
-    Layer.mergeAll(...(toolkits.map((t) => t.layer) as any)),
-  ) as any;
-};
-
-/**
- * Generic tools type where we cannot statically enumerate individual tools.
- */
-export type GenericTools<R = never> = Record<
-  string,
-  Tool.Tool<
-    string,
-    {
-      readonly parameters: AnyStructSchemaNoContext;
-      readonly success: Schema.Schema.AnyNoContext;
-      readonly failure: typeof Schema.Never;
-      readonly failureMode: Tool.FailureMode;
-    },
-    R
-  >
->;
-
-export interface AnyStructSchemaNoContext extends Pipeable.Pipeable {
-  readonly [Schema.TypeId]: any;
-  readonly make: any;
-  readonly Type: any;
-  readonly Encoded: any;
-  readonly Context: never;
-  readonly ast: SchemaAST.AST;
-  readonly fields: Schema.Struct.Fields;
-  readonly annotations: any;
-}