@dxos/assistant-toolkit 0.8.4-main.e8ec1fe → 0.8.4-main.fcfe5033a5

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

@@ -0,0 +1,83 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { ContextBinding } from '@dxos/assistant';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
+import { Prompt } from '@dxos/blueprints';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { QueueService } from '@dxos/functions';
+import { ObjectId } from '@dxos/keys';
+import { Operation } from '@dxos/operation';
+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();
+
+const operationHandlerSet = OperationHandlerSet.make(defaultAgentPrompt);
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: operationHandlerSet,
+  types: [Chat.Chat, Message.Message, ContextBinding, Text.Text],
+  aiServicePreset: 'edge-remote',
+});
+
+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* Operation.invoke(AgentPrompt, {
+          prompt: Ref.make(prompt),
+          input: {},
+          chat: Ref.make(chat),
+        });
+
+        const messageCountAfter = yield* countQueueMessages(queue);
+
+        expect(messageCountAfter).toBeGreaterThan(messageCountBefore);
+        expect(result).toBe('ack');
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 60_000 },
+  );
+});

package/src/functions/agent/prompt.ts

@@ -2,113 +2,222 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
 import * as Array from 'effect/Array';
+import * as Deferred from 'effect/Deferred';
 import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
-import * as Match from 'effect/Match';
+import * as Layer from 'effect/Layer';
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 
-import { AiService, ConsolePrinter, ModelName } from '@dxos/ai';
-import { AiSession, GenerationObserver, createToolkit } from '@dxos/assistant';
-import { Prompt, Template } from '@dxos/blueprints';
-import { Obj, Ref, Type } from '@dxos/echo';
-import { DatabaseService, TracingService, defineFunction } from '@dxos/functions';
+import { AiService, OpaqueToolkit, ModelName } from '@dxos/ai';
+import {
+  AiSession,
+  getOperationFromTool,
+  makeToolExecutionService,
+  makeToolResolverFromOperations,
+} from '@dxos/assistant';
+import { Template } from '@dxos/blueprints';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { Trace } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
+import { trim } from '@dxos/util';
 
