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

package/src/functions/agent/prompt.ts

@@ -6,96 +6,131 @@ import * as Array from 'effect/Array';
 import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 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 { AiConversation, type ContextBinding, AiSession, GenerationObserver, createToolkit } from '@dxos/assistant';
+import { Template } from '@dxos/blueprints';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { type Queue } from '@dxos/echo-db';
+import { acquireReleaseResource } from '@dxos/effect';
+import { QueueService, Trace, TracingService } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
+import { type Message } from '@dxos/types';
+
+import { AgentPrompt } from './definitions';
+
+import * as Chat from '../../types/Chat';
 
 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.Record({ key: Schema.String, value: Schema.Any }),
-  }),
-  outputSchema: Schema.Any,
-  handler: Effect.fnUntraced(function* ({ data }) {
-    log.info('processing input', { input: data.input });
-
-    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 observer = GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'agent' }));
+
+const lastTextFromMessages = (messages: Message.Message[]): string | undefined => {
+  const blocks = messages.flatMap((message) => message.blocks);
+  for (let index = blocks.length - 1; index >= 0; index--) {
+    const block = blocks[index]!;
+    if (block._tag === 'text') {
+      return block.text;
     }
+  }
+  return undefined;
+};
+
+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);
+        const systemPrompt = data.systemPrompt ? yield* Database.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(Database.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(Database.loadOption),
+          Effect.map(Array.filter(Option.isSome)),
+          Effect.map(Array.map((option) => option.value)),
+        );
+
+        const promptInstructions = yield* Database.load(prompt.instructions.source);
+        const promptText = Template.process(promptInstructions.content, input);
+
+        const systemInstructions = systemPrompt ? yield* Database.load(systemPrompt.instructions.source) : undefined;
+        const systemText = systemInstructions ? Template.process(systemInstructions.content, {}) : undefined;
+
+        const modelLayer = AiService.model(data.model ?? DEFAULT_MODEL);
+
+        if (data.chat) {
+          const chat = yield* Database.load(data.chat);
+          invariant(Obj.instanceOf(Chat.Chat, chat), 'Expected Chat object.');
+          const chatFeed = yield* Database.load(chat.feed);
+          invariant(chatFeed, 'Chat feed not found.');
+          const queueDxn = Feed.getQueueDxn(chatFeed);
+          invariant(queueDxn, 'Feed queue DXN not found.');
+          const chatQueue = yield* QueueService.getQueue(queueDxn);
+
+          const conversation = yield* acquireReleaseResource(
+            () => new AiConversation({ queue: chatQueue as Queue<Message.Message | ContextBinding> }),
+          );
+
+          yield* Effect.promise(() =>
+            conversation.context.bind({
+              blueprints: blueprints.map((blueprint) => Ref.make(blueprint)),
+              objects: objects.map((object) => Ref.make(object as Obj.Unknown)),
+            }),
+          );
+
+          const messages = yield* conversation
+            .createRequest({
+              prompt: promptText,
+              system: systemText,
+              observer,
+            })
+            .pipe(Effect.provide(modelLayer));
+
+          return {
+            note: lastTextFromMessages(messages),
+          };
+        }
+
+        const toolkit = yield* createToolkit({ blueprints });
+
+        const session = new AiSession({ observer });
+        const result = yield* session
+          .run({
+            prompt: promptText,
+            system: systemText,
+            blueprints,
+            objects: objects as Obj.Unknown[],
+            toolkit,
+          })
+          .pipe(Effect.provide(modelLayer));
 
-    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: data.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,
-    };
-  }),
-});
+        return {
+          note: lastTextFromMessages(result),
+        };
+      },
+      Effect.scoped,
+      Effect.provide(Trace.writerLayerNoop),
+    ),
+  ),
+);

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

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+import { Database, Obj } from '@dxos/echo';
+import { FunctionInvocationService, QueueService, TracingService } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+import { Message } from '@dxos/types';
+import { Trace } from '@dxos/functions';
+
+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,
+    TracingService,
+    FunctionInvocationService,
+    QueueService,
+    Trace.TraceService,
+  ],
+});