@dxos/plugin-assistant 0.8.4-main.422d1c7879 → 0.8.4-main.4668b7de9b

package/src/processor/processor.ts

@@ -2,50 +2,69 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom, Registry } from '@effect-atom/atom-react';
+import { Atom, Registry as AtomRegistry } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
 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 } from '@dxos/ai';
+import { type AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry, type OpaqueToolkit } from '@dxos/ai';
+import { Capabilities } from '@dxos/app-framework';
 import {
-  AiContextService,
-  type AiSession,
+  AiContext,
+  AiSession,
   createSystemPrompt,
   formatSystemPrompt,
-  AgentService,
+  McpServerError,
   PartialBlock,
   ToolExecutionServices,
 } from '@dxos/assistant';
 import { type Chat } from '@dxos/assistant-toolkit';
-import { type Blueprint } from '@dxos/blueprints';
-import { type Database, Feed, Obj, Ref } from '@dxos/echo';
+import {
+  type Credential,
+  Operation,
+  type OperationRegistry,
+  type ServiceNotAvailableError,
+  Trace,
+} from '@dxos/compute';
+import { type Database, Feed, Obj, Ref, type Registry } from '@dxos/echo';
 import { runAndForwardErrors, unwrapExit } from '@dxos/effect';
-import { Trace, type CredentialsService, type QueueService } from '@dxos/functions';
+import { AgentService } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
-import type { AutomationCapabilities } from '@dxos/plugin-automation/types';
 import { Message } from '@dxos/types';
 
-import { UpdateChatName } from '../operations/definitions';
+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 =
-  | CredentialsService
+  | Credential.CredentialsService
   | Database.Service
-  | QueueService
   | 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
+  | OperationRegistry.Service
+  | OpaqueToolkit.OpaqueToolkitProvider;
+
 export type AiChatProcessorOptions = {
   model?: ModelName;
   modelRegistry?: ModelRegistry;
-  blueprintRegistry?: Blueprint.Registry;
-  observableRegistry?: Registry.Registry;
+  registry?: Registry.Registry;
+  observableRegistry?: AtomRegistry.Registry;
   /**
    * For tracing.
    */
@@ -64,11 +83,11 @@ const defaultOptions: Partial<AiChatProcessorOptions> = {
   autoUpdateNameChance: 0.1,
 };
 
-export type AiRequestOptions = {};
+export type ProcessorRequestOptions = {};
 
-export type AiRequest = {
+export type ProcessorRequest = {
   message: string;
-  options?: AiRequestOptions;
+  options?: ProcessorRequestOptions;
 };
 
 /**
@@ -76,7 +95,7 @@ export type AiRequest = {
  * Uses AgentService to spawn a process-backed agent and subscribes to ephemeral trace events for streaming.
  */
 export class AiChatProcessor {
-  readonly #registry: Registry.Registry;
+  readonly #registry: AtomRegistry.Registry;
 
   /** Pending messages (finalized, non-streaming). */
   readonly #pending = Atom.make<Message.Message[]>([]);
@@ -91,7 +110,7 @@ export class AiChatProcessor {
   #requestFiber: Fiber.RuntimeFiber<void, unknown> | undefined;
 
   /** Last request (for retries). */
-  #lastRequest: AiRequest | undefined;
+  #lastRequest: ProcessorRequest | undefined;
 
   /** Streaming state. */
   public readonly streaming = Atom.make<boolean>((get) => get(this.#streaming).length > 0);
@@ -105,13 +124,29 @@ export class AiChatProcessor {
   /** 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,
-    private readonly _runtime: AutomationCapabilities.ComputeRuntime,
+    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 ?? Registry.make();
+    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);
@@ -126,8 +161,8 @@ export class AiChatProcessor {
     return this._conversation;
   }
 
-  get blueprintRegistry() {
-    return this._options.blueprintRegistry;
+  get registry() {
+    return this._options.registry;
   }
 
   get system(): string {
@@ -135,7 +170,9 @@ export class AiChatProcessor {
   }
 
   async getTools(): Promise<Record<string, any>> {
-    return this._runtime.runPromise(Effect.provide(this._conversation.getTools(), ToolExecutionServices));
+    return this._runtime.runPromise(
+      Effect.provide(this._conversation.getTools(), ToolExecutionServices).pipe(Effect.provide(this._spaceLayer)),
+    );
   }
 
   async getSystemPrompt(): Promise<string> {
@@ -144,14 +181,18 @@ export class AiChatProcessor {
         const blueprints = this.context.getBlueprints();
         const objects = this.context.getObjects();
         return yield* formatSystemPrompt({ system: this._options.system, blueprints, objects });
-      }).pipe(Effect.provideService(AiContextService, { binder: this.context }), Effect.orDie),
+      }).pipe(
+        Effect.provideService(AiContext.Service, { binder: this.context }),
+        Effect.provide(this._spaceLayer),
+        Effect.orDie,
+      ),
     );
   }
 
   /**
    * Initiates a new request via AgentService.
    */
-  async request(requestProp: AiRequest): Promise<void> {
+  async request(requestProp: ProcessorRequest): Promise<void> {
     if (this.#requestFiber) {
       await this.cancel();
     }
@@ -159,11 +200,12 @@ export class AiChatProcessor {
     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.getDXN(this._feed).toString(), model: this._options.model });
+        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(
@@ -172,6 +214,8 @@ export class AiChatProcessor {
               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);
                 }
               }
             }),
@@ -190,7 +234,7 @@ export class AiChatProcessor {
         yield* this.#maybeUpdateChatName();
       });
 
-      this.#requestFiber = this._runtime.runFork(effect);
+      this.#requestFiber = this._runtime.runFork(effect.pipe(Effect.provide(this._spaceLayer)));
 
       try {
         await this._runtime.runPromise(Fiber.join(this.#requestFiber));
@@ -239,11 +283,28 @@ export class AiChatProcessor {
     }
   }
 
+  /**
+   * 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> {
-    unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(UpdateChatName, { chat })));
+    const spaceId = Obj.getDatabase(chat)?.spaceId;
+    if (!spaceId) {
+      return;
+    }
+    unwrapExit(
+      await this._runtime.runPromiseExit(
+        Operation.invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId }).pipe(
+          Effect.provide(this._spaceLayer),
+        ),
+      ),
+    );
   }
 
   /**
@@ -286,6 +347,20 @@ export class AiChatProcessor {
     }
   }
 
+  /**
+   * 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).
    */
@@ -314,8 +389,12 @@ export class AiChatProcessor {
       return Effect.void;
     }
 
-    // TODO(dmaretskyi): Operation.schedule didn't work.
+    const spaceId = Obj.getDatabase(chat)?.spaceId;
+    if (!spaceId) {
+      return Effect.void;
+    }
+
     log.info('scheduling chat name update', { hasName: !!chat.name, chance });
-    return Operation.schedule(UpdateChatName, { chat });
+    return Operation.schedule(AssistantOperation.UpdateChatName, { chat }, { spaceId });
   }
 }