@dxos/assistant 0.8.4-main.3a94e84 → 0.8.4-main.406dc2a

package/dist/types/src/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,GAAG,EAAmB,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAEhE,eAAO,MAAM,qBAAqB,GAAI,IAAI,QAAQ,WAA4B,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG;IAC/C,KAAK,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC,EAAE,OAAO,KAAK,GAAG,CAAC;CA4BhE,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/src/context/binder.ts

@@ -1,103 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { computed, type ReadonlySignal } from '@preact/signals-core';
-import { Array, pipe } from 'effect';
-
-import { type Blueprint } from '@dxos/blueprints';
-import { Obj, type Type, type Ref, type Relation } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-db';
-import { ComplexSet } from '@dxos/util';
-
-import { ContextBinding } from './binding';
-
-/**
- * Manages bindings of blueprints and objects to a conversation.
- */
-export class ContextBinder {
-  constructor(private readonly _queue: Queue) {}
-
-  /**
-   * Reactive query of all bindings.
-   */
-  // TODO(burdon): Cache value?
-  readonly bindings: ReadonlySignal<Bindings> = computed(() => this._reduce(this._queue.objects));
-
-  // TODO(burdon): load refs?
-  readonly blueprints: ReadonlySignal<Ref.Ref<Blueprint.Blueprint>[]> = computed(() => [
-    ...this.bindings.value.blueprints,
-  ]);
-  readonly objects: ReadonlySignal<Ref.Ref<Type.Expando>[]> = computed(() => [...this.bindings.value.objects]);
-
-  /**
-   * Asynchronous query of all bindings.
-   */
-  async query(): Promise<Bindings> {
-    const queueItems = await this._queue.queryObjects();
-    return this._reduce(queueItems);
-  }
-
-  // TODO(burdon): Pass in Blueprint obj (from registry?) and create reference.
-  async bind(props: BindingProps): Promise<void> {
-    if (!props.blueprints?.length && !props.objects?.length) {
-      return;
-    }
-
-    await this._queue.append([
-      Obj.make(ContextBinding, {
-        blueprints: {
-          added: props.blueprints ?? [],
-          removed: [],
-        },
-        objects: {
-          added: props.objects ?? [],
-          removed: [],
-        },
-      }),
-    ]);
-  }
-
-  async unbind(props: BindingProps): Promise<void> {
-    if (!props.blueprints?.length && !props.objects?.length) {
-      return;
-    }
-
-    await this._queue.append([
-      Obj.make(ContextBinding, {
-        blueprints: {
-          added: [],
-          removed: props.blueprints ?? [],
-        },
-        objects: {
-          added: [],
-          removed: props.objects ?? [],
-        },
-      }),
-    ]);
-  }
-
-  private _reduce(items: (Obj.Any | Relation.Any)[]): Bindings {
-    return pipe(
-      items,
-      Array.filter(Obj.instanceOf(ContextBinding)),
-      Array.reduce(new Bindings(), (context, item) => {
-        item.blueprints.removed.forEach((item) => context.blueprints.delete(item));
-        item.blueprints.added.forEach((item) => context.blueprints.add(item));
-        item.objects.removed.forEach((item) => context.objects.delete(item));
-        item.objects.added.forEach((item) => context.objects.add(item));
-        return context;
-      }),
-    );
-  }
-}
-
-export type BindingProps = Partial<{
-  blueprints: Ref.Ref<Blueprint.Blueprint>[];
-  objects: Ref.Ref<Type.Expando>[];
-}>;
-
-export class Bindings {
-  blueprints = new ComplexSet<Ref.Ref<Blueprint.Blueprint>>((ref) => ref.dxn.toString());
-  objects = new ComplexSet<Ref.Ref<Type.Expando>>((ref) => ref.dxn.toString());
-}

package/src/context/binding.ts

@@ -1,32 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Blueprint } from '@dxos/blueprints';
-import { Type } from '@dxos/echo';
-
-/**
- * Thread message that binds or unbinds contextual objects to a conversation.
- */
-// TODO(burdon): Make ContentBlock.
-export const ContextBinding = Schema.Struct({
-  blueprints: Schema.Struct({
-    added: Schema.Array(Type.Ref(Blueprint.Blueprint)),
-    removed: Schema.Array(Type.Ref(Blueprint.Blueprint)),
-  }),
-
-  // TODO(burdon): Type.Expando => Type.Obj (or Obj.Any?)
-  objects: Schema.Struct({
-    added: Schema.Array(Type.Ref(Type.Expando)),
-    removed: Schema.Array(Type.Ref(Type.Expando)),
-  }),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/ContextBinding',
-    version: '0.1.0',
-  }),
-);
-
-export interface ContextBinding extends Schema.Schema.Type<typeof ContextBinding> {}

