@dxos/plugin-assistant 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/src/operations/run-prompt-in-new-chat.ts

@@ -6,108 +6,108 @@ import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { getObjectPathFromObject, LayoutOperation } from '@dxos/app-toolkit';
-import { AiContextBinder } from '@dxos/assistant';
+import { AiContext } from '@dxos/assistant';
 import { AgentPrompt } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt, Template } from '@dxos/blueprints';
+import { Blueprint, Routine, Template, Operation } from '@dxos/compute';
 import { Database, Feed, Filter, Obj, Ref } from '@dxos/echo';
 import { createFeedServiceLayer } from '@dxos/echo-db';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { Text } from '@dxos/schema';
 
-import { AssistantCapabilities } from '../types';
-import { CreateChat, RunPromptInNewChat } from './definitions';
+import { AssistantCapabilities, AssistantOperation } from '#types';
 
-const handler: Operation.WithHandler<typeof RunPromptInNewChat> = RunPromptInNewChat.pipe(
-  Operation.withHandler(
-    Effect.fnUntraced(
-      function* ({ db, prompt, objects, blueprints, background }) {
-        const registry = yield* Capability.get(Capabilities.AtomRegistry);
-        const { object: chat } = yield* Operation.invoke(CreateChat, { db });
+const handler: Operation.WithHandler<typeof AssistantOperation.RunPromptInNewChat> =
+  AssistantOperation.RunPromptInNewChat.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(
+        function* ({ db, prompt, objects, blueprints, background }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const { object: chat } = yield* Operation.invoke(AssistantOperation.CreateChat, { db });
 
-        if ((objects && objects.length > 0) || (blueprints && blueprints.length > 0)) {
-          const feedTarget = chat.feed.target;
-          invariant(feedTarget, 'Chat feed not found.');
-          const client = yield* Capability.get(ClientCapabilities.Client);
-          const space = client.spaces.get(db.spaceId);
-          invariant(space, 'Space not found.');
-          const feedServiceLayer = createFeedServiceLayer(space.queues);
-          const runtime = yield* Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer));
-          const binder = new AiContextBinder({ feed: feedTarget, runtime, registry });
-          yield* Effect.promise(() =>
-            binder.use(async (b: AiContextBinder) => {
-              const bindingProps: Parameters<AiContextBinder['bind']>[0] = {};
+          if ((objects && objects.length > 0) || (blueprints && blueprints.length > 0)) {
+            const feedTarget = chat.feed.target;
+            invariant(feedTarget, 'Chat feed not found.');
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = client.spaces.get(db.spaceId);
+            invariant(space, 'Space not found.');
+            const feedServiceLayer = createFeedServiceLayer(space.queues);
+            const runtime = yield* Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer));
+            const binder = new AiContext.Binder({ feed: feedTarget, runtime, registry });
+            yield* Effect.promise(() =>
+              binder.use(async (b: AiContext.Binder) => {
+                const bindingProps: Parameters<AiContext.Binder['bind']>[0] = {};
 
-              if (objects && objects.length > 0) {
-                bindingProps.objects = objects.map((obj) => Ref.make(obj));
-              }
+                if (objects && objects.length > 0) {
+                  bindingProps.objects = objects.map((obj) => Ref.make(obj));
+                }
 
-              if (blueprints && blueprints.length > 0) {
-                const allBlueprints = await db.query(Filter.type(Blueprint.Blueprint)).run();
-                const matchedBlueprints = allBlueprints.filter(
-                  (blueprint) => blueprint.key && blueprints.includes(blueprint.key),
-                );
-                if (matchedBlueprints.length > 0) {
-                  bindingProps.blueprints = matchedBlueprints.map((blueprint) => Ref.make(blueprint));
+                if (blueprints && blueprints.length > 0) {
+                  const allBlueprints = await db.query(Filter.type(Blueprint.Blueprint)).run();
+                  const matchedBlueprints = allBlueprints.filter((blueprint) => {
+                    const blueprintKey = Obj.getMeta(blueprint).key;
+                    return blueprintKey !== undefined && blueprints.includes(blueprintKey);
+                  });
+                  if (matchedBlueprints.length > 0) {
+                    bindingProps.blueprints = matchedBlueprints.map((blueprint) => Ref.make(blueprint));
+                  }
                 }
-              }
 
-              await b.bind(bindingProps);
-            }),
-          );
-        }
+                await b.bind(bindingProps);
+              }),
+            );
+          }
+
+          if (background) {
+            const promptRef =
+              typeof prompt === 'string'
+                ? Ref.make(
+                    Routine.make({
+                      instructions: prompt,
+                      blueprints: [],
+                      context: [],
+                    }),
+                  )
+                : prompt;
+            yield* Database.flush();
+            const computeRuntime = yield* Capability.get(AutomationCapabilities.ComputeRuntime);
+            const runtime = yield* computeRuntime.getRuntime(db.spaceId).runtimeEffect;
+            yield* Operation.invoke(AgentPrompt, {
+              prompt: promptRef,
+              input: {},
+              chat: Ref.make(chat),
+            }).pipe(
+              Effect.provide(runtime),
+              Effect.catchAll((error) => {
+                log.catch(error);
+                return Effect.void;
+              }),
+            );
+            return { object: chat };
+          }
 
-        if (background) {
-          const promptRef =
+          const chatPath = getObjectPathFromObject(chat);
+          const pendingPromptText =
             typeof prompt === 'string'
-              ? Ref.make(
-                  Prompt.make({
-                    instructions: prompt,
-                    blueprints: [],
-                    context: [],
-                  }),
-                )
-              : prompt;
-          yield* Database.flush();
-          const computeRuntime = yield* Capability.get(AutomationCapabilities.ComputeRuntime);
-          const runtime = yield* computeRuntime.getRuntime(db.spaceId).runtimeEffect;
-          yield* Operation.invoke(AgentPrompt, {
-            prompt: promptRef,
-            input: {},
-            chat: Ref.make(chat),
-          }).pipe(
-            Effect.provide(runtime),
-            Effect.catchAll((error) => {
-              log.catch(error);
-              return Effect.void;
-            }),
-          );
+              ? prompt
+              : yield* Effect.gen(function* () {
+                  const promptObj = yield* Effect.promise(() => prompt.load());
+                  const source = yield* Effect.promise(() => promptObj.instructions.source.load());
+                  invariant(Obj.instanceOf(Text.Text, source), 'Prompt template source must be Text.');
+                  return Template.process(source.content ?? '');
+                });
+          yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
+            ...current,
+            pendingPrompts: { ...current.pendingPrompts, [chatPath]: pendingPromptText },
+          }));
+          yield* Operation.invoke(LayoutOperation.Open, { subject: [chatPath] });
           return { object: chat };
-        }
-
-        const chatPath = getObjectPathFromObject(chat);
-        const pendingPromptText =
-          typeof prompt === 'string'
-            ? prompt
-            : yield* Effect.gen(function* () {
-                const promptObj = yield* Effect.promise(() => prompt.load());
-                const source = yield* Effect.promise(() => promptObj.instructions.source.load());
-                invariant(Obj.instanceOf(Text.Text, source), 'Prompt template source must be Text.');
-                return Template.process(source.content ?? '');
-              });
-        yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
-          ...current,
-          pendingPrompts: { ...current.pendingPrompts, [chatPath]: pendingPromptText },
-        }));
-        yield* Operation.invoke(LayoutOperation.Open, { subject: [chatPath] });
-        return { object: chat };
-      },
-      (effect, { db }) => effect.pipe(Effect.provide(Database.layer(db))),
+        },
+        (effect, { db }) => effect.pipe(Effect.provide(Database.layer(db))),
+      ),
     ),
