@dxos/assistant-toolkit 0.8.4-main.3c1ae3b → 0.8.4-main.3fbcb4aa9b

package/src/crud/graph.ts

@@ -13,6 +13,8 @@ import * as SchemaAST from 'effect/SchemaAST';
 
 import { Entity, Filter, Obj, Query, Type } from '@dxos/echo';
 import { Database } from '@dxos/echo';
+import { type Queue } from '@dxos/echo-db';
+import { isEncodedReference } from '@dxos/echo-protocol';
 import {
   ReferenceAnnotationId,
   RelationSourceDXNId,
@@ -23,8 +25,6 @@ import {
   getTypeAnnotation,
   getTypeIdentifierAnnotation,
 } from '@dxos/echo/internal';
-import { type EchoDatabase, type Queue } from '@dxos/echo-db';
-import { isEncodedReference } from '@dxos/echo-protocol';
 import { mapAst } from '@dxos/effect';
 import { ContextQueueService } from '@dxos/functions';
 import { DXN, ObjectId } from '@dxos/keys';
@@ -40,7 +40,7 @@ export const Subgraph = Schema.Struct({
 export interface Subgraph extends Schema.Schema.Type<typeof Subgraph> {}
 
 export type RelatedSchema = {
-  schema: Schema.Schema.AnyNoContext;
+  schema: Type.AnyEntity;
   kind: 'reference' | 'relation';
 };
 
@@ -51,12 +51,9 @@ export type RelatedSchema = {
  * @param schema
  * @returns
  */
-export const findRelatedSchema = async (
-  db: EchoDatabase,
-  anchor: Schema.Schema.AnyNoContext,
-): Promise<RelatedSchema[]> => {
+export const findRelatedSchema = async (db: Database.Database, anchor: Type.AnyEntity): Promise<RelatedSchema[]> => {
   // TODO(dmaretskyi): Query stored schemas.
-  const allSchemas = [...db.graph.schemaRegistry.schemas];
+  const allSchemas = await db.graph.schemaRegistry.query().run();
 
   // TODO(dmaretskyi): Also do references.
   return allSchemas
@@ -72,8 +69,8 @@ export const findRelatedSchema = async (
     })
     .map(
       (schema): RelatedSchema => ({
-        schema,
         kind: 'relation',
+        schema,
       }),
     );
 };
@@ -82,7 +79,7 @@ export const findRelatedSchema = async (
  * Non-strict DXN comparison.
  * Returns true if the DXN could be resolved to the schema.
  */
-const isSchemaAddressableByDxn = (schema: Schema.Schema.AnyNoContext, dxn: DXN): boolean => {
+const isSchemaAddressableByDxn = (schema: Type.AnyEntity, dxn: DXN): boolean => {
   if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
     return true;
   }
@@ -115,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);
@@ -139,14 +136,14 @@ export const LocalSearchHandler = LocalSearchToolkit.toLayer({
 class GraphWriterSchema extends Context.Tag('@dxos/assistant/GraphWriterSchema')<
   GraphWriterSchema,
   {
-    schema: Schema.Schema.AnyNoContext[];
+    schema: Type.AnyEntity[];
   }
 >() {}
 
 /**
  * Forms typed objects that can be written to the graph database.
  */
-export const makeGraphWriterToolkit = ({ schema }: { schema: Schema.Schema.AnyNoContext[] }) => {
+export const makeGraphWriterToolkit = ({ schema }: { schema: Type.AnyEntity[] }) => {
   return Toolkit.make(
     Tool.make('graph_writer', {
       description: 'Write to the local graph database',
@@ -176,7 +173,7 @@ export const makeGraphWriterHandler = (
       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.Any[]));
+      yield* Effect.promise(() => queue.append(data as Obj.Unknown[]));
 
       const dxns = data.map((obj) => Obj.getDXN(obj));
       onAppend?.(dxns);
@@ -188,7 +185,7 @@ export const makeGraphWriterHandler = (
 /**
  * Create a schema for structured data extraction.
  */
-export const createExtractionSchema = (types: Schema.Schema.AnyNoContext[]) => {
+export const createExtractionSchema = (types: Type.AnyEntity[]) => {
   return Schema.Struct({
     ...Object.fromEntries(
       types.map(preprocessSchema).map((schema, index) => [
@@ -201,18 +198,18 @@ export const createExtractionSchema = (types: Schema.Schema.AnyNoContext[]) => {
   });
 };
 
-export const getSanitizedSchemaName = (schema: Schema.Schema.AnyNoContext) => {
+export const getSanitizedSchemaName = (schema: Type.AnyEntity) => {
   return Type.getDXN(schema)!
     .asTypeDXN()!
     .type.replaceAll(/[^a-zA-Z0-9]+/g, '_');
 };
 
 export const sanitizeObjects = async (
-  types: Schema.Schema.AnyNoContext[],
+  types: Type.AnyEntity[],
   data: Record<string, readonly unknown[]>,
   db: Database.Database,
   queue?: Queue,
-): Promise<Obj.Any[]> => {
+): Promise<Obj.Unknown[]> => {
   const entries = types
     .map(
       (type) =>

package/src/errors.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { BaseError } from '@dxos/errors';
+import { DXN } from '@dxos/keys';
+
+/**
+ * Agent could not execute prompt.
+ */
+export class PromptError extends BaseError.extend('PromptError') {
+  constructor(
+    message: string,
+    context: {
+      description?: string;
+      prompt?: DXN.String;
+      chat?: DXN.String;
+    },
+  ) {
+    super({
+      message,
+      context,
+    });
+  }
+}

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,56 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { AiService, OpaqueToolkit, ModelName } from '@dxos/ai';
+import { Routine, Trace, Operation, OperationRegistry } from '@dxos/compute';
+import { Database, Feed, Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+
+import * as Chat from '../../types/Chat';
+
+// TODO(dmaretskyi): Rename to RunRoutine.
+export const AgentPrompt = Operation.make({
+  meta: {
+    key: 'org.dxos.function.prompt',
+    name: 'Run Routine',
+    description: 'Agentic worker that executes a provided prompt using blueprints and tools.',
+  },
+  input: Schema.Struct({
+    prompt: Ref.Ref(Routine.Routine),
+
+    /**
+     * When set, runs in this chat (history, queue, and bound context). Routine blueprints and context objects are merged into the conversation for this request.
+     */
+    chat: Schema.optional(Ref.Ref(Chat.Chat)),
+
+    /**
+     * @default @anthropic/claude-opus-4-6
+     */
+
+    model: Schema.optional(ModelName),
+    /**
+     * Input object or data.
+     * References get auto-resolved.
+     */
+    input: Schema.Any.pipe(Schema.annotations({ title: 'Input' })),
+
+    systemInstructions: Schema.optional(Schema.String).annotations({
+      description: 'Additional system instructions to add to the system prompt.',
+    }),
+  }),
+  output: Schema.Any,
+  // ECHO types that the handler loads via Database.load(). Declaring them here ensures the
+  // runtime registers their schema before remote invocation (e.g. via the EDGE function service).
+  types: [Routine.Routine, Text.Text, Feed.Feed, Chat.Chat],
+  services: [
+    AiService.AiService,
+    Database.Service,
+    Feed.FeedService,
+    OpaqueToolkit.OpaqueToolkitProvider,
+    OperationRegistry.Service,
+    Trace.TraceService,
+  ],
+}).pipe(Operation.intrinsic);

package/src/functions/agent/index.ts

@@ -2,10 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type FunctionDefinition } from '@dxos/functions';
+import { OperationHandlerSet } from '@dxos/compute';
 
-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.conversations.json

@@ -0,0 +1 @@
+{"conversations":[{"parameters":{"model":"@anthropic/claude-opus-4-6","stream":true,"tools":[{"name":"completeJob","inputSchema":{"type":"object","required":[],"properties":{"success":{"$id":"/schemas/any","title":"any"},"failure":{"type":"object","required":["message"],"properties":{"message":{"type":"string","description":"Short message describing the error."},"description":{"type":"string","description":"Optional longer message describing in detail what went wrong"}},"additionalProperties":false}},"additionalProperties":false}}]},"prompt":{"content":[{"role":"system","content":"You are an agent running in the non-interactive mode.\nThe user is unable to see what you are doing, and cannot answer any questions.\nDo not ask questions.\nComplete the task before you, and at the end call [completeJob] with the output.\nIf you are unable to complete the task, call [completeJob] with the failure reason.\nIf no output is required, call [completeJob] with an empty object: {}\nDo not stop until you call [completeJob].","options":{}},{"role":"user","content":"Reply with a single word: ack.\n<input>{}</input>","options":{"anthropic":{"cacheControl":{"ttl":"5m","type":"ephemeral"}}}}]},"response":[{"type":"response-metadata","id":"msg_01BNfgUBNqETGfNka6Y58SUS","modelId":"claude-opus-4-6","timestamp":"1970-01-01T00:00:00.000Z","metadata":{}},{"type":"reasoning-start","id":"0","metadata":{}},{"type":"reasoning-delta","id":"0","delta":"The","metadata":{}},{"type":"reasoning-delta","id":"0","delta":" user wants me to reply with a single word \"ack\" and complete the job.","metadata":{}},{"type":"reasoning-delta","id":"0","delta":"","metadata":{"anthropic":{"type":"thinking","signature":"EoQCClkIDRgCKkDmvWuElJmvgQqKv/OM8h45Qm9vFiau8OtHTiKeFGzABfFt5k5Oc9XiWXg1jeCrSXFmAcI3XEaKXp6jF8PCj/O0Mg9jbGF1ZGUtb3B1cy00LTY4ABIMidROWDebGP+ji8voGgyiyrnCLJU9DZTeWc0iMJ5ewfC96fa6DHSOj+APcM0VyN0tJiYPjIJI7DxYTiu277zCDVNdAUxNb/k45dQGripZikOeASjJaTuovSm8Ni01mepSojCietSMDfM1xBLbnyPHKxucO7akJRwDczuw8req/NjtOhY492FCt1lagajkZq8/rsICFxutxbPXyHXSY04cd/2+oY9cRAQYAQ=="}}},{"type":"reasoning-end","id":"0","metadata":{}},{"type":"tool-params-start","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","name":"completeJob","providerExecuted":false,"metadata":{}},{"type":"tool-params-delta","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","delta":"","metadata":{}},{"type":"tool-params-delta","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","delta":"{\"success","metadata":{}},{"type":"tool-params-delta","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","delta":"\": \"ack\"}","metadata":{}},{"type":"tool-params-end","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","metadata":{}},{"type":"finish","reason":"tool-calls","usage":{"inputTokens":757,"outputTokens":89,"totalTokens":846},"metadata":{"anthropic":{"usage":{"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":757,"output_tokens":9,"server_tool_use":null,"service_tier":"standard"}}}}]},{"parameters":{"model":"@anthropic/claude-opus-4-6","stream":true,"tools":[{"name":"completeJob","inputSchema":{"type":"object","required":[],"properties":{"success":{"$id":"/schemas/any","title":"any"},"failure":{"type":"object","required":["message"],"properties":{"message":{"type":"string","description":"Short message describing the error."},"description":{"type":"string","description":"Optional longer message describing in detail what went wrong"}},"additionalProperties":false}},"additionalProperties":false}}]},"prompt":{"content":[{"role":"system","content":"You are an agent running in the non-interactive mode.\nThe user is unable to see what you are doing, and cannot answer any questions.\nDo not ask questions.\nComplete the task before you, and at the end call [completeJob] with the output.\nIf you are unable to complete the task, call [completeJob] with the failure reason.\nIf no output is required, call [completeJob] with an empty object: {}\nDo not stop until you call [completeJob].","options":{}},{"role":"user","content":"Reply with a single word: ack.\n<input>{}</input>","options":{}},{"role":"assistant","content":[{"type":"reasoning","text":"The user wants me to reply with a single word \"ack\" and complete the job.","options":{}},{"type":"tool-call","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","name":"completeJob","params":{"success":"ack"},"providerExecuted":false,"options":{}}],"options":{}},{"role":"tool","content":[{"type":"tool-result","id":"toolu_01VQiUHtyF77TZd49DrKhnPR","name":"completeJob","isFailure":false,"result":{},"providerExecuted":false,"options":{}}],"options":{"anthropic":{"cacheControl":{"ttl":"5m","type":"ephemeral"}}}}]},"response":[{"type":"response-metadata","id":"msg_017Q7gpzDqQTqmKWouYU2oKt","modelId":"claude-opus-4-6","timestamp":"1970-01-01T00:00:00.000Z","metadata":{}},{"type":"finish","reason":"stop","usage":{"inputTokens":824,"outputTokens":2,"totalTokens":826},"metadata":{"anthropic":{"usage":{"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"input_tokens":824,"output_tokens":2,"server_tool_use":null,"service_tier":"standard"}}}}]}]}

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

@@ -0,0 +1,81 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { ContextBinding } from '@dxos/assistant';
+import { Routine, Operation, OperationHandlerSet } from '@dxos/compute';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { QueueService } from '@dxos/functions';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
+import { ObjectId } from '@dxos/keys';
+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(
+          Routine.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,116 +2,223 @@
 // 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 { Database } from '@dxos/echo';
-import { TracingService, defineFunction } from '@dxos/functions';
+import { AiService, OpaqueToolkit, ModelName } from '@dxos/ai';
+import {
+  AiSession,
+  getOperationFromTool,
+  makeToolExecutionService,
+  makeToolResolverFromOperations,
+} from '@dxos/assistant';
+import { Template, Trace, Operation } from '@dxos/compute';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
+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* Database.Service.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* Database.Service.load(ref);
-          return Obj.toJSON(object as Obj.Any);
-        }),
-      ),
-      Match.orElse(() => Effect.succeed(data.input)),
-    );
-
-    yield* Database.Service.flush({ indexes: true });
-    const prompt = yield* Database.Service.load(data.prompt);
-    const systemPrompt = data.systemPrompt ? yield* Database.Service.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.Service.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.Service.loadOption),
-      Effect.map(Array.filter(Option.isSome)),
-      Effect.map(Array.map((option) => option.value)),
-    );
-    const toolkit = yield* createToolkit({ blueprints });
-
-    const promptInstructions = yield* Database.Service.load(prompt.instructions.source);
-    const promptText = Template.process(promptInstructions.content, input);
-
-    const systemInstructions = systemPrompt
-      ? yield* Database.Service.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.tapBoth({
+        onSuccess: () => Database.flush(),
+        onFailure: () => Database.flush(),
+      }),
+      Effect.scoped,
+    ),
+  ),
+  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;
+          }),
+      });
+    }),
+  );