package/src/context/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './binder';
-export * from './binding';

package/src/research/exa.ts

@@ -1,97 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { AiTool, AiToolkit } from '@effect/ai';
-import { Effect, Schema } from 'effect';
-import Exa from 'exa-js';
-
-import { CredentialsService } from '@dxos/functions';
-import { log } from '@dxos/log';
-
-import { SEARCH_RESULTS } from '../testing';
-
-export class ExaToolkit extends AiToolkit.make(
-  AiTool.make('exa_search', {
-    description: 'Search the web for information',
-    parameters: {
-      query: Schema.String.annotations({ description: 'The query to search for' }),
-    },
-    success: Schema.Unknown,
-    failure: Schema.Never,
-  }).addRequirement<CredentialsService>(),
-) {}
-
-export const LiveExaHandler = ExaToolkit.toLayer({
-  exa_search: Effect.fn(function* ({ query }) {
-    const credential = yield* CredentialsService.getCredential({ service: 'exa.ai' });
-    const exa = new Exa(credential.apiKey);
-
-    const context = yield* Effect.promise(async () =>
-      exa.searchAndContents(query, {
-        type: 'auto',
-        text: {
-          maxCharacters: 3_000,
-        },
-        livecrawl: 'always',
-      }),
-    );
-
-    log.info('exa search', { query, costDollars: context.costDollars });
-
-    return context;
-  }),
-});
-
-export const MockExaHandler = ExaToolkit.toLayer({
-  exa_search: Effect.fn(function* ({ query }) {
-    // Find result with closest matching autoprompt using weighted Levenshtein distance
-    const result = SEARCH_RESULTS.reduce(
-      (closest, current) => {
-        if (!current.autopromptString) {
-          return closest;
-        }
-        if (!closest) {
-          return current;
-        }
-
-        // Calculate Levenshtein distance
-        const dist1 = levenshteinDistance(query, current.autopromptString);
-        const dist2 = levenshteinDistance(query, closest.autopromptString || '');
-
-        // Weight by length of the longer string to normalize
-        const weight1 = dist1 / Math.max(query.length, current.autopromptString.length);
-        const weight2 = dist2 / Math.max(query.length, closest.autopromptString?.length || 0);
-
-        return weight1 < weight2 ? current : closest;
-      },
-      null as (typeof SEARCH_RESULTS)[0] | null,
-    );
-
-    return result;
-  }),
-});
-
-const levenshteinDistance = (str1: string, str2: string): number => {
-  const m = str1.length;
-  const n = str2.length;
-  const dp: number[][] = Array(m + 1)
-    .fill(null)
-    .map(() => Array(n + 1).fill(0));
-
-  for (let i = 0; i <= m; i++) {
-    dp[i][0] = i;
-  }
-  for (let j = 0; j <= n; j++) {
-    dp[0][j] = j;
-  }
-
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      dp[i][j] =
-        str1[i - 1] === str2[j - 1] ? dp[i - 1][j - 1] : Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1;
-    }
-  }
-
-  return dp[m][n];
-};

package/src/research/graph.test.ts

@@ -1,64 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { AnthropicClient } from '@effect/ai-anthropic';
-import { FetchHttpClient } from '@effect/platform';
-import { describe, it } from '@effect/vitest';
-import { Config, Effect, Layer, pipe } from 'effect';
-
-import { AiService, AiServiceRouter, ToolExecutionService, ToolResolverService } from '@dxos/ai';
-import { tapHttpErrors } from '@dxos/ai/testing';
-import { TestHelpers } from '@dxos/effect';
-import { DatabaseService } from '@dxos/functions';
-import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
-
-import { makeGraphWriterHandler, makeGraphWriterToolkit } from './graph';
-import { AiSession } from '../session';
-
-// import { type EchoTestBuilder } from '@dxos/echo-db/testing';
-
-const TestLayer = pipe(
-  AiService.model('@anthropic/claude-3-5-sonnet-20241022'),
-  Layer.provideMerge(DatabaseService.notAvailable),
-  Layer.provideMerge(ToolResolverService.layerEmpty),
-  Layer.provideMerge(ToolExecutionService.layerEmpty),
-  Layer.provide(AiServiceRouter.AiServiceRouter),
-  Layer.provide(
-    AnthropicClient.layerConfig({
-      apiKey: Config.redacted('ANTHROPIC_API_KEY'),
-      transformClient: tapHttpErrors,
-    }),
-  ),
-  Layer.provide(FetchHttpClient.layer),
-);
-
-describe('graph', () => {
-  // let builder: EchoTestBuilder;
-  // test('findRelatedSchema', async () => {
-  //   const db = await createEchoDatabase();
-  //   const relatedSchemas = await findRelatedSchema(db, Schema.Struct({}));
-  // });
-
-  it.effect.skip(
-    'calculator',
-    Effect.fn(
-      function* ({ expect }) {
-        const graphWriteToolkit = makeGraphWriterToolkit({ schema: [DataType.Project] });
-
-        const session = new AiSession();
-        const response = yield* session
-          .run({
-            prompt: 'What is 10 + 20?',
-            history: [],
-            toolkit: graphWriteToolkit,
-          })
-          .pipe(Effect.provide(makeGraphWriterHandler(graphWriteToolkit)));
-        log.info('response', { response });
-      },
-      Effect.provide(TestLayer),
-      TestHelpers.runIf(process.env.ANTHROPIC_API_KEY),
-    ),
-  );
-});

