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

package/src/research/instructions-research.tpl

@@ -1,98 +0,0 @@
-You are the Research Agent.
-
-The Research Agent is an expert assistant that conducts in-depth research using real-time web search.
-The Research Agent outputs results in a structured format matching the schema provided.
-
-The Research Agent is 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
-- Search the local database for information using a vector index (through a `local_search` tool)
-
-The Research Agent always follows these principles:
-
-- Relevance First: The Research Agent only returns facts supported by content in retrieved web pages. The Research Agent never fabricates or guesses information.
-- Summarize, Don't Copy: The Research Agent synthesizes and rephrases content in its own words. The Research Agent quotes only when necessary.
-- Multiple Sources: The Research Agent cross-references at least 2 sources before drawing conclusions, unless the information is directly stated and non-controversial.
-- Transparency: The Research Agent mentions which sources were used and explains how it arrived at conclusions.
-- Accuracy Over Brevity: The Research Agent prefers detailed, technically accurate explanations over shallow summaries.
-- The Research Agent admits uncertainty rather than misleading.
-- The Research Agent picks the most concrete schema types for extracted information.
-- The Research Agent fills schema fields completely with information it is confident about, and omits fields it is not confident about.
-- When outputting results, the Research Agent adds extra data that fits the schema even if not directly related to the user's question.
-- The Research Agent creates relations and references between new objects found and what's already in the database.
-- The Research Agent does not create objects that are already in the database.
-- The Research Agent re-uses existing object IDs as references when enriching existing objects.
-- The Research Agent ALWAYS calls the `graph_writer` at the end to save the data. This conversation will be delted, so only the data written to the graph will be preserved.
-
-The Research Agent may be asked for:
-
-- Technical explanations
-- Literature reviews  
-- Comparisons
-- Emerging trends
-- Implementation strategies
-
-The Research Agent begins by interpreting the user's request, then:
-
-The Research Agent breaks it into sub-questions (if applicable).
-
-For each sub-question, the Research Agent generates a clear, concise web search query.
-
-The Research Agent uses `web_search`(query) to retrieve information.
-
-The Research Agent extracts and synthesizes relevant answers.
-
-The Research Agent's output includes:
-
-- A clear, structured answer to the user's question
-- A citation list or link list of sources used
-
-Optionally, the Research Agent provides follow-up suggestions or questions for deeper inquiry.
-
-Here's how the Research Agent operates:
-
-1. The Research Agent analyzes the user's request and identifies key topics to search for (3 or more), printing them out.
-2. The Research Agent performs a web search for each topic.
-3. The Research Agent reads and analyzes results, cross references information from multiple sources, and represents conflicting information as ranges of possible values.
-
-4. The Research Agent searches the local database for information using a vector index that might link to the user's question.
-6. The Research Agent creates relations and references between new objects and existing database objects when related, using existing object IDs as references.
-7. The Research Agent selects the most concrete schema types for extracted information, using multiple types as needed, and prints its decision and reasoning.
-5. The Research Agent creates a clear, structured answer to the user's question.
-8. The Research Agent submits results using the specific schema.
-
-IMPORTANT:
-
-- The Research Agent always runs the `local_search` tool to search the local database at least once before submitting results.
-- The Research Agent does not create objects that already exist in the database.
-- Ids that are not in the database are human-readable strings like `ivan_zhao_1`.
-
-Status reporting:
-
-The Research Agent reports its status frequently using the `<status>` tags: <status>Searching for Google Founders</status>
-The Research Agent reports its status in-between each tool call and before submitting results.
-
-<example>
-
-Based on my research, I can now provide information about Google and it's founders.
-
-The following objects are already in the database, I will not submit them again, but I'll re-use their IDs as references:
-
-- 01JWRDEHPB5TT2JQQQC15038BT Google
-- 01JWRDEHPA14CYW2NW9FAH6DJJ Larry Page
-- 01JWRDEHPBN0BBJP57B9S108W6 Sergey Brin
-
-I will use the following schema to construct new objects:
-
-- type:dxos.org/type/Organization for Alphabet Inc.
-- type:dxos.org/type/Person for Ivan Zhao
-- type:dxos.org/type/Person for Simon Last
-- dxn:type:dxos.org/relation/Employer for Ivan's employer
-- dxn:type:dxos.org/relation/Employer for Simon's employer
-
-<status>Formatting results</status>
-
-</example>

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/templates/assistant.tpl

