@dxos/assistant 0.8.4-main.b97322e → 0.8.4-main.bc2380dfbc

package/src/research/research.test.ts

@@ -1,190 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { AnthropicClient } from '@effect/ai-anthropic';
-import { FetchHttpClient } from '@effect/platform';
-import { Config, Layer, ManagedRuntime } from 'effect';
-import { inspect } from 'node:util';
-import { afterAll, beforeAll, describe, test } from 'vitest';
-
-import { AiService, AiServiceRouter, structuredOutputParser } from '@dxos/ai';
-import { EXA_API_KEY, tapHttpErrors } from '@dxos/ai/testing';
-import { Obj } from '@dxos/echo';
-import { type EchoDatabase } from '@dxos/echo-db';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
-import { getSchemaDXN } from '@dxos/echo-schema';
-import { ConfiguredCredentialsService, FunctionExecutor, ServiceContainer, TracingService } from '@dxos/functions';
-import { DataType, DataTypes } from '@dxos/schema';
-
-import { createExtractionSchema, getSanitizedSchemaName } from './graph';
-import { researchFn } from './research';
-
-const MOCK_SEARCH = false;
-
-const AnthropicLayer = AnthropicClient.layerConfig({
-  apiKey: Config.redacted('ANTHROPIC_API_KEY'),
-  transformClient: tapHttpErrors,
-});
-
-const AiServiceLayer = AiServiceRouter.AiServiceRouter.pipe(
-  Layer.provide(AnthropicLayer),
-  Layer.provide(FetchHttpClient.layer),
-);
-
-describe.skip('Research', () => {
-  let runtime: ManagedRuntime.ManagedRuntime<AiService, any>;
-  let builder: EchoTestBuilder;
-  let db: EchoDatabase;
-  let executor: FunctionExecutor;
-
-  beforeAll(async () => {
-    runtime = ManagedRuntime.make(AiServiceLayer);
-
-    // TODO(dmaretskyi): Helper to scaffold this from a config.
-    builder = await new EchoTestBuilder().open();
-
-    db = (await builder.createDatabase({ indexing: { vector: true } })).db;
-
-    executor = new FunctionExecutor(
-      new ServiceContainer().setServices({
-        ai: await runtime.runPromise(AiService),
-        credentials: new ConfiguredCredentialsService([{ service: 'exa.ai', apiKey: EXA_API_KEY }]),
-        database: { db },
-        tracing: TracingService.console,
-      }),
-    );
-  });
-
-  afterAll(async () => {
-    await runtime.dispose();
-  });
-
-  // TODO(dmaretskyi): Refactor using effect.
-  test.only('should generate a research report', { timeout: 300_000 }, async () => {
-    db.add(Obj.make(DataType.Organization, { name: 'Notion', website: 'https://www.notion.com' }));
-    await db.flush({ indexes: true });
-
-    const result = await executor.invoke(researchFn, {
-      query: 'Who are the founders of Notion?',
-      mockSearch: MOCK_SEARCH,
-    });
-
-    console.log(inspect(result, { depth: null, colors: true }));
-    console.log(JSON.stringify(result, null, 2));
-  });
-});
-
-describe('misc', () => {
-  test('createExtractionSchema', () => {
-    const _schema = createExtractionSchema(DataTypes);
-    // log.info('schema', { schema });
-  });
-
-  test('extract schema json schema', () => {
-    const schema = createExtractionSchema(DataTypes);
-    const _parser = structuredOutputParser(schema);
-    // log.info('schema', { json: parser.tool.parameters });
-  });
-
-  test('getSanitizedSchemaName', () => {
-    const _names = DataTypes.map(getSanitizedSchemaName);
-    // log.info('names', { names });
-  });
-
-  test('getTypeAnnotation', () => {
-    for (const schema of DataTypes) {
-      const _dxn = getSchemaDXN(schema);
-      // log.info('dxn', { schema, dxn });
-    }
-  });
-
-  test.skip('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 = await sanitizeObjects(TYPES, TEST_DATA, db);
-    // log.info('data', { data });
-  });
-});

package/src/research/research.ts

