@dxos/assistant-toolkit 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/src/blueprints/websearch/blueprint.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+
+import { Fetch } from './functions';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.web-search';
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Web Search',
+    description: 'Search the web.',
+    agentCanEnable: true,
+    instructions: {
+      source: Ref.make(Text.make()),
+    },
+    tools: Blueprint.toolDefinitions({ operations: [Fetch], tools: ['AnthropicWebSearch'] }),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/websearch/functions/definitions.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Operation } from '@dxos/operation';
+import { trim } from '@dxos/util';
+
+export const Fetch = Operation.make({
+  meta: {
+    key: 'org.dxos.function.web-search.fetch',
+    name: 'Fetch web page',
+    description: trim`
+      Fetches the content of a web page and returns the HTML. 
+      Use this to get the content of a web page.
+    `,
+  },
+  input: Schema.Struct({
+    url: Schema.String.annotations({
+      description: 'The URL of the web page to fetch.',
+    }),
+  }),
+  output: Schema.String,
+});

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

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/operation';
+
+import { Fetch } from './definitions';
+
+export default Fetch.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ url }) {
+      const response = yield* Effect.promise(() => fetch(url).then((response) => response.text()));
+      return response;
+    }),
+  ),
+);

package/src/blueprints/websearch/functions/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * from './definitions';
+
+export const WebSearchHandlers = OperationHandlerSet.lazy(() => import('./fetch'));

package/src/blueprints/websearch/index.ts

@@ -2,8 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { blueprint } from './websearch-blueprint';
-
-export { WebSearchToolkit } from './websearch-toolkit';
-
-export default blueprint;
+export { default as WebSearchBlueprint } from './blueprint';
+export { WebSearchToolkit, WebSearchToolkitGeneric } from './toolkit';
+export { Fetch as WebSearchFetch, WebSearchHandlers } from './functions';

package/src/blueprints/websearch/{websearch-toolkit.ts → toolkit.ts}

@@ -2,7 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
+import { GenericToolkit } from '@dxos/ai';
 import * as Toolkit from '@effect/ai/Toolkit';
 import * as AnthropicTool from '@effect/ai-anthropic/AnthropicTool';
+import * as Layer from 'effect/Layer';
 
 export const WebSearchToolkit = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
+
+export const WebSearchToolkitGeneric = GenericToolkit.make(WebSearchToolkit, Layer.empty);

package/src/crud/graph.test.ts

@@ -10,7 +10,7 @@ import { AiSession } from '@dxos/assistant';
 import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { TestHelpers } from '@dxos/effect/testing';
 import { log } from '@dxos/log';
-import { Project } from '@dxos/types';
+import { Pipeline } from '@dxos/types';
 
 import { makeGraphWriterHandler, makeGraphWriterToolkit } from './graph';
 
