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

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/version-pin.test.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe } from 'vitest';
-
-describe('VersionPin', () => {});

package/src/summarization/summarization.test.ts

@@ -1,208 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// TODO(burdon): Fix.
-// @ts-nocheck
-
-import { pipe, Schema } from 'effect';
-import { beforeAll, describe, test } from 'vitest';
-
-import { AiService, MixedStreamParser } from '@dxos/ai';
-import { Obj } from '@dxos/echo';
-import { type EchoDatabase } from '@dxos/echo-db';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
-import { defineFunction, FunctionExecutor, ServiceContainer } from '@dxos/functions';
-import { type ContentBlock, DataType } from '@dxos/schema';
-import { createTestData } from '@dxos/schema/testing';
-import { trim } from '@dxos/util';
-
-const REMOTE_AI = true;
-
-const summarizationFn = defineFunction({
-  description: 'Summarize a document',
-  inputSchema: Schema.Struct({
-    document: Schema.optional(DataType.Text),
-    transcript: Schema.Array(DataType.Message),
-  }),
-  outputSchema: DataType.Text,
-  handler: async ({ data: { document, transcript }, context }) => {
-    const ai = context.getService(AiService);
-    const result = await new MixedStreamParser().parse(
-      await ai.client.execStream({
-        model: '@anthropic/claude-3-5-haiku-20241022',
-        // TODO(burdon): Factor out and test prompts.
-        systemPrompt: trim`
-          Your job is to summarize a meeting transcript.
-          Transcript Summarizer updates an existing summary within <summary> tags with a new transcript that is placed in <transcript> tags.
-          Transcript Summarizer updates only the relevant parts of the summary.
-          If there's no summary, create a new one.
-          Transcript Summarizer outputs only the summary texts and nothing else.
-          Transcript Summarizer keeps the original summary structure.
-          Transcript Summarizer keeps the unrelated parts of the summary untouched.
-          The Transcript Summarizer errs on the side of being too verbose.
-          The Transcript Summarizer outputs the entire update summary.
-          The summary is formatted as hierarchical markdown bullet points with no headings.
-          The hierarchical structure is deeply nested.
-          The Transcript Summarizer formats the bullets with "-" symbol as prefix and two spaces indentation.
-          The Transcript Summarizer knows that the content of transcript will be updated solely by its output.
-          The Transcript Summarizer outputs only the summary text.
-        `,
-        history: [
-          Obj.make(DataType.Message, {
-            created: new Date().toISOString(),
-            sender: { role: 'user' },
-            blocks: [
-              {
-                _tag: 'text',
-                text: trim`
-                  <transcript>
-                    ${JSON.stringify(transcript, null, 2)}
-                  </transcript>
-                `,
-              },
-              ...(document != null && document.content.length > 0
-                ? [
-                    {
-                      _tag: 'text',
-                      text: trim`
-                        <summary>
-                          ${document.content}
-                        </summary>
-                      `,
-                    } satisfies ContentBlock.Text,
-                  ]
-                : []),
-            ],
-          }),
-        ],
-      }),
-    );
-    return Obj.make(DataType.Text, {
-      content: pipe(result[0]?.blocks[0], (c) => (c?._tag === 'text' ? c.text : '')),
-    });
-  },
-});
-
-const refinementFn = defineFunction({
-  description: 'Refine a summary',
-  inputSchema: Schema.Struct({
-    summaries: Schema.Array(DataType.Text),
-  }),
-  outputSchema: Schema.Struct({
-    summary: DataType.Text,
-  }),
-  handler: async ({ data: { summaries }, context }) => {
-    const ai = context.getService(AiService);
-    const result = await new MixedStreamParser().parse(
-      await ai.client.execStream({
-        model: '@anthropic/claude-3-5-haiku-20241022',
-        // TODO(burdon): Factor out and test prompts.
-        systemPrompt: trim`
-          You are a Transcript Summary Refiner.
-          Transcript Summary Refiner works on a history of evolving summaries that were generated based on the transcript.
-          The summaries are presented starting from the oldest to the newest.
-          Each iteration of the summary contains a new part of the transcript.
-          The Transcript Summary Refiner refines the summary based on the history of summaries.
-          The Transcript Summary Refiner identifies any potential data lost between the iterations and adds its back to the output.
-          The Transcript Summary Refiner updates the summary to be more structured.
-          The Transcript Summary Refiner errs on the side of being too verbose.
-          The Transcript Summary Refiner errs on keeping the original summary structure.
-          The Transcript Summary Refiner outputs the entire update summary.
-          The Transcript Summary is formatted as hierarchical markdown bullet points with no headings.
-          The hierarchical structure is deeply nested.
-          The Transcript Summary Refiner formats the bullets with "-" symbol as prefix and two spaces indentation.
-          The Transcript Summary Refiner knows that the content of transcript will be updated solely by its output.
-          The Transcript Summary Refiner outputs only the summary text.
-        `,
-        history: [
-          Obj.make(DataType.Message, {
-            created: new Date().toISOString(),
-            sender: { role: 'user' },
-            blocks: summaries.map(
-              (summary) =>
-                ({
-                  _tag: 'text',
-                  text: trim`
-                    <summary>
-                      ${summary.content}
-                    </summary>
-                  `,
-                }) satisfies ContentBlock.Text,
-            ),
-          }),
-        ],
-      }),
-    );
-    return {
-      summary: Obj.make(DataType.Text, {
-        content: pipe(result[0]?.blocks[0], (c) => (c?._tag === 'text' ? c.text : '')),
-      }),
-    };
-  },
-});
-
-describe.skip('Summarization', () => {
-  let builder: EchoTestBuilder;
-  let db: EchoDatabase;
-  let executor: FunctionExecutor;
-
-  // TODO(burdon): Rewrite test.
-  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;
-    executor = new FunctionExecutor(
-      new ServiceContainer().setServices({
-        ai: todo(),
-        database: {
-          db,
-        },
-      }),
-    );
-  });
-
-  test('keeps transcript outline', { timeout: 1000_000 }, async () => {
-    const { transcriptMessages } = createTestData();
-
-    const summary = Obj.make(DataType.Text, {
-      content: '',
-    });
-
-    const summaries = [];
-
-    for (let i = 0; i < transcriptMessages.length; i++) {
-      const blocks = transcriptMessages.slice(Math.max(0, i - 2), i + 1);
-      const result = await executor.invoke(summarizationFn, {
-        document: summary,
-        transcript: blocks,
-      });
-      summary.content = result.content;
-      summaries.push(Obj.make(DataType.Text, { content: result.content }));
-
-      console.log(blocks.at(-1));
-      console.log();
-      console.log('--------------------------------');
-      console.log();
-      console.log(summary.content);
-      console.log();
-
-      if (i % 3 === 0 && i > 0) {
-        const history: any = summaries.slice(-5);
-        const result = await executor.invoke(refinementFn, {
-          summaries: history,
-        });
-        summary.content = result.summary.content;
-        summaries.push(Obj.make(DataType.Text, { content: result.summary.content }));
-
-        console.log('REFINED');
-        console.log();
-        console.log('--------------------------------');
-        console.log();
-        console.log(summary.content);
-        console.log();
-      }
-    }
-  });
-});

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);
-};