package/src/research/graph.ts

@@ -1,369 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { AiTool, AiToolkit } from '@effect/ai';
-import { Context, Effect, identity, Option, Schema, SchemaAST } from 'effect';
-
-import type { Obj, Relation } from '@dxos/echo';
-import { Filter, Query } from '@dxos/echo';
-import { type EchoDatabase, type Queue } from '@dxos/echo-db';
-import { isEncodedReference } from '@dxos/echo-protocol';
-import {
-  create,
-  EntityKind,
-  getEntityKind,
-  getSchemaDXN,
-  getSchemaTypename,
-  getTypeAnnotation,
-  getTypeIdentifierAnnotation,
-  ObjectId,
-  ReferenceAnnotationId,
-  RelationSourceDXNId,
-  RelationSourceId,
-  RelationTargetDXNId,
-  RelationTargetId,
-  type BaseObject,
-} from '@dxos/echo-schema';
-import { mapAst } from '@dxos/effect';
-import { ContextQueueService, DatabaseService } from '@dxos/functions';
-import { DXN } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { deepMapValues, isNonNullable } from '@dxos/util';
-
-// TODO(burdon): Unify with the graph schema.
-export const Subgraph = Schema.Struct({
-  /** Objects and relations. */
-  objects: Schema.Array(Schema.Any),
-});
-export interface Subgraph extends Schema.Schema.Type<typeof Subgraph> {}
-
-export type RelatedSchema = {
-  schema: Schema.Schema.AnyNoContext;
-  kind: 'reference' | 'relation';
-};
-
-/**
- * Find all schemas that are related to the given schema.
- *
- * @param db
- * @param schema
- * @returns
- */
-export const findRelatedSchema = async (
-  db: EchoDatabase,
-  anchor: Schema.Schema.AnyNoContext,
-): Promise<RelatedSchema[]> => {
-  // TODO(dmaretskyi): Query stored schemas.
-  const allSchemas = [...db.graph.schemaRegistry.schemas];
-
-  // TODO(dmaretskyi): Also do references.
-  return allSchemas
-    .filter((schema) => {
-      if (getTypeAnnotation(schema)?.kind !== EntityKind.Relation) {
-        return false;
-      }
-
-      return (
-        isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema)!.sourceSchema!)) ||
-        isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema)!.targetSchema!))
-      );
-    })
-    .map(
-      (schema): RelatedSchema => ({
-        schema,
-        kind: 'relation',
-      }),
-    );
-};
-
-/**
- * Non-strict DXN comparison.
- * Returns true if the DXN could be resolved to the schema.
- */
-const isSchemaAddressableByDxn = (schema: Schema.Schema.AnyNoContext, dxn: DXN): boolean => {
-  if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
-    return true;
-  }
-
-  const t = dxn.asTypeDXN();
-  if (t) {
-    return t.type === getSchemaTypename(schema);
-  }
-
-  return false;
-};
-
-/**
- * Perform vector search in the local database.
- */
-// TODO(dmaretskyi): Rename `GraphReadToolkit`.
-export class LocalSearchToolkit extends AiToolkit.make(
-  AiTool.make('search_local_search', {
-    description: 'Search the local database for information using a vector index',
-    parameters: {
-      query: Schema.String.annotations({
-        description: 'The query to search for. Could be a question or a topic or a set of keywords.',
-      }),
-    },
-    success: Schema.Unknown,
-    failure: Schema.Never,
-  }).addRequirement<DatabaseService>(),
-) {}
-
-export const LocalSearchHandler = LocalSearchToolkit.toLayer({
-  search_local_search: Effect.fn(function* ({ query }) {
-    const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
-    const results = [...objects];
-
-    const contextQueue = yield* Effect.serviceOption(ContextQueueService);
-    if (Option.isSome(contextQueue)) {
-      const queueObjects = yield* Effect.promise(() => contextQueue.value.contextQueue.queryObjects());
-      // TODO(dmaretskyi): Text search on the queue.
-      results.push(...queueObjects);
-    }
-
-    return `
-      <local_context>
-        ${JSON.stringify(results, null, 2)}
-      </local_context>
-      `;
-  }),
-});
-
-/**
- * Attached as an annotation to the writer tool.
- */
-class GraphWriterSchema extends Context.Tag('GraphWriterSchema')<
-  GraphWriterSchema,
-  { schema: Schema.Schema.AnyNoContext[] }
->() {}
-
-/**
- * Forms typed objects that can be written to the graph database.
- */
-export const makeGraphWriterToolkit = ({ schema }: { schema: Schema.Schema.AnyNoContext[] }) => {
-  return AiToolkit.make(
-    AiTool.make('graph_writer', {
-      description: 'Write to the local graph database',
-      parameters: createExtractionSchema(schema).fields,
-      success: Schema.Unknown,
-      failure: Schema.Never,
-    })
-      .addRequirement<DatabaseService>()
-      .annotateContext(Context.make(GraphWriterSchema, { schema })),
-  );
-};
-
-export const makeGraphWriterHandler = (toolkit: ReturnType<typeof makeGraphWriterToolkit>) => {
-  const { schema } = Context.get(
-    toolkit.tools.graph_writer.annotations as Context.Context<GraphWriterSchema>,
-    GraphWriterSchema,
-  );
-  return toolkit.toLayer({
-    graph_writer: Effect.fn(function* (input) {
-      const { db } = yield* DatabaseService;
-      const contextQueue = yield* Effect.serviceOption(ContextQueueService);
-      const data = yield* Effect.promise(() =>
-        sanitizeObjects(schema, input as any, db, contextQueue.pipe(Option.getOrUndefined)?.contextQueue),
-      );
-      return data as Obj.Any[];
-    }),
-  });
-};
-/**
- * Create a schema for structured data extraction.
- */
-export const createExtractionSchema = (types: Schema.Schema.AnyNoContext[]) => {
-  return Schema.Struct({
-    ...Object.fromEntries(
-      types.map(preprocessSchema).map((schema, index) => [
-        `objects_${getSanitizedSchemaName(types[index])}`,
-        Schema.optional(Schema.Array(schema)).annotations({
-          description: `The objects of type: ${getSchemaDXN(types[index])?.asTypeDXN()!.type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option.getOrElse(() => ''))}`,
-        }),
-      ]),
-    ),
-  });
-};
-
-export const getSanitizedSchemaName = (schema: Schema.Schema.AnyNoContext) => {
-  return getSchemaDXN(schema)!
-    .asTypeDXN()!
-    .type.replaceAll(/[^a-zA-Z0-9]+/g, '_');
-};
-
-export const sanitizeObjects = async (
-  types: Schema.Schema.AnyNoContext[],
-  data: Record<string, readonly unknown[]>,
-  db: EchoDatabase,
-  queue?: Queue,
-): Promise<BaseObject[]> => {
-  const entries = types
-    .map(
-      (type) =>
-        data[`objects_${getSanitizedSchemaName(type)}`]?.map((object: any) => ({
-          data: object,
-          schema: type,
-        })) ?? [],
-    )
-    .flat();
-
-  const idMap = new Map<string, string>();
-  const existingIds = new Set<ObjectId>();
-  const enitties = new Map<ObjectId, Obj.Any | Relation.Any>();
-
-  const resolveId = (id: string): DXN | undefined => {
-    if (ObjectId.isValid(id)) {
-      existingIds.add(id);
-      return DXN.fromLocalObjectId(id);
-    }
-
-    const mappedId = idMap.get(id);
-    if (mappedId) {
-      return DXN.fromLocalObjectId(mappedId);
-    }
-
-    return undefined;
-  };
-
-  const res = entries
-    .map((entry) => {
-      // This entry mutates existing object.
-      if (ObjectId.isValid(entry.data.id)) {
-        return entry;
-      }
-
-      idMap.set(entry.data.id, ObjectId.random());
-      entry.data.id = idMap.get(entry.data.id);
-      return entry;
-    })
-    .map((entry) => {
-      const data = deepMapValues(entry.data, (value, recurse) => {
-        if (isEncodedReference(value)) {
-          const ref = value['/'];
-          const id = resolveId(ref);
-
-          if (id) {
-            // Link to an existing object.
-            return { '/': id.toString() };
-          } else {
-            // Search URIs?
-            return { '/': `search:?q=${encodeURIComponent(ref)}` };
-          }
-        }
-
-        return recurse(value);
-      });
-
-      if (getEntityKind(entry.schema) === 'relation') {
-        const sourceDxn = resolveId(data.source);
-        if (!sourceDxn) {
-          log.warn('source not found', { source: data.source });
-        }
-        const targetDxn = resolveId(data.target);
-        if (!targetDxn) {
-          log.warn('target not found', { target: data.target });
-        }
-        delete data.source;
-        delete data.target;
-        data[RelationSourceDXNId] = sourceDxn;
-        data[RelationTargetDXNId] = targetDxn;
-      }
-
-      return {
-        data,
-        schema: entry.schema,
-      };
-    })
-    .filter((object) => !existingIds.has(object.data.id)); // TODO(dmaretskyi): This dissallows updating existing objects.
-
-  // TODO(dmaretskyi): Use ref resolver.
-  const { objects: dbObjects } = await db.query(Query.select(Filter.ids(...existingIds))).run();
-  const queueObjects = (await queue?.getObjectsById([...existingIds])) ?? [];
-  const objects = [...dbObjects, ...queueObjects].filter(isNonNullable);
-
-  // TODO(dmaretskyi): Returns everything if IDs are empty!
-  log.info('objects', { dbObjects, queueObjects, existingIds });
-  const missing = Array.from(existingIds).filter((id) => !objects.some((object) => object.id === id));
-  if (missing.length > 0) {
-    throw new Error(`Object IDs do not point to existing objects: ${missing.join(', ')}`);
-  }
-
-  return res.flatMap(({ data, schema }) => {
-    let skip = false;
-    if (RelationSourceDXNId in data) {
-      const id = (data[RelationSourceDXNId] as DXN).asEchoDXN()?.echoId;
-      const obj = objects.find((object) => object.id === id) ?? enitties.get(id!);
-      if (obj) {
-        delete data[RelationSourceDXNId];
-        data[RelationSourceId] = obj;
-      } else {
-        skip = true;
-      }
-    }
-    if (RelationTargetDXNId in data) {
-      const id = (data[RelationTargetDXNId] as DXN).asEchoDXN()?.echoId;
-      const obj = objects.find((object) => object.id === id) ?? enitties.get(id!);
-      if (obj) {
-        delete data[RelationTargetDXNId];
-        data[RelationTargetId] = obj;
-      } else {
-        skip = true;
-      }
-    }
-    if (!skip) {
-      const obj = create(schema, data);
-      enitties.set(obj.id, obj);
-      return [obj];
-    }
-    return [];
-  });
-};
-
-const SoftRef = Schema.Struct({
-  '/': Schema.String,
-}).annotations({
-  description: 'Reference to another object.',
-});
-
-const preprocessSchema = (schema: Schema.Schema.AnyNoContext) => {
-  const isRelationSchema = getEntityKind(schema) === 'relation';
-
-  const go = (ast: SchemaAST.AST, visited = new Set<SchemaAST.AST>()): SchemaAST.AST => {
-    if (visited.has(ast)) {
-      // Already visited this node, prevent infinite recursion.
-      return ast;
-    }
-    visited.add(ast);
-
-    if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome)) {
-      return SoftRef.ast;
-    }
-
-    return mapAst(ast, (child) => go(child, visited));
-  };
-
-  return Schema.make<any, any, never>(mapAst(schema.ast, (ast) => go(ast))).pipe(
-    Schema.omit('id'),
-    Schema.extend(
-      Schema.Struct({
-        id: Schema.String.annotations({
-          description: 'The id of this object. Come up with a unique id based on your judgement.',
-        }),
-      }),
-    ),
-    isRelationSchema
-      ? Schema.extend(
-          Schema.Struct({
-            source: Schema.String.annotations({
-              description: 'The id of the source object for this relation.',
-            }),
-            target: Schema.String.annotations({
-              description: 'The id of the target object for this relation.',
-            }),
-          }),
-        )
-      : identity<Schema.Schema.AnyNoContext>,
-  );
-};

package/src/research/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './exa';
-export * from './research';
-export * from './graph';