@dxos/plugin-assistant 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/paths.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createTypeSectionPaths } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+
+const { getSectionPath: getChatsPath, getObjectPath: getChatPath } = createTypeSectionPaths(Chat.Chat);
+
+export { getChatsPath, getChatPath };

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const AssistantPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { AssistantOperationHandlerSet } from './operations';

package/src/processor/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './presets';
+export * from './processor';

package/src/processor/presets.ts

@@ -0,0 +1,72 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { type ModelName } from '@dxos/ai';
+
+const ModelProviders = ['dxos-local', 'dxos-remote', 'lm-studio', 'ollama'] as const;
+
+const ModelProvider = Schema.Literal(...ModelProviders);
+type ModelProvider = Schema.Schema.Type<typeof ModelProvider>;
+
+export type AiServicePreset = {
+  id: string;
+  provider: ModelProvider;
+  model: ModelName;
+  label?: string;
+};
+
+const createModelLabel = (model: ModelName) => {
+  const parts = model.split('.');
+  return parts[parts.length - 1];
+};
+
+// TODO(burdon): Users should be able to create and edit presets.
+export const AiServicePresets: AiServicePreset[] = [
+  // Sonnet is first so it is the default selection.
+  {
+    provider: 'dxos-remote' as const,
+    model: 'ai.claude.model.claude-sonnet-4-6' as const,
+    label: 'Claude Sonnet',
+  },
+  {
+    provider: 'dxos-remote' as const,
+    model: 'ai.claude.model.claude-opus-4-8' as const,
+    label: 'Claude Opus',
+  },
+  {
+    provider: 'dxos-remote' as const,
+    model: 'ai.claude.model.claude-haiku-4-5' as const,
+    label: 'Claude Haiku',
+  },
+  {
+    provider: 'ollama' as const,
+    model: 'ai.ollama.model.gpt-oss:20b' as const,
+  },
+  {
+    provider: 'ollama' as const,
+    model: 'ai.ollama.model.gemma4:latest' as const,
+  },
+  {
+    provider: 'lm-studio' as const,
+    model: 'ai.google.model.gemma-3-27b' as const,
+  },
+  {
+    provider: 'lm-studio' as const,
+    model: 'ai.meta.model.llama-3.2-3b-instruct' as const,
+  },
+  {
+    model: 'ai.ollama.model.deepseek-r1:latest' as const,
+    provider: 'dxos-local' as const,
+  },
+].map(
+  ({ model, provider, label }, i) =>
+    ({
+      id: `preset-${i}`,
+      provider,
+      model,
+      label: label ?? createModelLabel(model),
+    }) satisfies AiServicePreset,
+);