-const DEFAULT_MODEL: ModelName = '@anthropic/claude-opus-4-0';
-
-export default defineFunction({
-  key: 'dxos.org/function/prompt',
-  name: 'Agent',
-  description: 'Agentic worker that executes a provided prompt using blueprints and tools.',
-  inputSchema: Schema.Struct({
-    prompt: Type.Ref(Prompt.Prompt),
-    systemPrompt: Type.Ref(Prompt.Prompt).pipe(Schema.optional),
-    /**
-     * @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' })),
-  }),
-  outputSchema: Schema.Any,
-  handler: Effect.fnUntraced(function* ({ data }) {
-    log.info('processing input', { input: data.input });
-
-    // TODO(wittjosiah): Support templated object as input.
-    //   Currently the object templating only supports direct pass-through or strings.
-    // const input = { ...data.input };
-    // for (const key of Object.keys(data.input)) {
-    //   const value = data.input[key];
-    //   if (Ref.isRef(value)) {
-    //     const object = yield* DatabaseService.load(value);
-    //     input[key] = Obj.toJSON(object);
-    //   } else {
-    //     input[key] = JSON.stringify(value);
-    //   }
-    // }
-    const input = yield* Match.value(data.input).pipe(
-      Match.when(
-        (value: any) => Ref.isRef(value),
-        Effect.fnUntraced(function* (ref) {
-          const object = yield* DatabaseService.load(ref);
-          return Obj.toJSON(object as Obj.Any);
-        }),
-      ),
-      Match.orElse(() => Effect.succeed(data.input)),
-    );
-
-    yield* DatabaseService.flush({ indexes: true });
-    const prompt = yield* DatabaseService.load(data.prompt);
-    const systemPrompt = data.systemPrompt ? yield* DatabaseService.load(data.systemPrompt) : undefined;
-    yield* TracingService.emitStatus({ message: `Running ${prompt.id}` });
-
-    log.info('starting agent', { prompt: prompt.id, input });
-
-    const blueprints = yield* Function.pipe(
-      prompt.blueprints,
-      Array.appendAll(systemPrompt?.blueprints ?? []),
-      Effect.forEach(DatabaseService.loadOption),
-      Effect.map(Array.filter(Option.isSome)),
-      Effect.map(Array.map((option) => option.value)),
-    );
-    const objects = yield* Function.pipe(
-      prompt.context,
-      Array.appendAll(systemPrompt?.context ?? []),
-      Effect.forEach(DatabaseService.loadOption),
-      Effect.map(Array.filter(Option.isSome)),
-      Effect.map(Array.map((option) => option.value)),
-    );
-    const toolkit = yield* createToolkit({ blueprints });
-
-    const promptInstructions = yield* DatabaseService.load(prompt.instructions.source);
-    const promptText = Template.process(promptInstructions.content, input);
-
-    const systemInstructions = systemPrompt ? yield* DatabaseService.load(systemPrompt.instructions.source) : undefined;
-    const systemText = systemInstructions ? Template.process(systemInstructions.content, {}) : undefined;
-
-    const session = new AiSession();
-    const result = yield* session
-      .run({
-        prompt: promptText,
-        system: systemText,
-        blueprints,
-        objects: objects as Obj.Any[],
-        toolkit,
-        observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'agent' })),
-      })
-      .pipe(Effect.provide(AiService.model(data.model ?? DEFAULT_MODEL)));
-    const lastBlock = result
-      .at(-1)
-      ?.blocks.filter((block) => block._tag === 'text')
-      .at(-1);
-
-    return {
-      note: lastBlock?.text,
-    };
-  }),
-});
+import { PromptError } from '../../errors';
+import * as Chat from '../../types/Chat';
+import { AgentPrompt } from './definitions';
+
+const DEFAULT_MODEL: ModelName = '@anthropic/claude-opus-4-6';
+
+export default AgentPrompt.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* (data) {
+        log.info('processing input', { input: data.input });
+
+        const input = yield* Ref.isRef(data.input)
+          ? Database.load(data.input).pipe(Effect.map(Obj.toJSON))
+          : Effect.succeed(data.input);
+
+        yield* Database.flush();
+        const prompt = yield* Database.load(data.prompt);
+        yield* Trace.emitStatus(`Running ${prompt.id}`);
+
+        log.info('starting agent', { prompt: prompt.id, input });
+
+        const blueprints = yield* Function.pipe(
+          prompt.blueprints,
+          Effect.forEach(Database.loadOption),
+          Effect.map(Array.filter(Option.isSome)),
+          Effect.map(Array.map((option) => option.value)),
+        );
+
+        const objects = yield* Function.pipe(
+          prompt.context,
+          Effect.forEach(Database.loadOption),
+          Effect.map(Array.filter(Option.isSome)),
+          Effect.map(Array.map((option) => option.value)),
+        );
+
+        const promptInstructions = yield* Database.load(prompt.instructions.source);
+        let promptText = Template.process(promptInstructions.content, input);
+
+        if (input !== undefined) {
+          promptText += `\n<input>${JSON.stringify(input)}</input>`;
+        }
+
+        let systemText = trim`
+          You are an agent running in the non-interactive mode.
+          The user is unable to see what you are doing, and cannot answer any questions.
+          Do not ask questions.
+          Complete the task before you, and at the end call [completeJob] with the output.
+          If you are unable to complete the task, call [completeJob] with the failure reason.
+          If no output is required, call [completeJob] with an empty object: {}
+          Do not stop until you call [completeJob].
+        `;
+        if (data.systemInstructions) {
+          systemText += `\n\n${data.systemInstructions}`;
+        }
+
+        const modelLayer = AiService.model(data.model ?? DEFAULT_MODEL);
+
+        let feed: Feed.Feed;
+        if (data.chat) {
+          const chat = yield* Database.load(data.chat);
+          invariant(Obj.instanceOf(Chat.Chat, chat), 'Expected Chat object.');
+          feed = yield* Database.load(chat.feed);
+        } else {
+          feed = yield* Database.add(Feed.make());
+        }
+
+        const resultSink = yield* Deferred.make<unknown, PromptError>();
+        const promptToolkit = makePromptAgentToolkit({
+          output: Schema.Any, // TODO(dmaretskyi): Use prompt's output schema.
+          resultSink,
+        });
+
+        const runtime = yield* Effect.runtime<Feed.FeedService>();
+        const session = yield* acquireReleaseResource(() => new AiSession({ feed, runtime }));
+
+        yield* Effect.promise(() =>
+          session.context.bind({
+            blueprints: blueprints.map((blueprint) => Ref.make(blueprint)),
+            objects: objects.map((object) => Ref.make(object as Obj.Unknown)),
+          }),
+        );
+
+        yield* session
+          .createRequest({
+            prompt: promptText,
+            system: systemText,
+            toolkit: promptToolkit,
+          })
+          .pipe(
+            Effect.provide(
+              Layer.mergeAll(modelLayer, ToolExecutionService({ feed }), makeToolResolverFromOperations()),
+            ),
+          );
+
+        return yield* Deferred.poll(resultSink).pipe(
+          Effect.flatten,
+          Effect.flatten,
+          Effect.catchTag('NoSuchElementException', () =>
+            Effect.gen(function* () {
+              yield* session
+                .createRequest({
+                  prompt: 'You must signal task completion by calling [completeJob] with the output or failure reason.',
+                  system: systemText,
+                  toolkit: promptToolkit,
+                })
+                .pipe(
+                  Effect.provide(
+                    Layer.mergeAll(modelLayer, ToolExecutionService({ feed }), makeToolResolverFromOperations()),
+                  ),
+                );
+
+              return yield* Deferred.poll(resultSink).pipe(
+                Effect.flatten,
+                Effect.flatten,
+                Effect.catchTag('NoSuchElementException', () =>
+                  Effect.fail(new PromptError('Agent did not signal task completion.', {})),
+                ),
+              );
+            }),
+          ),
+        );
+      },
+      Effect.scoped,
+      Effect.provide(Trace.writerLayerNoop),
+    ),
+  ),
+  Operation.opaqueHandler,
+);
+
+const makePromptAgentToolkit = (options: {
+  output: Schema.Schema.Any;
+  resultSink: Deferred.Deferred<unknown, PromptError>;
+}) => {
+  class PromptAgentToolkit extends Toolkit.make(
+    Tool.make('completeJob', {
+      parameters: {
+        success: Schema.optional(Schema.Any), // TODO(dmaretskyi): Pipe output schema here.
+        failure: Schema.optional(
+          Schema.Struct({
+            message: Schema.String.annotations({
+              description: 'Short message describing the error.',
+            }),
+            description: Schema.optional(Schema.String).annotations({
+              description: 'Optional longer message describing in detail what went wrong',
+            }),
+          }),
+        ),
+      },
+    }),
+  ) {}
+  const layer = PromptAgentToolkit.toLayer({
+    completeJob: Effect.fnUntraced(function* (result) {
+      if (result.failure) {
+        yield* Deferred.fail(
+          options.resultSink,
+          new PromptError(result.failure.message, {
+            description: result.failure.description,
+          }),
+        );
+      } else {
+        yield* Deferred.succeed(options.resultSink, result.success);
+      }
+    }),
+  });
+
+  return OpaqueToolkit.make(PromptAgentToolkit, layer);
+};
+
+interface ToolExecutionServiceOptions {
+  feed: Feed.Feed;
+}
+
+const ToolExecutionService = ({ feed }: ToolExecutionServiceOptions) =>
+  Layer.unwrapEffect(
+    Effect.gen(function* () {
+      const operationInvoker = yield* Operation.Service;
+      return makeToolExecutionService({
+        invoke: (tool, input) =>
+          Effect.gen(function* () {
+            const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
+            log('invoking operation', { operationDef, input });
+            const result = yield* operationInvoker
+              .invoke(operationDef, input, {
+                conversation: Obj.getDXN(feed).toString(),
+              })
+              .pipe(Effect.orDie);
+            log('result', { result });
+            return result;
+          }),
+      });
+    }),
+  );

package/src/functions/entity-extraction/definitions.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+import { Database, Obj } from '@dxos/echo';
+import { QueueService, Trace } from '@dxos/functions';
+import { Operation, OperationRegistry } from '@dxos/operation';
+import { Message } from '@dxos/types';
+
+export const EntityExtraction = Operation.make({
+  meta: {
+    key: 'org.dxos.functions.entity-extraction',
+    name: 'Entity Extraction',
+    description: 'Extracts entities from emails and transcripts.',
+  },
+  input: Schema.Struct({
+    source: Message.Message.annotations({
+      description: 'Email or transcript to extract entities from.',
+    }),
+    // TODO(dmaretskyi): Consider making this an array of blueprints instead.
+    instructions: Schema.optional(Schema.String).annotations({
+      description: 'Instructions extraction process.',
+    }),
+  }),
+  output: Schema.Struct({
+    entities: Schema.optional(
+      Schema.Array(Obj.Unknown).annotations({
+        description: 'Extracted entities.',
+      }),
+    ),
+  }),
+  services: [AiService.AiService, Database.Service, QueueService, Trace.TraceService, OperationRegistry.Service],
+});