@@ -1,87 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// TODO(burdon): Fix.
-// @ts-nocheck
-
-import { AiToolkit } from '@effect/ai';
-import { Effect, Layer, Schema } from 'effect';
-
-import { AiService, ConsolePrinter } from '@dxos/ai';
-import { defineFunction, TracingService } from '@dxos/functions';
-import { log } from '@dxos/log';
-import { DataTypes } from '@dxos/schema';
-
-import { ExaToolkit, LiveExaHandler, MockExaHandler } from './exa';
-import { LocalSearchHandler, LocalSearchToolkit, makeGraphWriterHandler, makeGraphWriterToolkit } from './graph';
-// TODO(dmaretskyi): Vite build bug with instruction files with the same filename getting mixed-up
-import PROMPT from './instructions-research.tpl?raw';
-import { AiSession } from '../session';
-
-/**
- * Exec external service and return the results as a Subgraph.
- */
-// TODO(burdon): Rename.
-export const researchFn = defineFunction({
-  description: 'Research the web for information',
-  inputSchema: Schema.Struct({
-    query: Schema.String.annotations({
-      description: 'The query to search for.',
-    }),
-
-    // TOOD(burdon): Move to context.
-    mockSearch: Schema.optional(Schema.Boolean).annotations({
-      description: 'Whether to use the mock search tool.',
-      default: false,
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    result: Schema.Unknown,
-  }),
-  handler: Effect.fnUntraced(
-    function* ({ data: { query, mockSearch } }) {
-      yield* TracingService.emitStatus({ message: 'Researching...' });
-
-      const graphWriteToolkit = makeGraphWriterToolkit({ schema: DataTypes });
-      const toolkit = yield* AiToolkit.merge(ExaToolkit, LocalSearchToolkit, graphWriteToolkit).pipe(
-        Effect.provide(
-          Layer.mergeAll(
-            mockSearch ? MockExaHandler : LiveExaHandler,
-            LocalSearchHandler,
-            makeGraphWriterHandler(graphWriteToolkit),
-          ),
-        ),
-      );
-
-      const printer = new ConsolePrinter();
-      const session = new AiSession();
-      session.message.on((message) => printer.printMessage(message));
-      session.userMessage.on((message) => printer.printMessage(message));
-      session.block.on((block) => printer.printContentBlock(block));
-      session.streamEvent.on((event) => log('stream', { event }));
-
-      // TODO(dmaretskyi): Consider adding this pattern as the "Graph" output mode for the session.
-      const result = yield* session.run({
-        prompt: query,
-        history: [],
-        systemPrompt: PROMPT,
-        toolkit,
-      });
-
-      return {
-        result,
-      };
-
-      // queues.contextQueue!.append(data);
-
-      // return {
-      //   result: `
-      //   The research results are placed in the following objects:
-      //     ${data.map((object, id) => `[obj_${id}][dxn:echo:@:${object.id}]`).join('\n')}
-      //   `,
-      // };
-    },
-    Effect.provide(AiService.model('@anthropic/claude-3-5-sonnet-20241022')),
-  ),
-});

package/src/session/__snapshots__/session.test.ts.snap

@@ -1,32 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`AiSession > no tools 1`] = `
-[
-  {
-    "blocks": ReactiveArray [
-      {
-        "_tag": "text",
-        "text": "Hello world!",
-      },
-    ],
-    "created": "Sun, 20 Jul 2025 10:54:08 GMT",
-    "id": "01K0KQGFTFV3GBKGEWZW67K8HK",
-    "sender": {
-      "role": "user",
-    },
-  },
-  {
-    "blocks": ReactiveArray [
-      {
-        "_tag": "text",
-        "text": "Hi there! How can I help you today?",
-      },
-    ],
-    "created": "2025-07-20T10:54:10.801Z",
-    "id": "01K0KQGHVHJ37D4YG45WG090WV",
-    "sender": {
-      "role": "assistant",
-    },
-  },
-]
-`;

package/src/session/session.test.ts

@@ -1,310 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { AiTool, AiToolkit } from '@effect/ai';
-import { describe, it } from '@effect/vitest';
-import { Effect, Layer, Schema } from 'effect';
-
-import { AiService, ToolExecutionService, ToolResolverService } from '@dxos/ai';
-import { AiServiceTestingPreset } from '@dxos/ai/testing';
-import { Obj, Type } from '@dxos/echo';
-import { log } from '@dxos/log';
-
-import { AiSession } from './session';
-
-// Define a calendar event artifact schema.
-const CalendarEventSchema = Schema.Struct({
-  title: Schema.String,
-  startTime: Schema.String,
-  endTime: Schema.String,
-  description: Schema.String,
-}).pipe(
-  Type.Obj({
-    typename: 'example.com/type/CalendarEvent',
-    version: '0.1.0',
-  }),
-);
-
-type CalendarEvent = Schema.Schema.Type<typeof CalendarEventSchema>;
-
-class TestToolkit extends AiToolkit.make(
-  AiTool.make('Calculator', {
-    description: 'Basic calculator tool',
-    parameters: {
-      input: Schema.String.annotations({
-        description: 'The calculation to perform.',
-      }),
-    },
-    success: Schema.Struct({
-      result: Schema.Number,
-    }),
-    failure: Schema.Never,
-  }),
-) {}
-
-// Tool handlers.
-const toolkitLayer = TestToolkit.toLayer({
-  Calculator: ({ input }) =>
-    Effect.gen(function* () {
-      const result = (() => {
-        // Restrict to basic arithmetic operations for safety.
-        const sanitizedInput = input.replace(/[^0-9+\-*/().\s]/g, '');
-        log.info('calculate', { sanitizedInput });
-
-        // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval
-        return Function(`"use strict"; return (${sanitizedInput})`)();
-      })();
-
-      return { result };
-    }),
-});
-
-describe.runIf(process.env.DX_RUN_SLOW_TESTS)('AiSession', () => {
-  it.effect(
-    'no tools',
-    Effect.fn(
-      function* ({ expect }) {
-        const session = new AiSession({ operationModel: 'configured' });
-
-        const response = yield* session.run({
-          prompt: 'Hello world!',
-          history: [],
-        });
-        log.info('response', { response });
-      },
-      Effect.provide(
-        AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
-          Layer.provideMerge(ToolResolverService.layerEmpty),
-          Layer.provideMerge(ToolExecutionService.layerEmpty),
-          Layer.provideMerge(AiServiceTestingPreset('direct')),
-        ),
-      ),
-    ),
-  );
-
-  it.effect.only(
-    'calculator',
-    Effect.fn(
-      function* ({ expect }) {
-        const session = new AiSession({ operationModel: 'configured' });
-
-        const response = yield* session.run({
-          prompt: 'What is 10 + 20?',
-          history: [],
-          toolkit: TestToolkit,
-        });
-        log.info('response', { response });
-      },
-      Effect.provide(
-        Layer.mergeAll(
-          toolkitLayer,
-          ToolResolverService.layerEmpty,
-          ToolExecutionService.layerEmpty,
-          AiService.model('@anthropic/claude-3-5-sonnet-20241022').pipe(
-            Layer.provideMerge(AiServiceTestingPreset('direct')),
-          ),
-        ),
-      ),
-    ),
-  );
-
-  // TODO(dmaretskyi): Revive test.
-  /*
-  it.skip('create calendar itinerary', { timeout: 60_000 }, async () => {
-    
-    //   overrides: { model: 'llama3.1:8b' },
-    
-    const session = new AiSession({ operationModel: 'configured' });
-
-    const objects = new Set<string>();
-
-    // Define calendar artifact.
-    const calendarArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/calendar',
-      name: 'Calendar',
-      instructions: 'Use this to create and query calendar events.',
-      schema: CalendarEventSchema,
-      tools: [
-        createTool('calendar', {
-          name: 'query',
-          description: 'Query the calendar for events',
-          schema: Schema.Struct({}),
-          execute: async () => {
-            return ToolResult.Success(CALENDAR_EVENTS);
-          },
-        }),
-      ],
-    });
-
-    const tableArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/table',
-      name: 'Table',
-      instructions: 'Use this to create and manage tables. Each table has a unique id.',
-      schema: Schema.Struct({}),
-      tools: [
-        createTool('table', {
-          name: 'create',
-          description: 'Create a table',
-          schema: Schema.Struct({
-            data: Schema.Array(Schema.Any).annotations({ description: 'Array of data payloads to add as rows' }),
-          }),
-          execute: async ({ data }) => {
-            log('create table', { data });
-            const id = DXN.fromLocalObjectId(ObjectId.random()).toString();
-            objects.add(id);
-            // TODO(dmaretskyi): consider xml for refs instead of @dxn:echo:@:XXXXX
-            return ToolResult.Success(`table @${id}`);
-          },
-        }),
-      ],
-    });
-
-    const mapArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/map',
-      name: 'Map',
-      instructions:
-        'Use this to create and manage maps. Maps source data from tables. Table id is required to create a map.',
-      schema: Schema.Struct({}),
-      tools: [
-        createTool('map', {
-          name: 'create',
-          description: 'Create a map',
-          schema: Schema.Struct({
-            source: ArtifactId.annotations({
-              description: 'The table that will be used as the source of the map',
-            }),
-          }),
-          execute: async ({ source }) => {
-            // TODO(dmaretskyi): Use effect-schema decode instead of manual parsing.
-            const sourceId = ArtifactId.toDXN(source);
-            if (!objects.has(sourceId.toString())) {
-              return ToolResult.Error(`table id=${source} not found`);
-            }
-            log('create map', { sourceId });
-            const id = DXN.fromLocalObjectId(ObjectId.random()).toString();
-            objects.add(id);
-            // TODO(dmaretskyi): consider xml for refs instead of @dxn:echo:@:XXXXX
-            return ToolResult.Success(`map @${id}`);
-          },
-        }),
-      ],
-    });
-
-    const scriptArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/script',
-      name: 'Script',
-      instructions: 'Use this to create and manage scripts',
-      schema: Schema.Struct({}),
-      tools: [],
-    });
-
-    // session.streamEvent.on((event) => {
-    //   printStreamEvent(event);
-    // });
-
-    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));
-
-    // session.update.on((update) => {
-    //   log('update', { update });
-    // });
-
-    // Test creating an itinerary
-    const response = await session.run({
-      client: aiClient,
-      tools: [],
-      artifacts: [calendarArtifact, tableArtifact, mapArtifact, scriptArtifact],
-      requiredArtifactIds: [calendarArtifact.id, tableArtifact.id, mapArtifact.id, scriptArtifact.id],
-      history: [],
-      generationOptions: {
-        model: '@anthropic/claude-3-5-haiku-20241022',
-      },
-      prompt: 'create a table and map for a travel itinerary based on events in my calendar',
-      toolResolver: new ToolRegistry([]),
-    });
-
-    log('result', {
-      objects,
-      finalMessage: response.at(-1),
-    });
-  });
-  */
-});
-
-// Travel to rome, florence, livorno, siena, madrid for conferences
-// eslint-disable-next-line no-unused-vars
-const _CALENDAR_EVENTS: CalendarEvent[] = [
-  Obj.make(CalendarEventSchema, {
-    title: 'Exploring Ancient Ruins in Rome',
-    startTime: '2024-01-01T10:00:00Z',
-    endTime: '2024-01-01T11:00:00Z',
-    description: 'Tech conference at the historic Colosseum with networking opportunities',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Renaissance Tech Summit in Florence',
-    startTime: '2024-01-01T11:00:00Z',
-    endTime: '2024-01-01T12:00:00Z',
-    description: 'Discussing AI innovations surrounded by Renaissance art',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Livorno',
-    startTime: '2024-01-01T12:00:00Z',
-    endTime: '2024-01-01T13:00:00Z',
-    description: 'Travel to Livorno',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Siena',
-    startTime: '2024-01-01T13:00:00Z',
-    endTime: '2024-01-01T14:00:00Z',
-    description: 'Travel to Siena',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Madrid',
-    startTime: '2024-01-01T14:00:00Z',
-    endTime: '2024-01-01T15:00:00Z',
-    description: 'Travel to Madrid',
-  }),
-];
-
-// const printStreamEvent = (event: GenerationStreamEvent) => {
-//   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': {
-//       printContentBlock(event.content);
-//       break;
-//     }
-//     case 'content_block_delta': {
-//       switch (event.delta.type) {
-//         case 'text_delta': {
-//           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');
-//       break;
-//     }
-//     case 'message_delta': {
-//       break;
-//     }
-//     case 'message_stop': {
-//       process.stdout.write('\n\n');
-//       break;
-//     }
-//   }
-// };