@dxos/assistant-toolkit 0.8.4-main.fcc0d83b33 → 0.8.4-staging.60fe92afc8

package/src/blueprints/websearch/blueprint.test.ts

@@ -10,7 +10,7 @@ import { AgentService } from '@dxos/functions-runtime';
 import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
 import WebSearchBlueprint from './blueprint';
-import { WebSearchHandlers } from './functions';
+import { WebSearchHandlers } from './operations';
 import { WebSearchToolkitOpaque } from './toolkit';
 
 const TestLayer = AssistantTestLayer({
@@ -21,7 +21,8 @@ const TestLayer = AssistantTestLayer({
 });
 
 describe('WebToolkit', () => {
-  it.effect(
+  // Keep skipped, this test is flaky.
+  it.effect.skip(
     'WebFetch handler returns response text',
     Effect.fnUntraced(
       function* ({ expect }) {

package/src/blueprints/websearch/blueprint.ts

@@ -6,9 +6,9 @@ import { Blueprint } from '@dxos/compute';
 import { Ref } from '@dxos/echo';
 import { Text } from '@dxos/schema';
 
-import { Fetch } from './functions';
+import { Fetch } from './operations/definitions';
 
-const BLUEPRINT_KEY = 'org.dxos.blueprint.web-search';
+const BLUEPRINT_KEY = 'org.dxos.blueprint.webSearch';
 
 const make = () =>
   Blueprint.make({
@@ -19,7 +19,7 @@ const make = () =>
     instructions: {
       source: Ref.make(Text.make()),
     },
-    tools: Blueprint.toolDefinitions({ operations: [Fetch], tools: ['AnthropicWebSearch'] }),
+    tools: Blueprint.toolDefinitions({ operations: [Fetch] }),
   });
 
 const blueprint: Blueprint.Definition = {

package/src/blueprints/websearch/index.ts

@@ -4,4 +4,4 @@
 
 export { default as WebSearchBlueprint } from './blueprint';
 export { WebSearchToolkit, WebSearchToolkitOpaque } from './toolkit';
-export { Fetch as WebSearchFetch, WebSearchHandlers } from './functions';
+export { WebSearchHandlers, WebSearchOperations } from './operations';

package/src/blueprints/websearch/{functions → operations}/definitions.ts

@@ -5,12 +5,14 @@
 import * as Schema from 'effect/Schema';
 
 import { Operation } from '@dxos/compute';
+import { DXN } from '@dxos/keys';
 import { trim } from '@dxos/util';
 
 export const Fetch = Operation.make({
   meta: {
-    key: 'org.dxos.function.web-search.fetch',
+    key: DXN.make('org.dxos.function.web-search.fetch'),
     name: 'Fetch web page',
+    icon: 'ph--globe-simple--regular',
     description: trim`
       Fetches the content of a web page and returns the HTML. 
       Use this to get the content of a web page.

package/src/blueprints/websearch/operations/fetch.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { proxyFetchLegacy } from '@dxos/edge-client/cors-proxy';
+
+import { Fetch } from './definitions';
+
+export default Fetch.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ url }) {
+      const response = yield* Effect.tryPromise({
+        try: () => proxyFetchLegacy(new URL(url)),
+        catch: (cause) => new Error(`Fetch failed: ${String(cause)}`),
+      });
+      if (!response.ok) {
+        const body = yield* Effect.promise(() => response.text());
+        return yield* Effect.fail(new Error(`Fetch failed with status ${response.status}: ${body.slice(0, 256)}`));
+      }
+      return yield* Effect.promise(() => response.text());
+    }),
+  ),
+);

package/src/blueprints/websearch/{functions → operations}/index.ts

@@ -4,6 +4,6 @@
 
 import { OperationHandlerSet } from '@dxos/compute';
 
-export * from './definitions';
+export * as WebSearchOperations from './definitions';
 
 export const WebSearchHandlers = OperationHandlerSet.lazy(() => import('./fetch'));

package/src/crud/graph.test.ts

@@ -28,7 +28,7 @@ describe('graph', () => {
     'calculator',
     Effect.fn(
       function* (_) {
-        const request = new AiRequest();
+        const request = new AiRequest.Request();
         const toolkit = yield* OpaqueToolkit.fromContext(Toolkit);
         const response = yield* request.run({
           toolkit,

package/src/crud/graph.ts

@@ -11,23 +11,12 @@ import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { ContextQueueService } from '@dxos/compute';
-import { Entity, Filter, Obj, Query, Type } from '@dxos/echo';
-import { Database } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-db';
+import { Database, Entity, Feed, Filter, Obj, Query, Relation, Scope, Type } from '@dxos/echo';
 import { isEncodedReference } from '@dxos/echo-protocol';
-import {
-  ReferenceAnnotationId,
-  RelationSourceDXNId,
-  RelationSourceId,
-  RelationTargetDXNId,
-  RelationTargetId,
-  createObject,
-  getTypeAnnotation,
-  getTypeIdentifierAnnotation,
-} from '@dxos/echo/internal';
-import { mapAst } from '@dxos/effect';
-import { DXN, ObjectId } from '@dxos/keys';
+import { ReferenceAnnotationId, getTypeAnnotation, getTypeIdentifierAnnotation } from '@dxos/echo/Annotation';
+import { createObject } from '@dxos/echo/internal';
+import { SchemaEx } from '@dxos/effect';
+import { DXN, EID, EntityId, type URI } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { deepMapValues, isNonNullable, trim } from '@dxos/util';
 
@@ -37,8 +26,7 @@ export const Subgraph = Schema.Struct({
   objects: Schema.Array(Schema.Any),
 });
 
-export interface Subgraph extends Schema.Schema.Type<typeof Subgraph> {}
-
+export type Subgraph = Schema.Schema.Type<typeof Subgraph>;
 export type RelatedSchema = {
   schema: Type.AnyEntity;
   kind: 'reference' | 'relation';
@@ -52,19 +40,19 @@ export type RelatedSchema = {
  * @returns
  */
 export const findRelatedSchema = async (db: Database.Database, anchor: Type.AnyEntity): Promise<RelatedSchema[]> => {
-  // TODO(dmaretskyi): Query stored schemas.
-  const allSchemas = await db.graph.schemaRegistry.query().run();
+  const allSchemas = await db.query(Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry())).run();
 
   // TODO(dmaretskyi): Also do references.
   return allSchemas
     .filter((schema) => {
-      if (getTypeAnnotation(schema)?.kind !== Entity.Kind.Relation) {
+      const annotation = getTypeAnnotation(Type.getSchema(schema));
+      if (annotation?.kind !== Entity.Kind.Relation) {
         return false;
       }
 
       return (
-        isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema)!.sourceSchema!)) ||
-        isSchemaAddressableByDxn(anchor, DXN.parse(getTypeAnnotation(schema)!.targetSchema!))
+        isSchemaAddressableByDXN(anchor, annotation.sourceSchema!) ||
+        isSchemaAddressableByDXN(anchor, annotation.targetSchema!)
       );
     })
     .map(
@@ -79,17 +67,12 @@ export const findRelatedSchema = async (db: Database.Database, anchor: Type.AnyE
  * Non-strict DXN comparison.
  * Returns true if the DXN could be resolved to the schema.
  */
-const isSchemaAddressableByDxn = (schema: Type.AnyEntity, dxn: DXN): boolean => {
-  if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
+const isSchemaAddressableByDXN = (type: Type.AnyEntity, dxn: DXN.DXN): boolean => {
+  if (getTypeIdentifierAnnotation(Type.getSchema(type)) === dxn) {
     return true;
   }
 
-  const t = dxn.asTypeDXN();
-  if (t) {
-    return t.type === Type.getTypename(schema);
-  }
-
-  return false;
+  return DXN.getName(dxn) === Type.getTypename(type);
 };
 
 /**
@@ -106,20 +89,20 @@ export const LocalSearchToolkit = Toolkit.make(
     },
     success: Schema.Unknown,
     failure: Schema.Never,
-    dependencies: [Database.Service],
+    dependencies: [Database.Service, Feed.FeedService],
   }),
 );
 
 export const LocalSearchHandler = LocalSearchToolkit.toLayer({
   search_local_search: Effect.fn(function* ({ query }) {
-    const objects = yield* Database.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
+    const objects = yield* Database.query(Query.select(Filter.text(query, { type: 'vector' }))).run;
     const results = [...objects];
 
-    const option = yield* Effect.serviceOption(ContextQueueService);
-    if (Option.isSome(option)) {
-      const queueObjects = yield* Effect.promise(() => option.value.queue.queryObjects());
-      // TODO(dmaretskyi): Text search on the queue.
-      results.push(...queueObjects);
+    const feedOption = yield* Effect.serviceOption(Feed.ContextFeedService);
+    if (Option.isSome(feedOption)) {
+      const feedObjects = yield* Feed.runQuery(feedOption.value.feed, Filter.everything());
+      // TODO(dmaretskyi): Text search on the feed.
+      results.push(...feedObjects);
     }
 
     return trim`
@@ -150,7 +133,7 @@ export const makeGraphWriterToolkit = ({ schema }: { schema: Type.AnyEntity[] })
       parameters: createExtractionSchema(schema).fields,
       success: Schema.Unknown,
       failure: Schema.Never,
-      dependencies: [Database.Service, ContextQueueService],
+      dependencies: [Database.Service, Feed.ContextFeedService, Feed.FeedService],
     }).annotateContext(Context.make(GraphWriterSchema, { schema })),
   );
 };
@@ -160,7 +143,7 @@ export const makeGraphWriterHandler = (
   {
     onAppend,
   }: {
-    onAppend?: (object: DXN[]) => void;
+    onAppend?: (object: URI.URI[]) => void;
   } = {},
 ) => {
   const { schema } = Context.get(
@@ -171,11 +154,11 @@ export const makeGraphWriterHandler = (
   return toolkit.toLayer({
     graph_writer: Effect.fn(function* (input) {
       const { db } = yield* Database.Service;
-      const { queue } = yield* ContextQueueService;
-      const data = yield* Effect.promise(() => sanitizeObjects(schema, input as any, db, queue));
-      yield* Effect.promise(() => queue.append(data as Obj.Unknown[]));
+      const { feed } = yield* Feed.ContextFeedService;
+      const data = yield* sanitizeObjects(schema, input as any, db, feed);
+      yield* Feed.append(feed, data as Obj.Unknown[]);
 
-      const dxns = data.map((obj) => Obj.getDXN(obj));
+      const dxns = data.map((obj) => Entity.getURI(obj));
       onAppend?.(dxns);
       return dxns;
     }),
@@ -188,149 +171,150 @@ export const makeGraphWriterHandler = (
 export const createExtractionSchema = (types: Type.AnyEntity[]) => {
   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: ${Type.getDXN(types[index])?.asTypeDXN()!.type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option.getOrElse(() => ''))}`,
-        }),
-      ]),
+      types
+        .map((type) => preprocessSchema(Type.getSchema(type)))
+        .map((schema, index) => [
+          `objects_${getSanitizedSchemaName(types[index])}`,
+          Schema.optional(Schema.Array(schema)).annotations({
+            description: `The objects of type: ${DXN.getName(DXN.tryMake(Type.getURI(types[index])!)!)}. ${SchemaAST.getDescriptionAnnotation(Type.getSchema(types[index]).ast).pipe(Option.getOrElse(() => ''))}`,
+          }),
+        ]),
     ),
   });
 };
 
 export const getSanitizedSchemaName = (schema: Type.AnyEntity) => {
-  return Type.getDXN(schema)!
-    .asTypeDXN()!
-    .type.replaceAll(/[^a-zA-Z0-9]+/g, '_');
+  return DXN.getName(DXN.tryMake(Type.getURI(schema)!)!).replaceAll(/[^a-zA-Z0-9]+/g, '_');
 };
 
-export const sanitizeObjects = async (
+export const sanitizeObjects = (
   types: Type.AnyEntity[],
   data: Record<string, readonly unknown[]>,
   db: Database.Database,
-  queue?: Queue,
-): Promise<Obj.Unknown[]> => {
-  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, Entity.Unknown>();
-
-  const resolveId = (id: string): DXN | undefined => {
-    if (ObjectId.isValid(id)) {
-      existingIds.add(id);
-      return DXN.fromLocalObjectId(id);
-    }
+  feed?: Feed.Feed,
+): Effect.Effect<Entity.Unknown[], never, Feed.FeedService> =>
+  Effect.gen(function* () {
+    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<EntityId>();
+    const enitties = new Map<EntityId, Entity.Unknown>();
+
+    const resolveId = (id: string): EID.EID | undefined => {
+      if (EntityId.isValid(id)) {
+        existingIds.add(id);
+        return EID.make({ entityId: id });
+      }
 
-    const mappedId = idMap.get(id);
-    if (mappedId) {
-      return DXN.fromLocalObjectId(mappedId);
-    }
+      const mappedId = idMap.get(id);
+      if (mappedId && EntityId.isValid(mappedId)) {
+        return EID.make({ entityId: mappedId });
+      }
 
-    return undefined;
-  };
+      return undefined;
+    };
 
-  const res = entries
-    .map((entry) => {
-      // This entry mutates existing object.
-      if (ObjectId.isValid(entry.data.id)) {
+    const res = entries
+      .map((entry) => {
+        // This entry mutates existing object.
+        if (EntityId.isValid(entry.data.id)) {
+          return entry;
+        }
+
+        idMap.set(entry.data.id, EntityId.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)}` };
+            }
+          }
 
-      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);
+        });
+
+        let sourceUri: EID.EID | undefined;
+        let targetUri: EID.EID | undefined;
+        if (Entity.getKind(Type.getSchema(entry.schema)) === 'relation') {
+          sourceUri = resolveId(data.source);
+          if (!sourceUri) {
+            log.warn('source not found', { source: data.source });
           }
+          targetUri = resolveId(data.target);
+          if (!targetUri) {
+            log.warn('target not found', { target: data.target });
+          }
+          delete data.source;
+          delete data.target;
         }
 
-        return recurse(value);
-      });
+        return {
+          data,
+          schema: entry.schema,
+          sourceUri,
+          targetUri,
+        };
+      })
+      .filter((object) => !existingIds.has(object.data.id)); // TODO(dmaretskyi): This dissallows updating existing objects.
+
+    // TODO(dmaretskyi): Use ref resolver.
+    const dbObjects = yield* Effect.promise(() => db.query(Query.select(Filter.id(...existingIds))).run());
+    const feedObjects = feed && existingIds.size > 0 ? yield* Feed.runQuery(feed, Filter.id(...existingIds)) : [];
+    const objects = [...dbObjects, ...feedObjects].filter(isNonNullable);
+
+    // TODO(dmaretskyi): Returns everything if IDs are empty!
+    log.info('objects', { dbObjects, feedObjects, 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(', ')}`);
+    }
 
-      if (Entity.getKind(entry.schema) === 'relation') {
-        const sourceDxn = resolveId(data.source);
-        if (!sourceDxn) {
-          log.warn('source not found', { source: data.source });
+    return res.flatMap(({ data, schema, sourceUri, targetUri }) => {
+      let skip = false;
+      if (sourceUri) {
+        const id = EID.getEntityId(sourceUri);
+        const obj = objects.find((object) => object.id === id) ?? (id ? enitties.get(id) : undefined);
+        if (obj) {
+          data[Relation.Source] = obj;
+        } else {
+          skip = true;
         }
-        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 dbObjects = await db.query(Query.select(Filter.id(...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 (targetUri) {
+        const id = EID.getEntityId(targetUri);
+        const obj = objects.find((object) => object.id === id) ?? (id ? enitties.get(id) : undefined);
+        if (obj) {
+          data[Relation.Target] = 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 = createObject(schema, data);
+        enitties.set(obj.id, obj);
+        return [obj];
       }
-    }
-    if (!skip) {
-      const obj = createObject(schema, data);
-      enitties.set(obj.id, obj);
-      return [obj];
-    }
-    return [];
+      return [];
+    });
   });
-};
 
 const SoftRef = Schema.Struct({
   '/': Schema.String,
@@ -352,10 +336,10 @@ const preprocessSchema = (schema: Schema.Schema.AnyNoContext) => {
       return SoftRef.ast;
     }
 
-    return mapAst(ast, (child) => go(child, visited));
+    return SchemaEx.mapAst(ast, (child) => go(child, visited));
   };
 
-  return Schema.make<any, any, never>(mapAst(schema.ast, (ast) => go(ast))).pipe(
+  return Schema.make<any, any, never>(SchemaEx.mapAst(schema.ast, (ast) => go(ast))).pipe(
     Schema.omit('id'),
     Schema.extend(
       Schema.Struct({

package/src/errors.ts

@@ -3,7 +3,7 @@
 //
 
 import { BaseError } from '@dxos/errors';
-import { DXN } from '@dxos/keys';
+import { type EID } from '@dxos/keys';
 
 /**
  * Agent could not execute prompt.
@@ -13,8 +13,8 @@ export class PromptError extends BaseError.extend('PromptError') {
     message: string,
     context: {
       description?: string;
-      prompt?: DXN.String;
-      chat?: DXN.String;
+      prompt?: EID.EID;
+      chat?: EID.EID;
     },
   ) {
     super({