@dxos/plugin-assistant 0.9.0 → 0.9.1-staging.ee54ba693a

package/src/feed-logger.ts

@@ -5,27 +5,28 @@
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { createFeedServiceLayer, type Space, getSpace } from '@dxos/client/echo';
+import { type Space, getSpace } from '@dxos/client/echo';
 import { Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
-import { Feed, Obj, Ref } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-client';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
 import { InvocationTraceEndEvent, InvocationTraceEventType, InvocationTraceStartEvent } from '@dxos/functions-runtime';
 import { TraceEvent } from '@dxos/functions-runtime';
 import { InvocationOutcome } from '@dxos/functions-runtime';
 import { invariant } from '@dxos/invariant';
-import { EID, type EntityId } from '@dxos/keys';
+import { type EntityId } from '@dxos/keys';
 
 export class QueueLogger implements SequenceLogger {
   private _space: Space;
   private _invocationTraceFeed: Feed.Feed;
-  private _feedServiceLayer: Layer.Layer<Feed.FeedService>;
+  private _feedServiceLayer: Layer.Layer<Database.Service>;
+  /** Per-invocation trace feeds, keyed by invocationId. Created on `begin` and looked up for subsequent events. */
+  private _invocationFeeds = new Map<EntityId, Feed.Feed>();
 
   constructor(private readonly sequence: Sequence.Sequence) {
     const space = getSpace(sequence);
     invariant(space, 'Space not found');
     this._space = space;
-    this._feedServiceLayer = createFeedServiceLayer(space.queues);
+    this._feedServiceLayer = Database.layer(space.db);
 
     const existingFeedRef = this._space.properties.invocationTraceFeed;
 
@@ -47,18 +48,22 @@ export class QueueLogger implements SequenceLogger {
 
   log(event: SequenceEvent) {
     switch (event.type) {
-      case 'begin':
+      case 'begin': {
+        // Create a per-invocation trace feed and store it so subsequent events can append to it.
+        const invocationFeed = this._space.db.add(Feed.make({ namespace: 'trace' }));
+        this._invocationFeeds.set(event.invocationId, invocationFeed);
         void this._appendToTraceFeed([
           Obj.make(InvocationTraceStartEvent, {
             type: InvocationTraceEventType.START,
             invocationId: event.invocationId,
             timestamp: Date.now(),
             input: {},
-            invocationTraceFeed: Ref.fromURI(this._getTraceQueueEchoId(event.invocationId)),
+            invocationTraceFeed: Ref.make(invocationFeed),
             invocationTarget: Ref.make(this.sequence),
           }),
         ]);
         break;
+      }
       case 'end':
         void this._appendToTraceFeed([
           Obj.make(InvocationTraceEndEvent, {
@@ -68,10 +73,12 @@ export class QueueLogger implements SequenceLogger {
             outcome: InvocationOutcome.SUCCESS,
           }),
         ]);
+        // Clean up the per-invocation feed reference once the invocation is complete.
+        this._invocationFeeds.delete(event.invocationId);
         break;
       case 'step-start':
       case 'step-complete':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendToInvocationFeed(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -89,7 +96,7 @@ export class QueueLogger implements SequenceLogger {
         ]);
         break;
       case 'message':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendToInvocationFeed(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -107,7 +114,7 @@ export class QueueLogger implements SequenceLogger {
         ]);
         break;
       case 'block':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendToInvocationFeed(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -127,10 +134,6 @@ export class QueueLogger implements SequenceLogger {
     }
   }
 
-  private _getTraceQueueEchoId(invocationId: EntityId): EID.EID {
-    return EID.make({ spaceId: this._space.id, entityId: invocationId });
-  }
-
   private _appendToTraceFeed(items: any[]): Promise<void> {
     return Feed.append(this._invocationTraceFeed, items).pipe(
       Effect.provide(this._feedServiceLayer),
@@ -138,12 +141,11 @@ export class QueueLogger implements SequenceLogger {
     );
   }
 
-  // TODO(burdon): The per-invocation trace event queues address feeds by raw queue DXN
-  // (no backing Feed.Feed object). Migration to Feed.append is blocked on either
-  // (a) materializing a Feed object per invocation, or (b) a lower-level
-  // FeedService.appendByDxn primitive. Tracked as Phase 6 work in echo/AUDIT.md.
-  private _getTraceEventQueue(invocationId: EntityId): Queue<TraceEvent> {
-    const echoUri = this._getTraceQueueEchoId(invocationId);
-    return this._space.queues.get(echoUri);
+  private _appendToInvocationFeed(invocationId: EntityId, items: any[]): Promise<void> {
+    const invocationFeed = this._invocationFeeds.get(invocationId);
+    if (!invocationFeed) {
+      return Promise.resolve();
+    }
+    return this._space.db.appendToFeed(invocationFeed, items);
   }
 }

package/src/functions/services.test.ts

@@ -6,12 +6,12 @@ import { describe, test } from 'vitest';
 
 import { LayoutOperation } from '@dxos/app-toolkit';
 import {
-  AgentBlueprintHandlers,
   AgentHandlers,
+  AgentSkillHandlers,
   AgentWizardHandlers,
-  BlueprintManagerHandlers,
   DatabaseHandlers,
   DelegationHandlers,
+  SkillManagerHandlers,
   WebSearchHandlers,
 } from '@dxos/assistant-toolkit';
 import { Operation, OperationHandlerSet } from '@dxos/compute';
@@ -22,8 +22,8 @@ import { AssistantOperationHandlerSet } from '#operations';
 const handlerSet = OperationHandlerSet.merge(
   AssistantOperationHandlerSet,
   AgentHandlers,
-  AgentBlueprintHandlers,
-  BlueprintManagerHandlers,
+  AgentSkillHandlers,
+  SkillManagerHandlers,
   DatabaseHandlers,
   WebSearchHandlers,
   AgentWizardHandlers,

package/src/hooks/index.ts

@@ -3,7 +3,7 @@
 //
 // TODO(wittjosiah): Factor hooks out of plugin-assistant into a standalone package.
 
-export * from './useBlueprintRegistry';
+export * from './useSkillRegistry';
 export * from './useChatKeymap';
 export * from './useChatProcessor';
 export * from './useChatServices';
@@ -13,8 +13,10 @@ export * from './useContextObjects';
 export { useDebug } from './useDebug';
 export * from './useFilteredTypes';
 export * from './useFlush';
-export * from './useOnline';
 export * from './usePresets';
 export * from './useReferencesProvider';
+export * from './useTraceMessages';
+export * from './useHomeSuggestions';
+export * from './useProcessEphemeralStatus';
 
 export { type AiChatProcessor } from '../processor';

package/src/hooks/useChatProcessor.ts

@@ -12,13 +12,11 @@ import { Capabilities } from '@dxos/app-framework';
 import { useCapability } from '@dxos/app-framework/ui';
 import { AiSession } from '@dxos/assistant';
 import { type Chat } from '@dxos/assistant-toolkit';
-import { Credential, ServiceResolver } from '@dxos/compute';
-import { Database, Feed, Ref, Registry } from '@dxos/echo';
-import { createFeedServiceLayer } from '@dxos/echo-client';
+import { AgentService, Credential, ServiceResolver } from '@dxos/compute';
+import { Database, Obj, Ref, Registry } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
-import { AgentService } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { type Space } from '@dxos/react-client/echo';
+import { type Space, useObject } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
 import { type Assistant } from '#types';
@@ -47,22 +45,21 @@ export const useChatProcessor = ({
 }: UseChatProcessorProps): AiChatProcessor | undefined => {
   const observableRegistry = useContext(RegistryContext);
 
+  // Reactive subscription — re-renders when the feed ref resolves. Direct `.target` reads are not reactive.
+  const [feedSnapshot] = useObject(chat?.feed);
+  const feed = Obj.getReactiveOrUndefined(feedSnapshot);
+
   const [session, setSession] = useState<AiSession.Session>();
   useAsyncEffect(async () => {
-    if (!space || !chat) {
+    if (!space || !chat || !feed) {
       return;
     }
 
-    const feedTarget = chat.feed.target;
-    if (!feedTarget) {
-      return;
-    }
-    const feedServiceLayer = createFeedServiceLayer(space.queues);
     const runtime = await EffectEx.runAndForwardErrors(
-      Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
+      Effect.runtime<Database.Service>().pipe(Effect.provide(Database.layer(space.db))),
     );
     const session = new AiSession.Session({
-      feed: feedTarget,
+      feed,
       runtime,
       registry: observableRegistry,
     });
@@ -72,9 +69,8 @@ export const useChatProcessor = ({
       void session.close();
       setSession(undefined);
     };
-  }, [space, chat?.feed.target]);
+  }, [space, chat, feed]);
 
-  const feed = chat?.feed.target;
   const serviceResolver = useCapability(Capabilities.ServiceResolver);
 
   const processor = useMemo(() => {
@@ -85,7 +81,6 @@ export const useChatProcessor = ({
     const spaceLayer = ServiceResolver.provide(
       { space: space.id },
       Database.Service,
-      Feed.FeedService,
       Credential.CredentialsService,
       AiService.AiService,
       AgentService.AgentService,
@@ -99,6 +94,7 @@ export const useChatProcessor = ({
       observableRegistry,
       registry,
       model: preset?.model,
+      provider: preset?.provider,
     });
   }, [runtime, session, registry, preset, chat, feed, space?.id]);
 

package/src/hooks/useChatServices.ts

@@ -4,7 +4,7 @@
 
 import { Capabilities } from '@dxos/app-framework';
 import { useCapability } from '@dxos/app-framework/ui';
-import { getPersonalSpace } from '@dxos/app-toolkit';
+import { AppSpace } from '@dxos/app-toolkit';
 import { type Key } from '@dxos/echo';
 import { useClient } from '@dxos/react-client';
 
@@ -21,7 +21,7 @@ export type UseChatServicesProps = {
  */
 export const useChatServices = ({ id }: UseChatServicesProps) => {
   const client = useClient();
-  id ??= getPersonalSpace(client)?.id;
+  id ??= AppSpace.getPersonalSpace(client)?.id;
 
   const runtime = useCapability(Capabilities.ProcessManagerRuntime);
   return id ? runtime : undefined;

package/src/hooks/useChatToolbarActions.ts

@@ -35,12 +35,12 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
 
       const builder = MenuBuilder.make()
         .root({
-          label: ['chat-toolbar.title', { ns: meta.id }],
+          label: ['chat-toolbar.title', { ns: meta.profile.key }],
         })
         .action(
           'new',
           {
-            label: ['new-thread.button', { ns: meta.id }],
+            label: ['new-thread.button', { ns: meta.profile.key }],
             icon: 'ph--plus--regular',
             type: 'new',
             disabled: !companionTo,
@@ -56,7 +56,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
         .action(
           'rename',
           {
-            label: ['rename-thread.button', { ns: meta.id }],
+            label: ['rename-thread.button', { ns: meta.profile.key }],
             icon: 'ph--magic-wand--regular',
             type: 'rename',
             disabled: !chat,
@@ -70,7 +70,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
         .action(
           'branch',
           {
-            label: ['branch-thread.menu', { ns: meta.id }],
+            label: ['branch-thread.menu', { ns: meta.profile.key }],
             icon: 'ph--git-branch--regular',
             type: 'branch',
             disabled: !chat || !db,
@@ -86,7 +86,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
         builder.group(
           'chats',
           {
-            label: ['chat-history.label', { ns: meta.id }],
+            label: ['chat-history.label', { ns: meta.profile.key }],
             icon: 'ph--clock-counter-clockwise--regular',
             selectCardinality: 'single',
             variant: 'dropdownMenu',

package/src/hooks/useContextBinder.ts

@@ -7,8 +7,7 @@ import * as Effect from 'effect/Effect';
 import { useContext, useState } from 'react';
 
 import { AiContext } from '@dxos/assistant';
-import { Feed } from '@dxos/echo';
-import { createFeedServiceLayer } from '@dxos/echo-client';
+import { Database, Feed } from '@dxos/echo';
 import { EffectEx } from '@dxos/effect';
 import { type Space } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
@@ -26,9 +25,8 @@ export const useContextBinder = (
       return;
     }
 
-    const feedServiceLayer = createFeedServiceLayer(space.queues);
     const runtime = await EffectEx.runAndForwardErrors(
-      Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
+      Effect.runtime<Database.Service>().pipe(Effect.provide(Database.layer(space.db))),
     );
     const binder = new AiContext.Binder({ feed, runtime, registry });
     await binder.open();

package/src/hooks/useDebug.ts

@@ -16,10 +16,10 @@ import { type AiChatProcessor } from '../processor';
 export const useDebug = ({ processor }: { processor: AiChatProcessor }) => {
   return useCallback(async () => {
     const objects = processor.context.getObjects();
-    const blueprints = processor.context.getBlueprints();
+    const skills = processor.context.getSkills();
     const system = await processor.getSystemPrompt();
     const tools = (await processor.getTools()) ?? {};
-    console.group('Chat', { objects, blueprints });
+    console.group('Chat', { objects, skills });
     try {
       console.log(trim`
         System Prompt:

package/src/hooks/useHomeSuggestions.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useMemo, useState } from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { type Space } from '@dxos/react-client/echo';
+import { useAsyncEffect, useTranslation } from '@dxos/react-ui';
+
+import { meta } from '#meta';
+import { AssistantOperation } from '#types';
+
+const FALLBACK_SUGGESTION_KEYS = [
+  'space-home.suggestion-magazine.label',
+  'space-home.suggestion-spreadsheet.label',
+  'space-home.suggestion-kanban.label',
+] as const;
+
+/**
+ * Returns starter prompts for the space Home page. Returns undefined while the request is in flight
+ * so the section stays hidden until settled. On success yields generated prompts; on empty result or
+ * error falls back to the hardcoded defaults.
+ */
+export const useHomeSuggestions = (space?: Space): readonly string[] | undefined => {
+  const { t } = useTranslation(meta.profile.key);
+  const { invokePromise } = useOperationInvoker();
+  const fallbacks = useMemo(
+    () => FALLBACK_SUGGESTION_KEYS.map((key) => t(key, { year: new Date().getFullYear() })),
+    [t],
+  );
+  const [suggestions, setSuggestions] = useState<readonly string[] | undefined>(undefined);
+
+  useAsyncEffect(
+    async (controller) => {
+      setSuggestions(undefined);
+      if (!space) {
+        return;
+      }
+      const result = await invokePromise(
+        AssistantOperation.GenerateHomeSuggestions,
+        { db: space.db },
+        { spaceId: space.db.spaceId },
+      );
+      if (controller.signal.aborted) {
+        return;
+      }
+      const prompts = result.data?.prompts;
+      setSuggestions(prompts && prompts.length > 0 ? prompts : fallbacks);
+    },
+    [space, invokePromise],
+  );
+
+  return suggestions;
+};

package/src/hooks/usePresets.ts

@@ -2,32 +2,77 @@
 // Copyright 2025 DXOS.org
 //
 
+import { useAtomValue } from '@effect-atom/atom-react';
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import { type ChatPresetProps } from '#types';
+import { Provider } from '@dxos/ai';
+import { useOptionalCapability } from '@dxos/app-framework/ui';
+import { EffectEx } from '@dxos/effect';
 
-import { type AiServicePreset, AiServicePresets } from '../processor';
+import { type Assistant, AssistantCapabilities, type ChatPresetProps, Ollama } from '#types';
+
+import { type AiServicePreset, defaultsKeyForProvider, presetsForProvider, resolveProvider } from '../processor';
 
 export type UsePresets = {
   preset: AiServicePreset | undefined;
 } & Pick<ChatPresetProps, 'presets' | 'onPresetChange'>;
 
-export const usePresets = (online: boolean): UsePresets => {
-  // TODO(burdon): Memo preset for provider.
+/**
+ * Resolves the chat model presets for the provider selected in settings ({@link Assistant.Settings.modelProvider}),
+ * defaulting the selection to the configured per-provider model.
+ */
+export const usePresets = (settings: Assistant.Settings): UsePresets => {
   const [preset, setPreset] = useState<AiServicePreset>();
-  const presets = useMemo(
-    () => AiServicePresets.filter((preset) => online === (preset.provider === 'dxos-remote')),
-    [online],
-  );
+
+  // The Ollama manager is the bundled sidecar (desktop only); its presence signals that the
+  // `built-in` provider (rather than an external Ollama server) is available.
+  const ollamaManager = useOptionalCapability(AssistantCapabilities.OllamaManager);
+
+  const provider = resolveProvider(settings.modelProvider, !!ollamaManager);
+  const defaultModel = settings.modelDefaults?.[defaultsKeyForProvider(provider)];
+
+  // Installed models reported by the bundled sidecar; used to offer only models actually present.
+  const localModels = useAtomValue(ollamaManager?.state ?? Ollama.emptyState);
+
+  // When the bundled sidecar is the active provider, list installed models in the background so the
+  // chat selector is populated without first opening settings. Idempotent: kicks off only from the
+  // idle state, so it spawns the sidecar once when local models are in use (not on every launch);
+  // settings remains the explicit path for retrying after a failure.
+  useEffect(() => {
+    if (provider === Provider.builtIn.id && ollamaManager && localModels.kind === 'idle') {
+      void EffectEx.runPromise(ollamaManager.refresh);
+    }
+  }, [provider, ollamaManager, localModels.kind]);
+
+  // Probe the external LM Studio server only when that provider is selected on desktop.
+  const lmStudioProbeUrl =
+    provider === Provider.lmStudio.id && ollamaManager ? `${Provider.lmStudio.endpoint}/v1/models` : undefined;
+  const lmStudioReachable = useEndpointReachable(lmStudioProbeUrl);
+
+  const presets = useMemo(() => {
+    const base = presetsForProvider(provider);
+    // Desktop LM Studio: only offer presets when the external server responds.
+    if (provider === Provider.lmStudio.id && ollamaManager) {
+      return lmStudioReachable ? base : [];
+    }
+    // Bundled sidecar: only offer models that are actually installed (matched by back-end pull tag).
+    if (provider === Provider.builtIn.id && ollamaManager) {
+      const installed = new Set(localModels.models.map((model) => model.name));
+      return base.filter((preset) => installed.has(preset.backend));
+    }
+    return base;
+  }, [provider, ollamaManager, lmStudioReachable, localModels]);
 
   const presetOptions = useMemo(
     () => presets.map(({ id, model, label }) => ({ id, label: label ?? model })),
     [presets],
   );
 
+  // Default to the provider's configured model, else the first available preset.
   useEffect(() => {
-    setPreset(presets[0]);
-  }, [presets]);
+    const configured = defaultModel ? presets.find((preset) => preset.model === defaultModel) : undefined;
+    setPreset(configured ?? presets[0]);
+  }, [presets, defaultModel]);
 
   const handlePresetChange = useCallback<NonNullable<ChatPresetProps['onPresetChange']>>(
     (id) => {
@@ -40,8 +85,32 @@ export const usePresets = (online: boolean): UsePresets => {
   );
 
   return {
-    preset: preset,
+    preset,
     presets: presetOptions,
     onPresetChange: handlePresetChange,
   };
 };
+
+/** Reactively reports whether an HTTP endpoint responds; `undefined` url disables the probe. */
+const useEndpointReachable = (url: string | undefined): boolean => {
+  const [reachable, setReachable] = useState(false);
+  useEffect(() => {
+    if (!url) {
+      setReachable(false);
+      return;
+    }
+    let active = true;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+    fetch(url, { signal: controller.signal })
+      .then((response) => active && setReachable(response.ok))
+      .catch(() => active && setReachable(false))
+      .finally(() => clearTimeout(timer));
+    return () => {
+      active = false;
+      controller.abort();
+      clearTimeout(timer);
+    };
+  }, [url]);
+  return reachable;
+};