-  ),
-);
+  );
 
 export default handler;

package/src/operations/set-current-chat.ts

@@ -5,13 +5,12 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
 
-import { AssistantCapabilities } from '../types';
-import { CreateChat, SetCurrentChat } from './definitions';
+import { AssistantCapabilities, AssistantOperation } from '#types';
 
-const handler: Operation.WithHandler<typeof SetCurrentChat> = SetCurrentChat.pipe(
+const handler: Operation.WithHandler<typeof AssistantOperation.SetCurrentChat> = AssistantOperation.SetCurrentChat.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ companionTo, chat }) {
       const companionToId = Obj.getDXN(companionTo).toString();
@@ -29,7 +28,7 @@ const handler: Operation.WithHandler<typeof SetCurrentChat> = SetCurrentChat.pip
         const db = Obj.getDatabase(companionTo);
         if (db) {
           const { data } = yield* Effect.promise(() =>
-            operationInvoker.invokePromise(CreateChat, { db, addToSpace: false }),
+            operationInvoker.invokePromise(AssistantOperation.CreateChat, { db, addToSpace: false }),
           );
           if (data?.object) {
             yield* Capabilities.updateAtomValue(AssistantCapabilities.CompanionChatCache, (current) => ({

package/src/operations/update-chat-name.ts

@@ -7,15 +7,15 @@ import * as Prompt from '@effect/ai/Prompt';
 import * as Effect from 'effect/Effect';
 
 import { AiPreprocessor, AiService } from '@dxos/ai';
+import { Operation } from '@dxos/compute';
 import { Database, Feed, Filter, Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
 import { Message } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { UpdateChatName } from './definitions';
+import { AssistantOperation } from '#types';
 
-const handler: Operation.WithHandler<typeof UpdateChatName> = UpdateChatName.pipe(
+const handler: Operation.WithHandler<typeof AssistantOperation.UpdateChatName> = AssistantOperation.UpdateChatName.pipe(
   Operation.withHandler(
     Effect.fnUntraced(
       function* ({ chat }) {
@@ -48,7 +48,7 @@ const handler: Operation.WithHandler<typeof UpdateChatName> = UpdateChatName.pip
 
         const newName = response.text.replaceAll(/[^a-zA-Z0-9\s]/g, '').trim();
 
-        Obj.change(chat, (chat) => {
+        Obj.update(chat, (chat) => {
           chat.name = newName;
         });
         log.info('chat name updated', { chat, newName: chat.name });

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/presets.ts

@@ -6,7 +6,7 @@ import * as Schema from 'effect/Schema';
 
 import { type ModelName } from '@dxos/ai';
 
-const ModelProviders = ['dxos-local', 'dxos-remote', 'lm-studio'] as const;
+const ModelProviders = ['dxos-local', 'dxos-remote', 'lm-studio', 'ollama'] as const;
 
 const ModelProvider = Schema.Literal(...ModelProviders);
 type ModelProvider = Schema.Schema.Type<typeof ModelProvider>;
@@ -27,16 +27,24 @@ const createModelLabel = (model: ModelName) => {
 export const AiServicePresets: AiServicePreset[] = [
   {
     provider: 'dxos-remote' as const,
-    model: '@anthropic/claude-opus-4-0' as const,
+    model: '@anthropic/claude-opus-4-6' as const,
   },
   {
     provider: 'dxos-remote' as const,
-    model: '@anthropic/claude-sonnet-4-0' as const,
+    model: '@anthropic/claude-sonnet-4-5' as const,
   },
   {
     provider: 'dxos-remote' as const,
     model: '@anthropic/claude-3-5-haiku-20241022' as const,
   },
+  {
+    provider: 'ollama' as const,
+    model: 'gpt-oss:20b' as const,
+  },
+  {
+    provider: 'ollama' as const,
+    model: 'gemma4:latest' as const,
+  },
   {
     provider: 'lm-studio' as const,
     model: '@google/gemma-3-27b' as const,

package/src/processor/processor.test.ts

@@ -6,12 +6,12 @@ import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as ManagedRuntime from 'effect/ManagedRuntime';
 
-import { AiConversation } from '@dxos/assistant';
+import { AiSession } from '@dxos/assistant';
 import { Chat } from '@dxos/assistant-toolkit';
-import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { Database, Feed } from '@dxos/echo';
 import { acquireReleaseResource } from '@dxos/effect';
 import { TestHelpers } from '@dxos/effect/testing';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
 import { AiChatProcessor } from './processor';
 
@@ -25,11 +25,11 @@ describe('Chat processor', () => {
         const feed = Feed.make();
         yield* Database.add(feed);
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation({ feed, runtime }));
+        const session = yield* acquireReleaseResource(() => new AiSession.Session({ feed, runtime }));
         const managedRuntime = ManagedRuntime.make(
           Effect.runSync(Effect.map(Effect.context<never>(), () => undefined as any)) as any,
         );
-        const processor = new AiChatProcessor(conversation, managedRuntime as any, feed);
+        const processor = new AiChatProcessor(session, managedRuntime as any, feed);
         expect(processor).toBeDefined();
         expect(processor.active).toBeDefined();
       },

package/src/processor/processor.ts

@@ -8,53 +8,37 @@ 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 } from '@dxos/ai';
 import {
-  type AiService,
-  DEFAULT_EDGE_MODEL,
-  type ModelName,
-  type ModelRegistry,
-  type ToolExecutionService,
-  type ToolResolverService,
-} from '@dxos/ai';
-import {
-  AiContextService,
-  type AiConversation,
+  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 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 { type AutomationCapabilities } from '@dxos/plugin-automation';
 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
-  | FunctionInvocationService
   | AiService.AiService
-  | ToolExecutionService
-  | ToolResolverService
-  | TracingService
   | Trace.TraceService;
 
 export type AiChatProcessorOptions = {
@@ -80,11 +64,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;
 };
 
 /**
@@ -107,7 +91,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);
@@ -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.Session,
     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> {
@@ -160,14 +151,14 @@ 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.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();
     }
@@ -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,11 +249,18 @@ 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 })));
+    unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(AssistantOperation.UpdateChatName, { chat })));
   }
 
   /**
@@ -301,6 +303,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).
    */
@@ -331,6 +347,6 @@ export class AiChatProcessor {
 
     // TODO(dmaretskyi): Operation.schedule didn't work.
     log.info('scheduling chat name update', { hasName: !!chat.name, chance });
-    return Operation.schedule(UpdateChatName, { chat });
+    return Operation.schedule(AssistantOperation.UpdateChatName, { chat });
   }
 }