@@ -23,7 +23,7 @@ describe('graph', () => {
   //   const relatedSchemas = await findRelatedSchema(db, Schema.Struct({}));
   // });
 
-  const Toolkit = makeGraphWriterToolkit({ schema: [Project.Project] });
+  const Toolkit = makeGraphWriterToolkit({ schema: [Pipeline.Pipeline] });
   const ToolkitLayer = makeGraphWriterHandler(Toolkit);
 
   it.effect.skip(

package/src/crud/graph.ts

@@ -40,7 +40,7 @@ export const Subgraph = Schema.Struct({
 export interface Subgraph extends Schema.Schema.Type<typeof Subgraph> {}
 
 export type RelatedSchema = {
-  schema: Type.Entity.Any;
+  schema: Type.AnyEntity;
   kind: 'reference' | 'relation';
 };
 
@@ -51,7 +51,7 @@ export type RelatedSchema = {
  * @param schema
  * @returns
  */
-export const findRelatedSchema = async (db: Database.Database, anchor: Type.Entity.Any): Promise<RelatedSchema[]> => {
+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();
 
@@ -79,7 +79,7 @@ export const findRelatedSchema = async (db: Database.Database, anchor: Type.Enti
  * Non-strict DXN comparison.
  * Returns true if the DXN could be resolved to the schema.
  */
-const isSchemaAddressableByDxn = (schema: Type.Entity.Any, dxn: DXN): boolean => {
+const isSchemaAddressableByDxn = (schema: Type.AnyEntity, dxn: DXN): boolean => {
   if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
     return true;
   }
@@ -112,7 +112,7 @@ export const LocalSearchToolkit = Toolkit.make(
 
 export const LocalSearchHandler = LocalSearchToolkit.toLayer({
   search_local_search: Effect.fn(function* ({ query }) {
-    const objects = yield* Database.Service.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
+    const objects = yield* Database.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
     const results = [...objects];
 
     const option = yield* Effect.serviceOption(ContextQueueService);
@@ -136,14 +136,14 @@ export const LocalSearchHandler = LocalSearchToolkit.toLayer({
 class GraphWriterSchema extends Context.Tag('@dxos/assistant/GraphWriterSchema')<
   GraphWriterSchema,
   {
-    schema: Type.Entity.Any[];
+    schema: Type.AnyEntity[];
   }
 >() {}
 
 /**
  * Forms typed objects that can be written to the graph database.
  */
-export const makeGraphWriterToolkit = ({ schema }: { schema: Type.Entity.Any[] }) => {
+export const makeGraphWriterToolkit = ({ schema }: { schema: Type.AnyEntity[] }) => {
   return Toolkit.make(
     Tool.make('graph_writer', {
       description: 'Write to the local graph database',
@@ -185,7 +185,7 @@ export const makeGraphWriterHandler = (
 /**
  * Create a schema for structured data extraction.
  */
-export const createExtractionSchema = (types: Type.Entity.Any[]) => {
+export const createExtractionSchema = (types: Type.AnyEntity[]) => {
   return Schema.Struct({
     ...Object.fromEntries(
       types.map(preprocessSchema).map((schema, index) => [
@@ -198,14 +198,14 @@ export const createExtractionSchema = (types: Type.Entity.Any[]) => {
   });
 };
 
-export const getSanitizedSchemaName = (schema: Type.Entity.Any) => {
+export const getSanitizedSchemaName = (schema: Type.AnyEntity) => {
   return Type.getDXN(schema)!
     .asTypeDXN()!
     .type.replaceAll(/[^a-zA-Z0-9]+/g, '_');
 };
 
 export const sanitizeObjects = async (
-  types: Type.Entity.Any[],
+  types: Type.AnyEntity[],
   data: Record<string, readonly unknown[]>,
   db: Database.Database,
   queue?: Queue,

package/src/functions/READ_THIS.md

@@ -0,0 +1,5 @@
+###
+
+Can we move all functions into the corresponding blueprint folder?
+
+###

package/src/functions/agent/definitions.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { AiService, ModelName, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { Prompt } from '@dxos/blueprints';
+import { Database, Ref } from '@dxos/echo';
+import { FunctionInvocationService, QueueService, TracingService } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+import * as Chat from '../../types/Chat';
+
+export const AgentPrompt = Operation.make({
+  meta: {
+    key: 'org.dxos.function.prompt',
+    name: 'Agent',
+    description: 'Agentic worker that executes a provided prompt using blueprints and tools.',
+  },
+  input: Schema.Struct({
+    prompt: Ref.Ref(Prompt.Prompt),
+
+    // TODO(dmaretskyi): Remove.
+    systemPrompt: Schema.optional(Ref.Ref(Prompt.Prompt)),
+
+    /**
+     * When set, runs in this chat (history, queue, and bound context). Prompt blueprints and context objects are merged into the conversation for this request.
+     */
+    chat: Schema.optional(Ref.Ref(Chat.Chat)),
+
+    /**
+     * @default @anthropic/claude-opus-4-0
+     */
+
+    model: Schema.optional(ModelName),
+    /**
+     * Input object or data.
+     * References get auto-resolved.
+     */
+    input: Schema.Any.pipe(Schema.annotations({ title: 'Input' })),
+  }),
+  output: Schema.Any,
+  services: [
+    AiService.AiService,
+    Database.Service,
+    QueueService,
+    TracingService,
+    ToolExecutionService,
+    ToolResolverService,
+    FunctionInvocationService,
+  ],
+});

package/src/functions/agent/index.ts

@@ -2,10 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type FunctionDefinition } from '@dxos/functions';
+import { OperationHandlerSet } from '@dxos/operation';
 
-import { default as prompt$ } from './prompt';
+export * from './definitions';
 
-export namespace Agent {
-  export const prompt: FunctionDefinition.Any = prompt$; // TODO(burdon): Temp fix for TS error.
-}
+export const AgentHandlers = OperationHandlerSet.lazy(() => import('./prompt'));

package/src/functions/agent/prompt.test.ts

@@ -0,0 +1,144 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Stream from 'effect/Stream';
+
+import { AiService, GenericToolkit } from '@dxos/ai';
+import { ContextBinding, ToolExecutionServices } from '@dxos/assistant';
+import { Blueprint, Prompt } from '@dxos/blueprints';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { CredentialsService, FunctionInvocationService, QueueService, TracingService } from '@dxos/functions';
+import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
+import { ObjectId } from '@dxos/keys';
+import { OperationHandlerSet } from '@dxos/operation';
+import { Text } from '@dxos/schema';
+import { Message } from '@dxos/types';
+
+import * as Chat from '../../types/Chat';
+
+import { AgentPrompt } from './definitions';
+import defaultAgentPrompt from './prompt';
+
+ObjectId.dangerouslyDisableRandomness();
+
+/**
+ * Deterministic LM so chat-mode agent tests do not depend on memoized conversations or API keys.
+ */
+const StubLanguageModelLayer = Layer.effect(
+  LanguageModel.LanguageModel,
+  LanguageModel.make({
+    generateText: () => Effect.dieMessage('Agent prompt tests use streamText only.'),
+    streamText: () =>
+      Stream.fromIterable([
+        {
+          type: 'response-metadata',
+          id: 'stub-msg',
+          modelId: 'stub',
+          timestamp: '1970-01-01T00:00:00.000Z',
+          metadata: {},
+        },
+        { type: 'text-start', id: '0', metadata: {} },
+        { type: 'text-delta', id: '0', delta: 'ack', metadata: {} },
+        { type: 'text-end', id: '0', metadata: {} },
+        {
+          type: 'finish',
+          reason: 'stop',
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+          metadata: {},
+        },
+      ]),
+  }),
+);
+
+const StubAiServiceLayer = Layer.succeed(AiService.AiService, {
+  metadata: { name: 'stub-ai' },
+  model: () => StubLanguageModelLayer,
+});
+
+const testTypes = [
+  Prompt.Prompt,
+  Chat.Chat,
+  Blueprint.Blueprint,
+  Feed.Feed,
+  Message.Message,
+  ContextBinding,
+  Text.Text,
+];
+
+const TestLayer = Layer.mergeAll(
+  AiService.model('@anthropic/claude-opus-4-0'),
+  ToolExecutionServices,
+  Layer.succeed(Blueprint.RegistryService, new Blueprint.Registry([])),
+).pipe(
+  Layer.provideMerge(
+    FunctionInvocationServiceLayerTest({
+      functions: OperationHandlerSet.make(defaultAgentPrompt),
+    }),
+  ),
+  Layer.provideMerge(
+    Layer.mergeAll(
+      StubAiServiceLayer,
+      TestDatabaseLayer({ spaceKey: 'fixed', types: testTypes }),
+      CredentialsService.configuredLayer([]),
+      Feed.notAvailable,
+      TracingService.layerNoop,
+    ),
+  ),
+  Layer.provideMerge(GenericToolkit.providerLayer(GenericToolkit.empty)),
+);
+
+const countQueueMessages = (queue: { queryObjects: () => Promise<Obj.Unknown[]> }) =>
+  Effect.promise(async () => {
+    const items = await queue.queryObjects();
+    return items.filter(Obj.instanceOf(Message.Message)).length;
+  });
+
+describe('Agent prompt', () => {
+  it.effect(
+    'chat mode appends assistant messages to the chat queue',
+    Effect.fnUntraced(
+      function* (_) {
+        const feed = yield* Database.add(Feed.make());
+        const queueDxn = Feed.getQueueDxn(feed)!;
+        const queue = yield* QueueService.getQueue<Message.Message | ContextBinding>(queueDxn);
+        const messageCountBefore = yield* countQueueMessages(queue);
+
+        const chat = yield* Database.add(
+          Chat.make({
+            feed: Ref.make(feed),
+          }),
+        );
+
+        const prompt = yield* Database.add(
+          Prompt.make({
+            name: 'chat-mode-test',
+            instructions: 'Reply with a single word: ack.',
+            blueprints: [],
+            context: [],
+          }),
+        );
+
+        yield* Database.flush();
+
+        const result = yield* FunctionInvocationService.invokeFunction(AgentPrompt, {
+          prompt: Ref.make(prompt),
+          input: {},
+          chat: Ref.make(chat),
+        });
+
+        const messageCountAfter = yield* countQueueMessages(queue);
+
+        expect(messageCountAfter).toBeGreaterThan(messageCountBefore);
+        expect(result.note).toBe('ack');
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});