@dxos/plugin-assistant 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/src/processor/processor.ts

@@ -8,35 +8,23 @@ import * as Fiber from 'effect/Fiber';
 import * as Option from 'effect/Option';
 import * as Stream from 'effect/Stream';
 
-import {
-  type AiService,
-  DEFAULT_EDGE_MODEL,
-  type ModelName,
-  type ModelRegistry,
-  type ToolExecutionService,
-  type ToolResolverService,
-} from '@dxos/ai';
+import { type AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry } from '@dxos/ai';
 import {
   AiContextService,
-  type AiConversation,
+  type 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 Blueprint, type Credential, Trace, Operation } from '@dxos/compute';
 import { type Database, Feed, Obj, Ref } from '@dxos/echo';
 import { runAndForwardErrors, unwrapExit } from '@dxos/effect';
-import {
-  Trace,
-  type CredentialsService,
-  type FunctionInvocationService,
-  type QueueService,
-  type TracingService,
-} from '@dxos/functions';
+import { 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';
 
@@ -47,14 +35,10 @@ import { UpdateChatName } from '../operations/definitions';
  * Retained for backward compatibility with CLI and update-name.
  */
 export type AiChatServices =
-  | CredentialsService
+  | Credential.CredentialsService
   | Database.Service
   | QueueService
-  | FunctionInvocationService
   | AiService.AiService
-  | ToolExecutionService
-  | ToolResolverService
-  | TracingService
   | Trace.TraceService;
 
 export type AiChatProcessorOptions = {
@@ -121,8 +105,15 @@ 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: AiConversation,
+    private readonly _conversation: AiSession,
     private readonly _runtime: AutomationCapabilities.ComputeRuntime,
     private readonly _feed: Feed.Feed,
     private readonly _options: AiChatProcessorOptions = defaultOptions,
@@ -151,7 +142,7 @@ export class AiChatProcessor {
   }
 
   async getTools(): Promise<Record<string, any>> {
-    return this._runtime.runPromise(this._conversation.getTools());
+    return this._runtime.runPromise(Effect.provide(this._conversation.getTools(), ToolExecutionServices));
   }
 
   async getSystemPrompt(): Promise<string> {
@@ -175,11 +166,13 @@ 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.
-        const session = yield* AgentService.getSession(this._feed);
+        log.info('init agent session', { feed: Obj.getDXN(this._feed).toString(), 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) =>
@@ -187,6 +180,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);
                 }
               }
             }),
@@ -254,6 +249,13 @@ 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.
    */
@@ -301,6 +303,20 @@ export class AiChatProcessor {
     }
   }
 
+  /**
+   * Records a per-server MCP failure, deduped by url+kind 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.kind === event.kind)) {
+        return errors;
+      }
+      return [...errors, event];
+    });
+  }
+
   /**
    * Move remaining streaming messages to pending (called when agent completes).
    */

package/src/queue-logger.ts

@@ -4,7 +4,7 @@
 
 import { type Queue, Ref, type Space, getSpace } from '@dxos/client/echo';
 import { type Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
-import { DXN, Key, Obj } from '@dxos/echo';
+import { DXN, Feed, Obj } from '@dxos/echo';
 import { InvocationTraceEndEvent, InvocationTraceEventType, InvocationTraceStartEvent } from '@dxos/functions-runtime';
 import { TraceEvent } from '@dxos/functions-runtime';
 import { InvocationOutcome } from '@dxos/functions-runtime';
@@ -20,15 +20,26 @@ export class QueueLogger implements SequenceLogger {
     const space = getSpace(sequence);
     invariant(space, 'Space not found');
     this._space = space;
-    let dxn = this._space.properties.invocationTraceQueue?.dxn;
-    if (!dxn) {
-      dxn = DXN.fromQueue(QueueSubspaceTags.TRACE, this._space.id, Key.ObjectId.random());
-      const newDxn = dxn;
-      Obj.change(this._space.properties, (obj) => {
-        obj.invocationTraceQueue = Ref.fromDXN(newDxn);
+
+    const existingFeedRef = this._space.properties.invocationTraceFeed;
+    let queueDxn: DXN | undefined;
+
+    if (existingFeedRef) {
+      // A feed reference exists; resolve its queue DXN. If the target isn't loaded yet,
+      // fail loudly rather than silently creating a new feed and orphaning existing traces.
+      invariant(existingFeedRef.target, 'invocationTraceFeed reference is not yet loaded');
+      queueDxn = Feed.getQueueDxn(existingFeedRef.target) ?? undefined;
+      invariant(queueDxn, 'invocationTraceFeed has no queue DXN');
+    } else {
+      const feed = space.db.add(Feed.make({ namespace: 'trace' }));
+      queueDxn = Feed.getQueueDxn(feed) ?? undefined;
+      invariant(queueDxn, 'New invocationTraceFeed has no queue DXN');
+      Obj.update(this._space.properties, (obj) => {
+        obj.invocationTraceFeed = Ref.make(feed);
       });
     }
-    this._invocationTraceQueue = this._space.queues.get(dxn);
+
+    this._invocationTraceQueue = this._space.queues.get(queueDxn);
   }
 
   log(event: SequenceEvent) {