package/src/processor/processor.node.test.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+
+import { Capabilities } from '@dxos/app-framework';
+import { AiSession } from '@dxos/assistant';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Database, Feed } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+import { TestHelpers } from '@dxos/effect/testing';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
+
+import { AiChatProcessor } from './processor';
+
+const TestLayer = AssistantTestLayer({ tracing: 'noop', types: [Chat.Chat, Feed.Feed] });
+
+describe('Chat processor', () => {
+  it.scoped(
+    'basic',
+    Effect.fn(
+      function* ({ expect }) {
+        const feed = Feed.make();
+        yield* Database.add(feed);
+        const runtime = yield* Effect.runtime<Feed.FeedService>();
+        const session = yield* EffectEx.acquireReleaseResource(() => new AiSession.Session({ feed, runtime }));
+        const managedRuntime = ManagedRuntime.make(Layer.empty) as unknown as Capabilities.ProcessManagerRuntime;
+        const processor = new AiChatProcessor(session, managedRuntime, feed, Layer.empty as any);
+        expect(processor).toBeDefined();
+        expect(processor.active).toBeDefined();
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/processor/processor.ts

@@ -0,0 +1,423 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom, Registry as AtomRegistry } from '@effect-atom/atom-react';
+import * as AiError from '@effect/ai/AiError';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Fiber from 'effect/Fiber';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Stream from 'effect/Stream';
+
+import { type AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry, type OpaqueToolkit } from '@dxos/ai';
+import { Capabilities } from '@dxos/app-framework';
+import {
+  AiContext,
+  AiSession,
+  createSystemPrompt,
+  formatSystemPrompt,
+  McpServerError,
+  PartialBlock,
+  ToolExecutionServices,
+} from '@dxos/assistant';
+import { type Chat } from '@dxos/assistant-toolkit';
+import { type Credential, Operation, type ServiceNotAvailableError, Trace } from '@dxos/compute';
+import { type Database, Feed, Obj, Ref, type Registry } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+import { AgentService } from '@dxos/functions-runtime';
+import { log } from '@dxos/log';
+import { Message } from '@dxos/types';
+
+import { AssistantOperation } from '#types';
+
+/**
+ * @deprecated Services type for the old direct-conversation processor path.
+ * Retained for backward compatibility with CLI and update-name.
+ */
+export type AiChatServices =
+  | Credential.CredentialsService
+  | Database.Service
+  | AiService.AiService
+  | Trace.TraceService;
+
+/**
+ * Space-scoped services materialised by the layer passed into
+ * {@link AiChatProcessor}. Mirrors the tag list that
+ * {@link useChatProcessor} passes to {@link ServiceResolver.provide}.
+ */
+export type SpaceServices =
+  | Database.Service
+  | Feed.FeedService
+  | Credential.CredentialsService
+  | AiService.AiService
+  | AgentService.AgentService
+  | Registry.Service
+  | OpaqueToolkit.OpaqueToolkitProvider;
+
+export type AiChatProcessorOptions = {
+  model?: ModelName;
+  modelRegistry?: ModelRegistry;
+  registry?: Registry.Registry;
+  observableRegistry?: AtomRegistry.Registry;
+  /**
+   * For tracing.
+   */
+  chat?: Ref.Ref<Chat.Chat>;
+  system?: string;
+};
+
+const defaultOptions: Partial<AiChatProcessorOptions> = {
+  model: DEFAULT_EDGE_MODEL,
+};
+
+export type ProcessorRequestOptions = {};
+
+export type ProcessorRequest = {
+  message: string;
+  options?: ProcessorRequestOptions;
+};
+
+/**
+ * Maps a failure from the agent fiber to an error suitable for display.
+ * {@link AiError}s originate from the AI service and are actionable by the user
+ * (e.g., "model 'x' not found", "Connection refused"), so their detail is propagated.
+ * Any other failure is treated as an internal/unexpected error and reported generically
+ * to avoid leaking implementation detail.
+ */
+const parseError = (err: unknown): Error => {
+  let message: string | undefined;
+  if (AiError.isAiError(err)) {
+    message = err.description?.trim() || err.message;
+  } else if (typeof err === 'string') {
+    // TODO(burdon): This is brittle.
+    // UnknownError: ChatCompletionsClient.streamText: model 'gemma3:27b' not found
+    const [, model] = err.match(/model\s+'([^']+)'\s+not\s+found/i) || [];
+    if (model) {
+      message = `The model is not available: ${model}`;
+    }
+  }
+
+  if (!message) {
+    message = 'An unexpected error occurred.';
+  }
+
+  return new Error(message, { cause: err });
+};
+
+/**
+ * Handles interactions with the AI service.
+ * Uses AgentService to spawn a process-backed agent and subscribes to ephemeral trace events for streaming.
+ */
+export class AiChatProcessor {
+  readonly #registry: AtomRegistry.Registry;
+
+  /** Pending messages (finalized, non-streaming). */
+  readonly #pending = Atom.make<Message.Message[]>([]);
+
+  /** Currently streaming messages (from ephemeral trace events). */
+  readonly #streaming = Atom.make<Message.Message[]>([]);
+
+  /** Set of message IDs that have been finalized (non-pending delivered via ephemeral). */
+  readonly #finalizedIds = new Set<string>();
+
+  /** Currently active request fiber. */
+  #requestFiber: Fiber.RuntimeFiber<void, unknown> | undefined;
+
+  /** Last request (for retries). */
+  #lastRequest: ProcessorRequest | undefined;
+
+  /** Streaming state. */
+  public readonly streaming = Atom.make<boolean>((get) => get(this.#streaming).length > 0);
+
+  /** Active state. */
+  public readonly active = Atom.make(false);
+
+  /** Array of Messages (incl. the current message being streamed). */
+  public readonly messages = Atom.make<Message.Message[]>((get) => [...get(this.#pending), ...get(this.#streaming)]);
+
+  /** Last error. */
+  public readonly error = Atom.make<Option.Option<Error>>(Option.none());
+
+  /**
+   * MCP server connection errors observed during the most recent request.
+   * Misconfigured/unreachable servers are dropped from the toolkit so the chat
+   * keeps working; the entries here let the UI display which servers failed.
+   */
+  public readonly mcpErrors = Atom.make<readonly Trace.PayloadType<typeof McpServerError>[]>([]);
+
+  constructor(
+    private readonly _conversation: AiSession.Session,
+    private readonly _runtime: Capabilities.ProcessManagerRuntime,
+    private readonly _feed: Feed.Feed,
+    /**
+     * Pre-built layer that materialises {@link SpaceServices}. Built via
+     * {@link ServiceResolver.provide} with the {@link ServiceResolver} already
+     * supplied (hence `RIn = never`); the {@link ServiceNotAvailableError}
+     * error channel surfaces when a tag is not available for the space.
+     * Provided to every effect run by the processor so the underlying
+     * {@link ProcessManagerRuntime} has access to space-affinity services.
+     */
+    private readonly _spaceLayer: Layer.Layer<SpaceServices, ServiceNotAvailableError, never>,
+    private readonly _options: AiChatProcessorOptions = defaultOptions,
+  ) {
+    this.#registry = this._options.observableRegistry ?? AtomRegistry.make();
+    if (this._options.model && !this._options.system) {
+      const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
+      this._options.system = createSystemPrompt(capabilities);
+    }
+  }
+
+  get context() {
+    return this._conversation.context;
+  }
+
+  get conversation() {
+    return this._conversation;
+  }
+
+  get registry() {
+    return this._options.registry;
+  }
+
+  get system(): string {
+    return this._options.system ?? '';
+  }
+
+  async getTools(): Promise<Record<string, any>> {
+    return this._runtime.runPromise(
+      Effect.provide(this._conversation.getTools(), ToolExecutionServices).pipe(Effect.provide(this._spaceLayer)),
+    );
+  }
+
+  async getSystemPrompt(): Promise<string> {
+    return this._runtime.runPromise(
+      Effect.gen(this, function* () {
+        const blueprints = this.context.getBlueprints();
+        const objects = this.context.getObjects();
+        return yield* formatSystemPrompt({ system: this._options.system, blueprints, objects });
+      }).pipe(
+        Effect.provideService(AiContext.Service, { binder: this.context }),
+        Effect.provide(this._spaceLayer),
+        Effect.orDie,
+      ),
+    );
+  }
+
+  /**
+   * Initiates a new request via AgentService.
+   */
+  async request(requestProp: ProcessorRequest): Promise<void> {
+    if (this.#requestFiber) {
+      await this.cancel();
+    }
+
+    try {
+      this.#lastRequest = requestProp;
+      this.#registry.set(this.error, Option.none());
+      this.#registry.set(this.mcpErrors, []);
+      this.#registry.set(this.active, true);
+
+      const effect = Effect.gen(this, function* () {
+        // NOTE: Gets or creates a session for the feed.
+        log.info('init agent session', { feed: Obj.getURI(this._feed), model: this._options.model });
+        const session = yield* AgentService.getSession(this._feed, { model: this._options.model });
+        const ephemeralStream = session.subscribeEphemeral();
+        yield* ephemeralStream.pipe(
+          Stream.runForEach((message) =>
+            Effect.sync(() => {
+              for (const event of message.events) {
+                if (Trace.isOfType(PartialBlock, event)) {
+                  this.#handleEphemeralMessage(event.data);
+                } else if (Trace.isOfType(McpServerError, event)) {
+                  this.#handleMcpError(event.data);
+                }
+              }
+            }),
+          ),
+          Effect.fork,
+        );
+
+        log('chat processor submitting prompt', { length: requestProp.message.length });
+        yield* session.submitPrompt(requestProp.message);
+        log('chat processor submitPrompt returned, waiting for agent', {});
+
+        // On the first message (no name yet), schedule rename immediately so it
+        // runs concurrently with the AI response rather than waiting for completion.
+        if (!this._options.chat?.target?.name) {
+          yield* this.#updateChatName(requestProp.message);
+        }
+
+        yield* session.waitForCompletion();
+        log.info('session complete');
+
+        this.#flushStreaming();
+      });
+
+      this.#requestFiber = this._runtime.runFork(effect.pipe(Effect.provide(this._spaceLayer)));
+
+      // Inspect the fiber's exit so the underlying failure (e.g. "model 'x' not found") is
+      // preserved as a clean Error rather than an opaque FiberFailure.
+      const exit = await this._runtime.runPromise(Fiber.await(this.#requestFiber));
+      if (Exit.isFailure(exit)) {
+        if (Cause.isInterruptedOnly(exit.cause)) {
+          return;
+        }
+
+        throw EffectEx.causeToError(exit.cause);
+      }
+
+      this.#registry.set(this.error, Option.none());
+      this.#lastRequest = undefined;
+      this.#requestFiber = undefined;
+    } catch (err) {
+      // `EffectEx.causeToError` above unwraps the fiber failure into the underlying error (e.g. an AiError
+      // carrying "model 'x' not found"); `parseError` decides what to surface to the user.
+      log.error('request failed', { error: err });
+      this.#registry.set(this.error, Option.some(parseError(err)));
+    } finally {
+      log.info('setting active to false');
+      this.#registry.set(this.active, false);
+      this.#requestFiber = undefined;
+    }
+  }
+
+  /**
+   * Cancels the current request.
+   */
+  async cancel(): Promise<void> {
+    await EffectEx.runAndForwardErrors(
+      Effect.gen(this, function* () {
+        log.info('cancelling request', { fiber: this.#requestFiber });
+        if (this.#requestFiber) {
+          yield* Fiber.interrupt(this.#requestFiber);
+        }
+        const session = yield* AgentService.getSession(this._feed);
+        yield* session.terminate();
+      }).pipe(Effect.provide(this._spaceLayer)),
+    );
+
+    this.#requestFiber = undefined;
+    this.#registry.set(this.active, false);
+  }
+
+  /**
+   * Retry last failed request.
+   */
+  async retry(): Promise<void> {
+    if (this.#lastRequest) {
+      return this.request(this.#lastRequest);
+    }
+  }
+
+  /**
+   * Clears the recorded MCP server errors (e.g. after the user dismisses the warning banner).
+   */
+  dismissMcpErrors(): void {
+    this.#registry.set(this.mcpErrors, []);
+  }
+
+  /**
+   * Update the current chat's name.
+   */
+  async updateName(chat: Chat.Chat): Promise<void> {
+    const spaceId = Obj.getDatabase(chat)?.spaceId;
+    if (!spaceId) {
+      return;
+    }
+    EffectEx.unwrapExit(
+      await this._runtime.runPromiseExit(
+        Operation.invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId }).pipe(
+          Effect.provide(this._spaceLayer),
+        ),
+      ),
+    );
+  }
+
+  /**
+   * Handles an ephemeral message from the agent process.
+   * Both pending and completed blocks arrive here. Completed blocks are deduped
+   * against messages already written to the feed queue to handle the race between
+   * ephemeral delivery and feed replication.
+   */
+  #handleEphemeralMessage(event: Trace.PayloadType<typeof PartialBlock>) {
+    const isPending = event.block.pending;
+    const message = Obj.make(Message.Message, {
+      id: event.messageId,
+      created: new Date().toISOString(),
+      sender: { role: event.role },
+      blocks: [event.block],
+    });
+
+    if (isPending) {
+      if (this.#finalizedIds.has(event.messageId)) {
+        return;
+      }
+      this.#registry.update(this.#streaming, (streaming) => {
+        const idx = streaming.findIndex((existing) => existing.id === event.messageId);
+        if (idx >= 0) {
+          const updated = [...streaming];
+          updated[idx] = message;
+          return updated;
+        }
+        return [...streaming, message];
+      });
+    } else {
+      this.#finalizedIds.add(event.messageId);
+      this.#registry.update(this.#streaming, (streaming) => streaming.filter((existing) => existing.id !== message.id));
+      this.#registry.update(this.#pending, (pending) => {
+        if (pending.some((existing) => existing.id === message.id)) {
+          return pending;
+        }
+        return [...pending, message];
+      });
+    }
+  }
+
+  /**
+   * Records a per-server MCP failure, deduped by url+protocol so repeat misconfigurations
+   * across turns do not spam the UI.
+   */
+  #handleMcpError(event: Trace.PayloadType<typeof McpServerError>) {
+    log.warn('MCP server error', event);
+    this.#registry.update(this.mcpErrors, (errors) => {
+      if (errors.some((existing) => existing.url === event.url && existing.protocol === event.protocol)) {
+        return errors;
+      }
+      return [...errors, event];
+    });
+  }
+
+  /**
+   * Move remaining streaming messages to pending (called when agent completes).
+   */
+  #flushStreaming() {
+    const remaining = this.#registry.get(this.#streaming);
+    if (remaining.length > 0) {
+      this.#registry.update(this.#pending, (pending) => [...pending, ...remaining]);
+      this.#registry.set(this.#streaming, []);
+    }
+    this.#finalizedIds.clear();
+  }
+
+  /**
+   * Schedule a chat name update as a detached (fire-and-forget) operation.
+   * Called automatically on the first message; can also be invoked manually via the toolbar.
+   */
+  #updateChatName(prompt?: string): Effect.Effect<void, never, Operation.Service> {
+    const chat = this._options.chat?.target;
+    if (!chat) {
+      return Effect.void;
+    }
+
+    const spaceId = Obj.getDatabase(chat)?.spaceId;
+    if (!spaceId) {
+      return Effect.void;
+    }
+
+    log.info('scheduling chat name update');
+    return Operation.schedule(AssistantOperation.UpdateChatName, { chat, prompt }, { spaceId });
+  }
+}

package/src/templates/automation-templates.test.ts

@@ -0,0 +1,66 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { describe, test } from 'vitest';
+
+import { Operation, Routine, Trace, Trigger } from '@dxos/compute';
+import { Database, Filter, Obj, Query } from '@dxos/echo';
+import { TestDatabaseLayer } from '@dxos/echo-client/testing';
+import { EffectEx } from '@dxos/effect';
+import { Automation } from '@dxos/plugin-automation';
+
+import { dailyDigest } from './daily-digest';
+import { researchBrief } from './research-brief';
+
+const dbLayer = TestDatabaseLayer({
+  types: [Automation.Automation, Routine.Routine, Trigger.Trigger, Operation.PersistentOperation],
+});
+
+const TestLayer = Layer.mergeAll(dbLayer, Trace.writerLayerNoop);
+
+const templates = [
+  { template: researchBrief, blueprintCount: 4 },
+  { template: dailyDigest, blueprintCount: 3 },
+];
+
+describe('scheduled automation templates', () => {
+  test('apply globally (no subject required)', ({ expect }) => {
+    // Like Blank, these are offered in the global create dialog — no `appliesTo` gate.
+    expect(researchBrief.appliesTo).toBeUndefined();
+    expect(dailyDigest.appliesTo).toBeUndefined();
+  });
+
+  for (const { template, blueprintCount } of templates) {
+    test(`${template.label} scaffolds a Routine, a disabled timer Trigger, and an Automation`, async ({ expect }) => {
+      await Effect.gen(function* () {
+        const automation = yield* template.scaffold({});
+        yield* Database.add(automation);
+        yield* Database.flush();
+
+        expect(automation.triggers).toHaveLength(1);
+        expect(automation.runnable).toBeDefined();
+
+        const routines = yield* Database.query(Filter.type(Routine.Routine)).run;
+        expect(routines).toHaveLength(1);
+        expect(routines[0]?.blueprints).toHaveLength(blueprintCount);
+
+        const triggers = yield* Database.query(Query.select(Filter.type(Trigger.Trigger))).run;
+        expect(triggers).toHaveLength(1);
+        const trigger = triggers[0];
+        expect(trigger?.enabled).toBe(false);
+        expect(trigger?.spec?.kind).toBe('timer');
+        expect(trigger?.input?.prompt).toBeDefined();
+        // The trigger is owned by the automation (cascade-deletes with it); the routine stays independent.
+        expect(trigger && Obj.getParent(trigger)?.id).toBe(automation.id);
+        expect(routines[0] && Obj.getParent(routines[0])).toBeUndefined();
+
+        const operations = yield* Database.query(Filter.type(Operation.PersistentOperation)).run;
+        expect(operations).toHaveLength(1);
+        expect(automation.runnable?.uri).toBe(trigger?.function?.uri);
+      }).pipe(Effect.provide(TestLayer), EffectEx.runAndForwardErrors);
+    });
+  }
+});

package/src/templates/daily-digest.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type AutomationCapabilities } from '@dxos/plugin-automation';
+
+import { makeScheduledRoutineAutomation } from './scaffold';
+
+/** Inbox supplies new messages; database queries recent objects; markdown writes the digest document. */
+const BLUEPRINT_KEYS = [
+  'org.dxos.blueprint.inbox',
+  'org.dxos.blueprint.database',
+  'org.dxos.blueprint.markdown',
+] as const;
+
+/** Runs daily by default; the user edits the schedule and the scope by opening the trigger and routine. */
+const DEFAULT_CRON = '0 9 * * *';
+
+const DEFAULT_INSTRUCTIONS = `\
+Summarize recent activity in this space into a markdown document.
+
+Review new messages in the inbox and recently changed objects. Produce a short digest grouped by theme,
+highlight anything that needs attention, and write it to a markdown document titled with the current date.
+`;
+
+export const dailyDigest: AutomationCapabilities.Template = {
+  id: 'org.dxos.automation.dailyDigest',
+  label: 'Daily Digest',
+  icon: 'ph--list-bullets--regular',
+  scaffold: ({ name }) =>
+    makeScheduledRoutineAutomation({
+      name: name ?? 'Daily Digest',
+      instructions: DEFAULT_INSTRUCTIONS,
+      blueprintKeys: BLUEPRINT_KEYS,
+      cron: DEFAULT_CRON,
+    }),
+};

package/src/templates/index.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type AutomationCapabilities } from '@dxos/plugin-automation';
+
+import { dailyDigest } from './daily-digest';
+import { researchBrief } from './research-brief';
+
+/** Generic, subject-less automation templates contributed alongside plugin-automation's Blank. */
+export const automationTemplates: AutomationCapabilities.Template[] = [researchBrief, dailyDigest];