@dxos/assistant 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/src/service/AgentService.test.ts

@@ -0,0 +1,169 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Registry } from '@effect-atom/atom';
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import * as Stream from 'effect/Stream';
+import { expect } from 'vitest';
+
+import { Blueprint } from '@dxos/blueprints';
+import { Feed } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { Trace } from '@dxos/functions';
+import { Process } from '@dxos/functions-runtime';
+import { ObjectId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { Operation, OperationHandlerSet } from '@dxos/operation';
+import { Organization } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+import { AssistantTestLayer } from '../testing';
+import { PartialBlock } from '../tracing';
+import * as AgentService from './AgentService';
+
+ObjectId.dangerouslyDisableRandomness();
+
+//
+// Test data.
+//
+
+const TEST_DATA = {
+  organizations: [
+    Organization.make({
+      name: 'Cyberdyne Systems',
+      website: 'https://cyberdyne.com',
+    }),
+    Organization.make({
+      name: 'Acme Robotics',
+      website: 'https://acmerobotics.example',
+    }),
+    Organization.make({
+      name: 'Globex Research',
+      website: 'https://globex.example',
+    }),
+  ],
+  research: {
+    'https://cyberdyne.com': `
+      Cyberdyne Systems is a company that builds AI agents.
+      They are based in San Francisco, California.
+      They were founded in 1984.
+      They are a public company.
+      They are listed on the NASDAQ under the symbol CYBR.
+      They are a member of the S&P 500 index.
+    `,
+    'https://acmerobotics.example': `
+      Acme Robotics designs industrial automation and collaborative robots.
+      They are headquartered in Austin, Texas.
+      They were founded in 2010.
+      They serve manufacturing and logistics customers worldwide.
+    `,
+    'https://globex.example': `
+      Globex Research runs applied R&D labs focused on materials science and energy storage.
+      They are based in Cambridge, Massachusetts.
+      They partner with universities and government grants programs.
+      Their flagship product line is solid-state battery prototypes for EVs.
+    `,
+  } as Record<string, string>,
+};
+
+const Research = Operation.make({
+  meta: {
+    key: 'org.dxos.function.research',
+    name: 'Research',
+    description: 'Research an organization',
+  },
+  input: Schema.Struct({
+    website: Schema.String.annotations({ description: 'The website of the organization to research' }),
+  }),
+  output: Schema.String,
+});
+
+const handlers = OperationHandlerSet.make(
+  Research.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* ({ website }) {
+        log.info('begin research', { website });
+        yield* Effect.sleep(
+          15_000 * (TEST_DATA.organizations.findIndex((organization) => organization.website === website) + 1),
+        );
+        log.info('end research', { website });
+        return TEST_DATA.research[website];
+      }),
+    ),
+  ),
+);
+
+const ResearchBlueprint = Blueprint.make({
+  key: 'org.dxos.blueprint.research',
+  name: 'Research',
+  tools: Blueprint.toolDefinitions({ operations: [Research] }),
+});
+
+//
+// Test layer: AI services + toolkit.
+//
+
+const SYSTEM_PROMPT = trim`
+  You are reacting to a continuous stream of organizations.
+  Research each organization.
+  Research takes a while to complete.
+  Do not block on the research since there might be more organizations to research, and we want research to happen in parallel.
+  Do not wait longer then 3 seconds to keep the conversation open for new events or user queries.
+  Do internal reasoning, but only show the answers to the user.
+`;
+
+const TestLayer = AssistantTestLayer({
+  types: [Organization.Organization, Feed.Feed, Blueprint.Blueprint],
+  tracing: 'console',
+  aiServicePreset: 'edge-remote',
+  operationHandlers: [handlers],
+  blueprints: [ResearchBlueprint],
+  systemPrompt: SYSTEM_PROMPT,
+});
+
+describe('Agent Executable', () => {
+  // TODO(dmaretskyi): Figure out how to make it not sleep for 45 seconds.
+  it.scoped.skip(
+    'runs AI agent with background tools via process manager',
+    Effect.fnUntraced(
+      function* (_) {
+        const registry = yield* Registry.AtomRegistry;
+        const monitor = yield* Process.ProcessMonitorService;
+        registry.subscribe(monitor.processTreeAtom, (tree) => {
+          console.log(`\n----- Process tree -----\n${Process.prettyProcessTree(tree)}\n-----------------\n`);
+        });
+
+        const agent = yield* AgentService.createSession({
+          blueprints: [ResearchBlueprint],
+        });
+
+        let ephemeralEventCount = 0;
+        yield* agent.subscribeEphemeral().pipe(
+          Stream.runForEach((msg) =>
+            Effect.gen(function* () {
+              for (const event of msg.events) {
+                if (Trace.isOfType(PartialBlock, event)) {
+                  ephemeralEventCount++;
+                }
+              }
+            }),
+          ),
+          Effect.fork,
+        );
+
+        for (const org of TEST_DATA.organizations) {
+          yield* agent.submitPrompt(JSON.stringify(org));
+        }
+        yield* agent.submitPrompt('When all research is complete, print 1-sentence summary for each organization.');
+        yield* agent.waitForCompletion();
+        expect(ephemeralEventCount).toBeGreaterThan(0);
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 120_000 },
+  );
+});

package/src/service/AgentService.ts

@@ -0,0 +1,184 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Stream from 'effect/Stream';
+
+import { ModelName } from '@dxos/ai';
+import { Blueprint } from '@dxos/blueprints';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { type Trace } from '@dxos/functions';
+import { ProcessManager } from '@dxos/functions-runtime';
+
+import { type McpServerConfig, AiContextBinder } from '../conversation';
+import { AgentProcess } from './agent-process';
+
+export interface Service {
+  /**
+   * Gets or creates a session for a feed.
+   */
+  getSession: (feed: Feed.Feed, options?: GetSessionOptions) => Effect.Effect<Session>;
+}
+
+export class AgentService extends Context.Tag('@dxos/assistant/AgentService')<AgentService, Service>() {}
+
+/**
+ * Handle to an agent session.
+ */
+export interface Session {
+  /**
+   * The feed that the session is associated with.
+   */
+  readonly feed: Feed.Feed;
+
+  /**
+   * Submits a prompt to the agent.
+   */
+  submitPrompt: (prompt: string) => Effect.Effect<void>;
+
+  /**
+   * Wait until agent has completed its work.
+   */
+  waitForCompletion: () => Effect.Effect<void>;
+
+  /**
+   * Subscribe to ephemeral trace events (e.g., streaming partial messages).
+   * Replays buffered events, then streams new ones until the process ends.
+   */
+  subscribeEphemeral: () => Stream.Stream<Trace.Message>;
+
+  /**
+   * Adds context objects to the agent.
+   */
+  addContext: (context: Ref.Ref<Obj.Unknown>[]) => Effect.Effect<void, never, Feed.FeedService>;
+
+  /**
+   * Gets the context objects from the agent.
+   */
+  getContext: () => Effect.Effect<Ref.Ref<Obj.Unknown>[], never, Feed.FeedService>;
+}
+
+/**
+ * Gets or creates a session for a feed.
+ */
+export const getSession = Effect.serviceFunctionEffect(AgentService, (service) => service.getSession);
+
+export interface GetSessionOptions {
+  readonly model?: ModelName;
+}
+
+export interface CreateSessionOptions {
+  readonly blueprints?: Blueprint.Blueprint[];
+  readonly context?: Ref.Ref<Obj.Unknown>[];
+  readonly model?: ModelName;
+}
+
+export const createSession: (
+  opts?: CreateSessionOptions,
+) => Effect.Effect<
+  Session,
+  Blueprint.NotFoundError,
+  Database.Service | Feed.FeedService | Blueprint.RegistryService | AgentService
+> = Effect.fn('createSession')(function* (opts) {
+  const blueprints = yield* Effect.forEach(opts?.blueprints ?? [], (blueprint) =>
+    Blueprint.upsert(blueprint.key).pipe(Effect.map(Ref.make)),
+  );
+
+  const feed = yield* Database.add(Feed.make());
+  const runtime = yield* Effect.runtime<Feed.FeedService>();
+  const binder = yield* acquireReleaseResource(() => new AiContextBinder({ feed, runtime }));
+
+  yield* Effect.promise(() =>
+    binder.bind({
+      blueprints,
+      objects: opts?.context ?? [],
+    }),
+  );
+
+  return yield* getSession(feed, { model: opts?.model });
+}, Effect.scoped);
+
+export const layer = (opts?: {
+  systemPrompt?: string;
+  /**
+   * Default model used by sessions that don't specify one explicitly.
+   */
+  model?: ModelName;
+
+  /**
+   * Provider for space-level MCP server configs.
+   */
+  getMcpServers?: () => McpServerConfig[];
+}): Layer.Layer<AgentService, never, ProcessManager.ProcessManagerService> =>
+  Layer.effect(
+    AgentService,
+    Effect.gen(function* () {
+      const processManager = yield* ProcessManager.ProcessManagerService;
+      const sessionCache = new Map<string, Session>();
+
+      return {
+        getSession: (feed: Feed.Feed, options?: GetSessionOptions) =>
+          Effect.gen(function* () {
+            const cached = sessionCache.get(feed.id);
+            if (cached) {
+              return cached;
+            }
+
+            const target = Obj.getDXN(feed).toString();
+            const executable = AgentProcess({
+              systemPrompt: opts?.systemPrompt,
+              model: options?.model ?? opts?.model,
+              getMcpServers: opts?.getMcpServers,
+            });
+            const processes = yield* processManager.list({ target, key: executable.key });
+
+            let handle: ProcessManager.Handle<string, void>;
+            if (processes.length > 0) {
+              handle = processes[0];
+            } else {
+              handle = yield* processManager.spawn(executable, {
+                name: 'agent',
+                target,
+                traceMeta: {
+                  conversationId: feed.id,
+                },
+              });
+            }
+
+            const session = makeSession(handle, feed);
+            sessionCache.set(feed.id, session);
+            return session;
+          }),
+      };
+    }),
+  );
+
+const makeSession = (process: ProcessManager.Handle<string, void>, feed: Feed.Feed): Session => ({
+  feed,
+  submitPrompt: (prompt: string) => process.submitInput(prompt),
+  waitForCompletion: () => process.runToCompletion(),
+  subscribeEphemeral: () => process.subscribeEphemeral(),
+  addContext: (context: Ref.Ref<Obj.Unknown>[]) =>
+    Effect.gen(function* () {
+      const runtime = yield* Effect.runtime<Feed.FeedService>();
+      const binder = yield* acquireReleaseResource(() => new AiContextBinder({ feed, runtime }));
+      yield* Effect.promise(() =>
+        binder.bind({
+          blueprints: [],
+          objects: context,
+        }),
+      );
+    }).pipe(Effect.scoped),
+  getContext: () =>
+    Effect.gen(function* () {
+      const runtime = yield* Effect.runtime<Feed.FeedService>();
+      const binder = yield* acquireReleaseResource(() => new AiContextBinder({ feed, runtime }));
+      return binder.getObjects().map((object) => Ref.make(object));
+    }).pipe(Effect.scoped),
+});