@dxos/assistant 0.8.2-main.2f9c567 → 0.8.2-main.5885341

package/src/ai-service/client.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 import { test, describe } from 'vitest';
 
 import { defineTool, Message, ToolResult, type Tool } from '@dxos/artifact';
@@ -58,8 +58,8 @@ describe.skip('AI Service Client', () => {
       name: 'custodian',
       description: 'Custodian can tell you the password if you say the magic word',
       parameters: toJsonSchema(
-        Schema.Struct({
-          magicWord: Schema.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
+        S.Struct({
+          magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
         }),
       ),
     };
@@ -194,8 +194,8 @@ describe.skip('Ollama Client', () => {
         defineTool('test', {
           name: 'encrypt',
           description: 'Encrypt a message',
-          schema: Schema.Struct({
-            message: Schema.String.annotations({ description: 'The message to encrypt' }),
+          schema: S.Struct({
+            message: S.String.annotations({ description: 'The message to encrypt' }),
           }),
           execute: async ({ message }) => ToolResult.Success(message.split('').reverse().join('')),
         }),

package/src/ai-service/ollama-client.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { type MessageContentBlock, defineTool, type Tool, ToolResult } from '@dxos/artifact';
 import { ObjectId } from '@dxos/echo-schema';
@@ -388,8 +388,8 @@ const WELL_KNOWN_TOOLS: Record<string, Tool> = {
   [ToolTypes.TextToImage]: defineTool('system', {
     name: 'text-to-image',
     description: 'Generate an image from a text prompt',
-    schema: Schema.Struct({
-      prompt: Schema.String.annotations({ description: 'The text prompt describing the image to generate' }),
+    schema: S.Struct({
+      prompt: S.String.annotations({ description: 'The text prompt describing the image to generate' }),
     }),
     execute: async ({ prompt }) => {
       const image = await fetch(SAMPLE_IMAGE_URL).then(async (res) => Buffer.from(await res.arrayBuffer()));
@@ -467,15 +467,15 @@ class OllamaDecoderStream extends TransformStream<string, OllamaResponseData> {
   }
 }
 
-class ModelDoesNotSupportToolsError extends Schema.TaggedError<ModelDoesNotSupportToolsError>()(
+class ModelDoesNotSupportToolsError extends S.TaggedError<ModelDoesNotSupportToolsError>()(
   'ModelDoesNotSupportToolsError',
   {
-    model: Schema.String,
+    model: S.String,
   },
 ) {}
 
-class ModelNotFoundError extends Schema.TaggedError<ModelNotFoundError>()('ModelNotFoundError', {
-  model: Schema.String,
+class ModelNotFoundError extends S.TaggedError<ModelNotFoundError>()('ModelNotFoundError', {
+  model: S.String,
 }) {}
 
 const parseOllamaError = (error: string): Error => {

package/src/ai-service/types.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { Tool, Message, type MessageContentBlock } from '@dxos/artifact';
 import { type ObjectId } from '@dxos/echo-schema';
@@ -11,9 +11,9 @@ import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from './defs';
 
 export const createArtifactElement = (id: ObjectId) => `<artifact id=${id} />`;
 
-export const LLMModel = Schema.Literal(...DEFAULT_EDGE_MODELS, ...DEFAULT_OLLAMA_MODELS);
+export const LLMModel = S.Literal(...DEFAULT_EDGE_MODELS, ...DEFAULT_OLLAMA_MODELS);
 
-export type LLMModel = Schema.Schema.Type<typeof LLMModel>;
+export type LLMModel = S.Schema.Type<typeof LLMModel>;
 
 export const ToolTypes = Object.freeze({
   // TODO(dmaretskyi): Not implemented yet.
@@ -24,47 +24,47 @@ export const ToolTypes = Object.freeze({
 /**
  * Client GPT request.
  */
-export const GenerateRequest = Schema.Struct({
+export const GenerateRequest = S.Struct({
   /**
    * Preferred model or system default.
    */
-  model: Schema.optional(LLMModel),
+  model: S.optional(LLMModel),
 
   /**
    * Tools available for the LLM.
    */
-  tools: Schema.optional(Schema.Array(Tool).pipe(Schema.mutable)),
+  tools: S.optional(S.Array(Tool).pipe(S.mutable)),
 
   /**
    * System instructions to the LLM.
    */
-  systemPrompt: Schema.optional(Schema.String),
+  systemPrompt: S.optional(S.String),
 
   /**
    * History of messages to include in the context window.
    */
   // TODO(burdon): Rename messages.
-  history: Schema.optional(Schema.Array(Message)),
+  history: S.optional(S.Array(Message)),
 
   /**
    * Current request.
    */
-  prompt: Schema.optional(Message),
+  prompt: S.optional(Message),
 });
-export type GenerateRequest = Schema.Schema.Type<typeof GenerateRequest>;
+export type GenerateRequest = S.Schema.Type<typeof GenerateRequest>;
 
 /**
  * Non-streaming response.
  */
-export const GenerateResponse = Schema.Struct({
-  messages: Schema.Array(Message),
+export const GenerateResponse = S.Struct({
+  messages: S.Array(Message),
 
   /**
    * Number of tokens used in the response.
    */
-  tokenCount: Schema.optional(Schema.Number),
+  tokenCount: S.optional(S.Number),
 });
-export type GenerateResponse = Schema.Schema.Type<typeof GenerateResponse>;
+export type GenerateResponse = S.Schema.Type<typeof GenerateResponse>;
 
 /**
  * Server-Sent Events (SSE) stream from the AI service.

package/src/conversation/conversation.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 import { describe, test } from 'vitest';
 
 import { createUserMessage, defineTool, ToolResult } from '@dxos/artifact';
@@ -40,8 +40,8 @@ describe.skip('Conversation tests', () => {
     const custodian = defineTool('testing', {
       name: 'custodian',
       description: 'Custodian can tell you the password if you say the magic word',
-      schema: Schema.Struct({
-        magicWord: Schema.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
+      schema: S.Struct({
+        magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
       }),
       execute: async ({ magicWord }) => {
         if (magicWord === 'pretty please') {

package/src/conversation/types.ts

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

package/src/cypher/echo-data-source.ts

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

package/src/session/session.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 import { inspect } from 'node:util';
 import { describe, test } from 'vitest';
 
@@ -15,8 +15,7 @@ import {
   type MessageContentBlock,
 } from '@dxos/artifact';
 import { AIServiceEdgeClient } from '@dxos/assistant';
-import { Type } from '@dxos/echo';
-import { create, ObjectId } from '@dxos/echo-schema';
+import { create, EchoObject, ObjectId } from '@dxos/echo-schema';
 import { DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
 
@@ -24,19 +23,14 @@ import { AISession } from './session';
 import { AI_SERVICE_ENDPOINT } from '../testing';
 
 // Define a calendar event artifact schema.
-const CalendarEventSchema = Schema.Struct({
-  title: Schema.String,
-  startTime: Schema.String,
-  endTime: Schema.String,
-  description: Schema.String,
-}).pipe(
-  Type.def({
-    typename: 'example.com/type/CalendarEvent',
-    version: '0.1.0',
-  }),
-);
+const CalendarEventSchema = S.Struct({
+  title: S.String,
+  startTime: S.String,
+  endTime: S.String,
+  description: S.String,
+}).pipe(EchoObject({ typename: 'example.com/type/CalendarEvent', version: '0.1.0' }));
 
-type CalendarEvent = Schema.Schema.Type<typeof CalendarEventSchema>;
+type CalendarEvent = S.Schema.Type<typeof CalendarEventSchema>;
 
 // TODO(burdon): Flaky.
 describe.skip('AISession with Ollama', () => {
@@ -59,7 +53,7 @@ describe.skip('AISession with Ollama', () => {
         defineTool('calendar', {
           name: 'query',
           description: 'Query the calendar for events',
-          schema: Schema.Struct({}),
+          schema: S.Struct({}),
           execute: async () => {
             return ToolResult.Success(CALENDAR_EVENTS);
           },
@@ -71,13 +65,13 @@ describe.skip('AISession with Ollama', () => {
       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({}),
+      schema: S.Struct({}),
       tools: [
         defineTool('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' }),
+          schema: S.Struct({
+            data: S.Array(S.Any).annotations({ description: 'Array of data payloads to add as rows' }),
           }),
           execute: async ({ data }) => {
             log('create table', { data });
@@ -95,12 +89,12 @@ describe.skip('AISession with Ollama', () => {
       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({}),
+      schema: S.Struct({}),
       tools: [
         defineTool('map', {
           name: 'create',
           description: 'Create a map',
-          schema: Schema.Struct({
+          schema: S.Struct({
             source: ArtifactId.annotations({
               description: 'The table that will be used as the source of the map',
             }),
@@ -125,7 +119,7 @@ describe.skip('AISession with Ollama', () => {
       id: 'artifact:dxos.org/plugin/script',
       name: 'Script',
       instructions: 'Use this to create and manage scripts',
-      schema: Schema.Struct({}),
+      schema: S.Struct({}),
       tools: [],
     });
 

package/src/session/session.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Option, Schema } from 'effect';
+import { Option, Schema as S } from 'effect';
 
 import {
   defineTool,
@@ -287,7 +287,7 @@ export class AISession {
     return defineTool('system', {
       name: 'query_artifact_definitions',
       description: 'Query the available artifact definitions',
-      schema: Schema.Struct({}),
+      schema: S.Struct({}),
       execute: async () => {
         return ToolResult.Success({
           artifactDefinitions: artifacts.map((artifact) => ({
@@ -308,8 +308,8 @@ export class AISession {
       name: 'require_artifact_definitions',
       description:
         'Require the use of specific artifact definitions. This will allow the model to interact with artifact definitions and use their tools.',
-      schema: Schema.Struct({
-        artifactDefinitionIds: Schema.Array(Schema.String).annotations({
+      schema: S.Struct({
+        artifactDefinitionIds: S.Array(S.String).annotations({
           description: 'The ids of the artifact definitions to require',
           examples: [['artifact:dxos.org/example/Test']],
         }),
@@ -336,20 +336,20 @@ export class AISession {
       name: 'create_plan',
       description:
         'Create a plan. Make sure that each step is independent and can be executed solely on the data returned by the previous step. The steps only share the data that is specified in the plan.',
-      schema: Schema.Struct({
-        goal: Schema.String.annotations({ description: 'The goal that the plan will achieve.' }),
-        steps: Schema.Array(
-          Schema.Struct({
-            action: Schema.String.annotations({
+      schema: S.Struct({
+        goal: S.String.annotations({ description: 'The goal that the plan will achieve.' }),
+        steps: S.Array(
+          S.Struct({
+            action: S.String.annotations({
               description: 'Complete, detailed action to perform.',
             }),
-            input: Schema.String.annotations({
+            input: S.String.annotations({
               description: 'The required input data for this step. First step must not require any data.',
             }),
-            output: Schema.String.annotations({
+            output: S.String.annotations({
               description: 'The output data from this step. This is passed to the next step as input.',
             }),
-            requiredArtifactIds: Schema.Array(Schema.String).annotations({
+            requiredArtifactIds: S.Array(S.String).annotations({
               description: 'The ids of the artifacts required to perform this step.',
               examples: [['artifact:dxos.org/example/Test']],
             }),
@@ -473,7 +473,7 @@ const createBaseInstructions = ({
   ${availableArtifacts.length > 0 ? `Artifacts already in context: ${availableArtifacts.join('\n')}` : ''}
 `;
 
-export class AIServiecOverloadedError extends Schema.TaggedError<AIServiecOverloadedError>()(
+export class AIServiecOverloadedError extends S.TaggedError<AIServiecOverloadedError>()(
   'AIServiecOverloadedError',
   {},
 ) {}
@@ -483,7 +483,7 @@ const gatherObjectVersions = (messages: Message[]): Map<ObjectId, ObjectVersion>
   for (const message of messages) {
     for (const block of message.content) {
       if (block.type === 'json' && block.disposition === VersionPin.DISPOSITION) {
-        const pin = VersionPin.pipe(Schema.decodeOption)(JSON.parse(block.json)).pipe(Option.getOrUndefined);
+        const pin = VersionPin.pipe(S.decodeOption)(JSON.parse(block.json)).pipe(Option.getOrUndefined);
         if (!pin) {
           continue;
         }

package/src/testing/artifacts.test.ts

@@ -3,7 +3,7 @@
 //
 
 /*
-import { Schema } from '@effect/schema';
+import { Schema as S } from '@effect/schema';
 import { describe, test } from 'vitest';
 
 import { ObjectId, toJsonSchema } from '@dxos/echo-schema';
@@ -15,26 +15,26 @@ import { AIServiceEdgeClient, Tool } from '../ai-service';
 import { defineTool, ToolResult } from '../conversation';
 
 // TODO(dmaretskyi): Effect schema.
-const ArtifactDef = Schema.Struct({
-  typename: Schema.String,
-  description: Schema.String,
-  schema: Schema.Any,
-  actions: Schema.Array(Tool),
-}).pipe(Schema.mutable);
+const ArtifactDef = S.Struct({
+  typename: S.String,
+  description: S.String,
+  schema: S.Any,
+  actions: S.Array(Tool),
+}).pipe(S.mutable);
 
-type ArtifactDef = Schema.Schema.Type<typeof ArtifactDef>;
+type ArtifactDef = S.Schema.Type<typeof ArtifactDef>;
 
-const ListItem = Schema.Struct({
-  name: Schema.String,
+const ListItem = S.Struct({
+  name: S.String,
 });
 
-const ListSchema = Schema.Struct({
+const ListSchema = S.Struct({
   id: ObjectId,
-  title: Schema.String,
-  items: Schema.Array(ListItem).pipe(Schema.mutable),
-}).pipe(Schema.mutable);
+  title: S.String,
+  items: S.Array(ListItem).pipe(S.mutable),
+}).pipe(S.mutable);
 
-type ListSchema = Schema.Schema.Type<typeof ListSchema>;
+type ListSchema = S.Schema.Type<typeof ListSchema>;
 
 const list: ArtifactDef = {
   typename: 'example.com/type/List',
@@ -44,7 +44,7 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'query',
       description: 'Query all lists',
-      schema: Schema.Struct({}),
+      schema: S.Struct({}),
       execute: async ({}, context) => {
         return ToolResult.Success(LISTS[id]);
       },
@@ -52,7 +52,7 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'inspect',
       description: 'Get contents of the list',
-      schema: Schema.Struct({
+      schema: S.Struct({
         id: ObjectId.annotations({ description: 'The list to inspect' }),
       }),
       execute: async ({ id }, context) => {
@@ -62,9 +62,9 @@ const list: ArtifactDef = {
     defineTool('list', {
       name: 'create',
       description: 'Add one or more items to an existing list',
-      schema: Schema.Struct({
+      schema: S.Struct({
         id: ObjectId.annotations({ description: 'The list to add items to' }),
-        items: Schema.Array(ListItem).annotations({ description: 'The items to add to the list' }),
+        items: S.Array(ListItem).annotations({ description: 'The items to add to the list' }),
       }),
       execute: async ({ id, items }, context) => {
         LISTS[id].items.push(...items);
@@ -81,7 +81,7 @@ const artifacts = [list];
 const getArtifactDefinitions = defineTool('system', {
   name: 'getArtifactDefinitions',
   description: 'Queries the definitions and metadata of artifacts defined in the system',
-  schema: Schema.Any,
+  schema: S.Any,
   execute: async (_, context) => {
     return ToolResult.Success(
       artifacts.map((artifact) => ({
@@ -116,8 +116,8 @@ describe('Artifacts', () => {
       name: 'custodian',
       description: 'Custodian can tell you the password if you say the magic word',
       parameters: toJsonSchema(
-        Schema.Struct({
-          magicWord: Schema.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
+        S.Struct({
+          magicWord: S.String.annotations({ description: 'The magic word. Should be exactly "pretty please"' }),
         }),
       ),
     };

package/src/testing/query-promts.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { Schema as S } from 'effect';
 
 import { defineTool, ToolResult } from '@dxos/artifact';
 import { toJsonSchema } from '@dxos/echo-schema';
@@ -11,14 +11,14 @@ import { log } from '@dxos/log';
 import { executeQuery, formatJsonSchemaForLLM, type DataSource } from '../cypher';
 import { trim } from '../util';
 
-export const createCypherTool = (dataSource: DataSource, schemaTypes: Schema.Schema.Any[] = []) =>
+export const createCypherTool = (dataSource: DataSource, schemaTypes: S.Schema.Any[] = []) =>
   defineTool('dxos.org/echo', {
     name: 'query',
     description:
       'Query the ECHO graph database in cypher query language. Returns data from the database.' +
       (schemaTypes.length > 0 ? `\n\n${createSystemPrompt(schemaTypes)}` : ''),
-    schema: Schema.Struct({
-      query: Schema.String.annotations({
+    schema: S.Struct({
+      query: S.String.annotations({
         description: `
           A valid cypher query string to execute.
           Query must have one MATCH clause.
@@ -55,7 +55,7 @@ export const createCypherTool = (dataSource: DataSource, schemaTypes: Schema.Sch
     },
   });
 
-export const createSystemPrompt = (schemaTypes: Schema.Schema.Any[]) => trim`
+export const createSystemPrompt = (schemaTypes: S.Schema.Any[]) => trim`
   You have access to ECHO graph database. You can query the database to get data to satisfy user prompts.
 
   Database schema is defined in pseud-cypher syntax. The schema is:

package/src/testing/test-data.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import { type Schema as S } from 'effect';
 
 import { raise } from '@dxos/debug';
 import type { EchoDatabase } from '@dxos/echo-db';
@@ -254,7 +254,7 @@ export class MockDataSource implements DataSource {
   objects: Record<
     string,
     {
-      schema: Schema.Schema.All;
+      schema: S.Schema.All;
       typeDxn: string;
       id: string;
       data: unknown;
@@ -265,7 +265,7 @@ export class MockDataSource implements DataSource {
     string,
     {
       json: JsonSchemaType;
-      instance: Schema.Schema.All;
+      instance: S.Schema.All;
     }
   > = {};
 
@@ -280,7 +280,7 @@ export class MockDataSource implements DataSource {
     return this.relationships.filter((relationship) => !label || relationship.label === label);
   }
 
-  add<S extends Schema.Schema.All>(schema: S, data: Schema.Schema.Type<S>) {
+  add<S extends S.Schema.All>(schema: S, data: S.Schema.Type<S>) {
     invariant(typeof data.id === 'string', 'Data must have an id');
     const jsonSchema = toJsonSchema(schema);
     if (!this.schema[jsonSchema.$id!]) {