@dxos/plugin-assistant 0.8.4-main.c85a9c8dae → 0.8.4-main.dfabb4ec29

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

@@ -0,0 +1,112 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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 { AgentPrompt } from '@dxos/assistant-toolkit';
+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 { AutomationCapabilities } from '@dxos/plugin-automation';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { Text } from '@dxos/schema';
+
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+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) {
+                  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));
+                  }
+                }
+
+                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 };
+          }
+
+          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))),
+      ),
+    ),
+  );
+
+export default handler;

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

@@ -0,0 +1,49 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+const handler: Operation.WithHandler<typeof AssistantOperation.SetCurrentChat> = AssistantOperation.SetCurrentChat.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ companionTo, chat }) {
+      const companionToId = Obj.getDXN(companionTo).toString();
+
+      if (chat) {
+        const chatId = Obj.getDXN(chat).toString();
+        yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
+          ...current,
+          currentChat: { ...current.currentChat, [companionToId]: chatId },
+        }));
+      } else {
+        // New thread: create a transient chat and cache it so the graph connector
+        // can resolve it immediately via the cache fallback tier.
+        const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
+        const db = Obj.getDatabase(companionTo);
+        if (db) {
+          const { data } = yield* Effect.promise(() =>
+            operationInvoker.invokePromise(AssistantOperation.CreateChat, { db, addToSpace: false }),
+          );
+          if (data?.object) {
+            yield* Capabilities.updateAtomValue(AssistantCapabilities.CompanionChatCache, (current) => ({
+              ...current,
+              [companionToId]: data.object,
+            }));
+          }
+        }
+        yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
+          ...current,
+          currentChat: { ...current.currentChat, [companionToId]: undefined },
+        }));
+      }
+    }),
+  ),
+);
+
+export default handler;

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

@@ -0,0 +1,61 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+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 { Message } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+import { AssistantOperation } from '#types';
+
+const handler: Operation.WithHandler<typeof AssistantOperation.UpdateChatName> = AssistantOperation.UpdateChatName.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({ chat }) {
+        log.info('updating chat name', { chat });
+
+        const feed = yield* Database.load(chat.feed);
+        const history = yield* Feed.runQuery(feed, Filter.type(Message.Message));
+
+        log.info('history', { history: history.length });
+
+        const system = trim`
+          It is extremely important that you respond only with the title and nothing else.
+          Do not use markdown or other formatting.
+          If you cannot do this effectively respond with "New Chat".
+
+          <example_reply>
+          Fishing Trip
+          </example_reply>
+        `;
+        const prompt = 'Suggest a name for this chat';
+
+        const historyPrompt = yield* AiPreprocessor.preprocessPrompt(history, {
+          system,
+          cacheControl: 'ephemeral',
+        });
+
+        const response = yield* LanguageModel.generateText({
+          prompt: Prompt.merge(historyPrompt, prompt),
+        });
+
+        const newName = response.text.replaceAll(/[^a-zA-Z0-9\s]/g, '').trim();
+
+        Obj.update(chat, (chat) => {
+          chat.name = newName;
+        });
+        log.info('chat name updated', { chat, newName: chat.name });
+      },
+      Effect.provide(AiService.model('@anthropic/claude-haiku-4-5')),
+    ),
+  ),
+);
+
+export default handler;

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

@@ -4,4 +4,3 @@
 
 export * from './presets';
 export * from './processor';
-export * from './update-name';

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

@@ -2,72 +2,39 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Schema from 'effect/Schema';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
 
-import { AiService } from '@dxos/ai';
-import { GenericToolkit } from '@dxos/ai';
-import { AiServiceTestingPreset } from '@dxos/ai/testing';
-import { AiConversation, ToolExecutionServices } from '@dxos/assistant';
+import { AiSession } from '@dxos/assistant';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Database, Feed } from '@dxos/echo';
 import { acquireReleaseResource } from '@dxos/effect';
 import { TestHelpers } from '@dxos/effect/testing';
-import { CredentialsService, QueueService, TracingService } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTestMocked, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
-import { type Message } from '@dxos/types';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 
-import { AiChatProcessor, type AiChatServices } from './processor';
+import { AiChatProcessor } from './processor';
 
-const TestToolkit = Toolkit.make(
-  Tool.make('random', {
-    description: 'Random number generator',
-    parameters: {},
-    success: Schema.Number,
-  }),
-);
+const TestLayer = AssistantTestLayer({ tracing: 'noop', types: [Chat.Chat, Feed.Feed] });
 
-// TODO(burdon): Explain structure.
-const TestServicesLayer = Layer.mergeAll(
-  TracingService.layerNoop,
-  AiServiceTestingPreset('direct'),
-  TestDatabaseLayer({
-    // indexing: { vector: true },
-    // types: [],
-  }),
-  // CredentialsService.configuredLayer([{ service: 'exa.ai', apiKey: EXA_API_KEY }]),
-  FunctionInvocationServiceLayerTestMocked({ functions: [] }).pipe(Layer.provideMerge(TracingService.layerNoop)),
-);
-
-const TestLayer: Layer.Layer<AiChatServices, never, never> = Layer.mergeAll(
-  AiService.model('@anthropic/claude-opus-4-0'),
-  ToolExecutionServices,
-  CredentialsService.layerFromDatabase(),
-).pipe(
-  Layer.provideMerge(GenericToolkit.providerLayer(GenericToolkit.make(TestToolkit, TestToolkit.toLayer({} as any)))),
-  Layer.provideMerge(TestServicesLayer),
-  Layer.orDie,
-);
-
-// TODO(burdon): Create actual test with mock LLM.
 describe('Chat processor', () => {
   it.scoped(
     'basic',
     Effect.fn(
       function* ({ expect }) {
-        const services = yield* Effect.runtime<AiChatServices>();
-        const queue = yield* QueueService.createQueue<Message.Message>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation({ queue }));
-        const processor = new AiChatProcessor(conversation, async () => services);
-        const result = yield* Effect.promise(() => processor.request({ message: 'Hello' }));
-        void processor.cancel();
-        expect(processor.active).to.be.false;
-        expect(result).to.exist;
+        const feed = Feed.make();
+        yield* Database.add(feed);
+        const runtime = yield* Effect.runtime<Feed.FeedService>();
+        const session = yield* acquireReleaseResource(() => new AiSession({ feed, runtime }));
+        const managedRuntime = ManagedRuntime.make(
+          Effect.runSync(Effect.map(Effect.context<never>(), () => undefined as any)) as any,
+        );
+        const processor = new AiChatProcessor(session, managedRuntime as any, feed);
+        expect(processor).toBeDefined();
+        expect(processor.active).toBeDefined();
       },
       Effect.provide(TestLayer),
-      TestHelpers.taggedTest('llm'),
+      TestHelpers.provideTestContext,
     ),
   );
 });