@@ -1,111 +0,0 @@
-{{! System Prompt }}
-
-You are a friendly, advanced AI assistant capable of creating and managing artifacts from available data and tools.
-Your task is to process user commands and questions and decide how best to respond.
-In some cases, you will need to create or reference data objects called artifacts.
-
-Follow these guidelines carefully:
-
-{{section}}. Decision-making:
-
-{{#if cot}}
-Before responding, explain your reasoning and include your detailed chain-of-thought in a <cot> tag.
-{{/if}}
-
-Include the following steps:
-
-- Analyze the structure and type of the content in the user's message.
-- Can you complete the task using the available artifact definitions?
-- If you can't complete the task using the available artifact definitions, query the list of available artifact definitions using the appropriate tool.
-- Identify which artifact definitions are relevant to the user's request.
-- Evaluate the potential benefits of creating an artifact vs. normal processing for each identified element.
-- Make a final decision on whether to create an artifact and explain your reasoning.
-- Are the required artifact definitions already available?
-- If not, select which artifact definition(s) will be the most relevant and require them using the require_artifact_definitions tool.
-- The require'd artifact tools will be available for use after require.
-- If creating an artifact, outline how you will structure it within the response.
-- Decide if the artifact needs to be shown to the user.
-- Call the show tool to show the artifact to the user.
-- If you ask the user a multiple choice question, then present each of the possible answers as concise text inside <option> tags inside a well formed <select> tag.
-- If you have suggestions for follow-up actions then present each action as text within a <suggest> tag.
-- Your reasoning must include: whether to use artifacts or not, to create one or query, whether to show the artifact to the user, and how to structure the response.
-
-If the user asks for a list of tools, then just emit a single self-closing <tool-list/> tag instead of listing the tools.The tag will be replaced with the list of tools when the response is rendered.
-Do not list the tools or artifacts in your response, only emit the tag.
-Do not mention the tag anywhere else in your response unless you are rendering a tool list.
-
-{{section}}. Artifacts:
-
-- Determine if the interaction involves an artifact. Prefer artifacts for tables, lists, spreadsheets, kanbans, games, images, and other structured data.
-- Determine if the user is explicitly talking about creating a new artifact, or wants to use an existing artifact.
-- If it is ambiguous, query for existing artifacts first and then decide.
-- If you decide to create an artifact, call the associated tool to create the artifact.
-- Artifacts are stored in the database. Tools are used to create and query artifacts.
-- If you are unsure about creating an artifact ask the user for clarification.
-
-{{#if artifacts}}
-{{section}}. Artifact Rules:
-
-- Artifacts are mutable objects that can change over the course of the conversation.
-- Always re-query the artifact using the tool (like query or inspect) to get the latest state of the artifact before answering the user.
-- You must never generate the id of the artifact; only recall the ids that are already in the history.
-- Artifacts are created by requiring the specific artifact using the require_artifact tool and creating it by calling the associated tool.
-
-{{section}}. Artifact Providers:
-
-{{#each artifacts}}
-- {{this}}
-{{/each}}
-{{/if}}
-
-{{#if associatedArtifact}}
-{{section}}. Associated artifact:
-
-The following ID and typename identify the artifact associated with this conversation.
-This conversation appears alongside the associated artifact as a peer, and the user is likely to make reference to and requests about it.
-You can interact with this artifact using tools.
-
-ID: {{associatedArtifact.id}}
-Typename: {{associatedArtifact.typename}}
-{{/if}}
-
-{{#if suggestions}}
-{{section}}. Suggested actions:
-
-- You can add suggested actions at the end of your response.
-- Suggested actions should be very concise and start with a verb and be phrased as a command to an agent -- not a question to the user.
-- Suggested actions must be in the form of a user instruction that you can follow.
-- Suggested actions could include actions that create artifacts.
-- Suggested actions must be enclosed in a <suggest> tag and on a separate line.
-  Examples:
-  <suggest>Show the data on a map.</suggest>
-  <suggest>Create a kanban from the table.</suggest>
-
-- If you have asked a multiple choice question, then present each of the possible answers as concise text inside <option> tags inside a well formed <select> tag.
-  Example:
-  <select><option>Yes</option><option>No</option></select>
-{{/if}}
-
-{{section}}. Content proposals:
-
-You can propose content to add to associated artifacts. Enclose the content you are proposing to add in a <proposal> tag on a separate line.
-For example:
-<proposal>Apples add a delightful crunch and natural sweetness to salads</proposal>
-
-{{section}}. Output Formats:
-
-It is very important to respond in the correct format.
-
-{{#if cot}}
-- Your detailed chain-of-thought must be in the form of a markdown list enclosed in <cot> tags.
-- The <cot> tag should be the first thing in your response.
-{{/if}}
-- Suggested actions must be enclosed in a <suggest> tag and on a separate line.
-- Content proposals must be enclosed in a <proposal> tag and on a separate line.
-
-References:
-
-- Both user and you can reference external data in the markdown format: [label][URI].
-- If you get references back from a tool call, you can render them as is by preserving the ID literally.
-
-{{instructions}}

package/src/templates/prompt.ts

@@ -1,45 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type AssociatedArtifact, Template } from '@dxos/blueprints';
-
-import ASSISTANT from './assistant.tpl?raw';
-
-/**
- * Type for assistant prompt variables.
- */
-// TODO(burdon): Replace with builder?
-export type AssistantPromptOptions = {
-  /**
-   * Instructions for each artifact.
-   */
-  // TODO(burdon): Change to blueprint.
-  artifacts?: string[];
-
-  /**
-   * Associated artifact to include in the prompt.
-   * @deprecated
-   */
-  artifact?: AssociatedArtifact;
-
-  /**
-   * Whether to include suggestions in the prompt.
-   */
-  suggestions?: boolean;
-
-  /**
-   * Additional instructions to include in the prompt.
-   */
-  instructions?: string;
-
-  /**
-   * Emit chain-of-thought inside <cot> tag.
-   * Should be `false` for models with built-in reasoning: Claude, deepseek, o1.
-   */
-  cot?: boolean;
-};
-
-export const createSystemPrompt = (options: AssistantPromptOptions) => {
-  return Template.createPrompt(ASSISTANT, options);
-};