@dxos/plugin-assistant 0.8.4-main.72ec0f3 → 0.8.4-main.765dc60934

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,70 +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 { AiServiceTestingPreset } from '@dxos/ai/testing';
-import { AiConversation, makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
-import { TestHelpers, acquireReleaseResource } from '@dxos/effect';
-import { CredentialsService, QueueService, TracingService } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTestMocked, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
-import { type Message } from '@dxos/types';
+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 { 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): Create minimal toolkit.
-const toolkit = Toolkit.merge(TestToolkit) as Toolkit.Toolkit<any>;
-
-// 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'),
-  makeToolResolverFromFunctions([], toolkit),
-  makeToolExecutionServiceFromFunctions(toolkit, toolkit.toLayer({}) as any),
-  CredentialsService.layerFromDatabase(),
-).pipe(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.Session({ 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,
     ),
   );
 });