@dxos/plugin-assistant 0.8.3 → 0.8.4-main.1c7ec43d41

package/src/capabilities/react-surface.tsx

@@ -2,136 +2,166 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
-import React, { useEffect, useMemo } from 'react';
+import * as Effect from 'effect/Effect';
+import React, { type ComponentProps, useEffect } from 'react';
 
-import { Capabilities, contributes, createIntent, createSurface, useIntentDispatcher } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/assistant';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useSettingsState } from '@dxos/app-framework/ui';
+import { AppSurface, useActiveSpace } from '@dxos/app-toolkit/ui';
+import { Chat, Agent } from '@dxos/assistant-toolkit';
+import { getSpace } from '@dxos/client/echo';
+import { Blueprint, Routine } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
-import { Filter, type Key, Obj, Query } from '@dxos/echo';
-import { SettingsStore } from '@dxos/local-storage';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { fullyQualifiedId, getSpace, getTypename } from '@dxos/react-client/echo';
-import { StackItem } from '@dxos/react-ui-stack';
+import { Feed, Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { Panel } from '@dxos/react-ui';
 
+import { AssistantSettings } from '#components';
 import {
-  AssistantDialog,
-  AssistantSettings,
-  BlueprintContainer,
+  BlueprintArticle,
+  ChatCompanion,
   ChatContainer,
-  PromptSettings,
-  TemplateContainer,
-} from '../components';
-import { ASSISTANT_PLUGIN, ASSISTANT_DIALOG } from '../meta';
-import { AIChatType, AssistantAction, type AssistantSettingsProps, CompanionTo, TemplateType } from '../types';
+  ChatDialog,
+  AgentArticle,
+  AgentProperties,
+  RoutineArticle,
+  RoutineList,
+  TracePanel,
+  TriggerStatus,
+} from '#containers';
+import { ASSISTANT_COMPANION_VARIANT, ASSISTANT_DIALOG, meta } from '#meta';
+import { type Assistant } from '#types';
 
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${ASSISTANT_PLUGIN}/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<AssistantSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === ASSISTANT_PLUGIN,
-      component: ({ data: { subject } }) => <AssistantSettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${ASSISTANT_PLUGIN}/chat`,
-      role: 'article',
-      filter: (data): data is { subject: AIChatType; variant: undefined } =>
-        Obj.instanceOf(AIChatType, data.subject) && data.variant !== 'assistant-chat',
-      component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
-    }),
-    createSurface({
-      id: `${ASSISTANT_PLUGIN}/object-chat`,
-      role: 'article',
-      filter: (data): data is { companionTo: Obj.Any; subject: AIChatType | 'assistant-chat' } =>
-        Obj.isObject(data.companionTo) &&
-        (Obj.instanceOf(AIChatType, data.subject) || data.subject === 'assistant-chat'),
-      component: ({ data, role }) => {
-        const { dispatch } = useIntentDispatcher();
-        const associatedArtifact = useMemo(
-          () => ({
-            id: fullyQualifiedId(data.companionTo),
-            typename: getTypename(data.companionTo) ?? 'unknown',
-            spaceId: (getSpace(data.companionTo)?.id ?? 'unknown') as Key.SpaceId,
-          }),
-          [data.companionTo],
-        );
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'plugin-settings',
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
+          return <AssistantSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: 'chat',
+        role: 'article',
+        filter: (data): data is { attendableId: string; subject: Chat.Chat; variant: undefined } =>
+          typeof data.attendableId === 'string' &&
+          Obj.instanceOf(Chat.Chat, data.subject) &&
+          data.variant !== ASSISTANT_COMPANION_VARIANT,
+        component: ({ data, role, ref }) => {
+          return <ChatContainer role={role} subject={data.subject} attendableId={data.attendableId} ref={ref} />;
+        },
+      }),
+      Surface.create({
+        id: 'agent',
+        filter: AppSurface.object(AppSurface.Article, Agent.Agent),
+        component: ({ data, role }) => (
+          <AgentArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: 'agent-properties',
+        filter: AppSurface.object(AppSurface.ObjectProperties, Agent.Agent),
+        component: ({ data }) => <AgentProperties subject={data.subject} />,
+      }),
+      Surface.create({
+        id: 'companion-chat',
+        role: 'article',
+        filter: (data): data is { subject: Chat.Chat | null; attendableId: string; companionTo: Obj.Unknown } =>
+          typeof data.attendableId === 'string' &&
+          Obj.isObject(data.companionTo) &&
+          (Obj.instanceOf(Chat.Chat, data.subject) || data.subject === null),
+        component: ({ data: { subject, attendableId, companionTo }, role, ref }) => (
+          <ChatCompanion
+            role={role}
+            subject={subject}
+            attendableId={attendableId}
+            companionTo={companionTo}
+            ref={ref}
+          />
+        ),
+      }),
+      Surface.create({
+        id: 'companion-invocations',
+        role: 'article',
+        filter: (data): data is { companionTo: Sequence } =>
+          (Obj.instanceOf(Sequence, data.companionTo) || Obj.instanceOf(Routine.Routine, data.companionTo)) &&
+          data.subject === 'invocations',
+        component: ({ data, role }) => {
+          const space = getSpace(data.companionTo);
+          const feed = space?.properties.invocationTraceFeed?.target;
+          const queueDxn = feed ? Feed.getQueueDxn(feed) : undefined;
+          // TODO(wittjosiah): Support invocation filtering for prompts.
+          const target = Obj.instanceOf(Routine.Routine, data.companionTo) ? undefined : data.companionTo;
 
-        // TODO(wittjosiah): Factor out to container.
-        useEffect(() => {
-          const timeout = setTimeout(async () => {
-            const space = getSpace(data.companionTo);
-            if (space && data.subject === 'assistant-chat') {
-              const result = await space.db
-                .query(Query.select(Filter.ids(data.companionTo.id)).targetOf(CompanionTo).source())
-                .run();
-              if (result.objects.length > 0) {
-                return;
-              }
+          return (
+            <Panel.Root role={role} className='dx-document'>
+              <Panel.Content asChild>
+                <InvocationTraceContainer db={space?.db} queueDxn={queueDxn} target={target} detailAxis='block' />
+              </Panel.Content>
+            </Panel.Root>
+          );
+        },
+      }),
+      Surface.create({
+        id: 'blueprint',
+        filter: AppSurface.object(AppSurface.Article, Blueprint.Blueprint),
+        component: ({ data, role }) => (
+          <BlueprintArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: 'prompt',
+        filter: AppSurface.object(AppSurface.Article, Routine.Routine),
+        component: ({ data, role }) => (
+          <RoutineArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: ASSISTANT_DIALOG,
+        filter: AppSurface.component<ComponentProps<typeof ChatDialog>>(AppSurface.Dialog, ASSISTANT_DIALOG),
+        component: ({ data }) => <ChatDialog {...data.props} />,
+      }),
+      Surface.create({
+        id: 'trace',
+        filter: AppSurface.literal(Surface.makeType<{ subject: string }>('deck-companion--trace'), 'trace'),
+        component: () => {
+          const space = useActiveSpace();
+          useEffect(() => {
+            log('trace panel surface', { hasSpace: Boolean(space), spaceId: space?.id });
+          }, [space?.id]);
 
-              const program = Effect.gen(function* () {
-                const { object } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
-                yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-                yield* dispatch(
-                  createIntent(SpaceAction.AddRelation, {
-                    space,
-                    schema: CompanionTo,
-                    source: object,
-                    target: data.companionTo,
-                  }),
-                );
-              });
-              void Effect.runPromise(program);
-            }
-          });
+          if (!space) {
+            // TODO(dmaretskyi): Not really part of UX, but so we know what the error is.
+            return <span>No active space</span>;
+          }
 
-          return () => clearTimeout(timeout);
-        }, [data.subject]);
+          return <TracePanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'status',
+        role: 'status-indicator',
+        component: () => {
+          const space = useActiveSpace();
+          if (!space) {
+            return null;
+          }
 
-        if (data.subject === 'assistant-chat') {
-          return null;
-        }
-
-        return <ChatContainer role={role} chat={data.subject} associatedArtifact={associatedArtifact} />;
-      },
-    }),
-    createSurface({
-      id: `${ASSISTANT_PLUGIN}/blueprint`,
-      role: 'article',
-      filter: (data): data is { subject: Blueprint } => Obj.instanceOf(Blueprint, data.subject),
-      component: ({ data, role }) => <BlueprintContainer role={role} blueprint={data.subject} />,
-    }),
-    createSurface({
-      id: `${ASSISTANT_PLUGIN}/companion/logs`,
-      role: 'article',
-      filter: (data): data is { companionTo: Blueprint } =>
-        Obj.instanceOf(Blueprint, data.companionTo) && data.subject === 'logs',
-      component: ({ data, role }) => {
-        const space = getSpace(data.companionTo);
-        return (
-          <StackItem.Content role={role}>
-            <InvocationTraceContainer space={space} target={data.companionTo} detailAxis='block' />
-          </StackItem.Content>
-        );
-      },
-    }),
-    createSurface({
-      id: `${ASSISTANT_PLUGIN}/template`,
-      role: 'article',
-      filter: (data): data is { subject: TemplateType } => Obj.instanceOf(TemplateType, data.subject),
-      component: ({ data, role }) => <TemplateContainer role={role} template={data.subject} />,
-    }),
-    createSurface({
-      id: ASSISTANT_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: { chat: AIChatType } } => data.component === ASSISTANT_DIALOG,
-      component: ({ data }) => <AssistantDialog {...data.props} />,
-    }),
-    createSurface({
-      id: `${ASSISTANT_PLUGIN}/prompt-settings`,
-      role: 'object-settings',
-      filter: (data): data is { subject: TemplateType } => Obj.instanceOf(TemplateType, data.subject),
-      component: ({ data }) => <PromptSettings template={data.subject} />,
-    }),
-  ]);
+          return <TriggerStatus role='status-indicator' space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'prompts',
+        filter: AppSurface.subject(
+          Surface.makeType<{ subject: Obj.Any; attendableId: string }>('prompts'),
+          Obj.isObject,
+        ),
+        component: ({ data }) => <RoutineList subject={data.subject} />,
+      }),
+    ]),
+  ),
+);

package/src/capabilities/settings.ts

@@ -2,18 +2,30 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
+import * as Effect from 'effect/Effect';
 
-import { meta } from '../meta';
-import { type AssistantSettingsProps, AssistantSettingsSchema } from '../types';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
 
-export default () => {
-  const settings = live<AssistantSettingsProps>({});
+import { meta } from '#meta';
+import { Assistant, AssistantCapabilities } from '#types';
 
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: AssistantSettingsSchema,
-    value: settings,
-  });
-};
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Assistant.Settings,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(AssistantCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Assistant.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/state.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { type Obj } from '@dxos/echo';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '#meta';
+import { AssistantCapabilities } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    // NOTE: This needs to be a chat object rather than a string id to avoid a query race.
+    // TODO(wittjosiah): Handle serialization and hydration for this so it can be cached.
+    const stateAtom = createKvsStore({
+      key: meta.id,
+      schema: AssistantCapabilities.StateSchema,
+      defaultValue: () => ({
+        currentChat: {},
+        pendingPrompts: {},
+      }),
+    });
+
+    const companionChatCacheAtom = Atom.make<Record<string, Obj.Unknown | undefined>>({}).pipe(Atom.keepAlive);
+
+    return [
+      Capability.contributes(AssistantCapabilities.State, stateAtom),
+      Capability.contributes(AssistantCapabilities.CompanionChatCache, companionChatCacheAtom),
+    ];
+  }),
+);

package/src/capabilities/toolkit.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { WebSearchToolkitOpaque } from '@dxos/assistant-toolkit';
+
+export default Capability.makeModule(() =>
+  Effect.succeed([Capability.contributes(AppCapabilities.Toolkit, WebSearchToolkitOpaque)]),
+);

package/src/cli/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './plugin';

package/src/cli/plugin.ts

@@ -0,0 +1,83 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { ActivationEvents, Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { ContextBinding } from '@dxos/assistant';
+import { Agent, Chat, McpServer, Memory, Plan } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { Feed } from '@dxos/echo';
+import { ClientEvents } from '@dxos/plugin-client/types';
+import { Text } from '@dxos/schema';
+import { HasSubject, Message } from '@dxos/types';
+
+import {
+  AiService,
+  BlueprintDefinition,
+  EdgeModelResolver,
+  LocalModelResolver,
+  Migrations,
+  OperationHandler,
+  Toolkit,
+} from '#capabilities';
+import { meta } from '#meta';
+import { AssistantEvents } from '#types';
+
+/**
+ * Headless variant of `AssistantPlugin` for Node-only contexts (CLI, tests).
+ * Omits modules that depend on browser globals or the React/UI stack:
+ * translations, ReactSurface, MarkdownExtension, AppGraphBuilder, Settings,
+ * AssistantState, CompanionChatProvisioner, metadata (`createObject` hooks),
+ * and the `on-space-created` hook.
+ */
+export const AssistantPlugin = Plugin.define(meta).pipe(
+  // Headless plugin has no ReactSurface; full Assistant fires SetupArtifactDefinition from the surface module.
+  // Activate blueprint definitions on Startup so AgentHandlers (and other blueprint ops) register in CLI/tests.
+  AppPlugin.addBlueprintDefinitionModule({
+    activate: BlueprintDefinition,
+    activatesOn: ActivationEvents.Startup,
+  }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      Chat.Chat,
+      Chat.CompanionTo,
+      Blueprint.Blueprint,
+      ContextBinding,
+      Feed.Feed,
+      HasSubject.HasSubject,
+      Message.Message,
+      Routine.Routine,
+      Agent.Agent,
+      McpServer.McpServer,
+      Plan.Plan,
+      Sequence,
+      Memory.Memory,
+      Text.Text,
+    ],
+  }),
+  Plugin.addModule({
+    activatesOn: AssistantEvents.SetupAiServiceProviders,
+    activate: EdgeModelResolver,
+  }),
+  Plugin.addModule({
+    activatesOn: AssistantEvents.SetupAiServiceProviders,
+    activate: LocalModelResolver,
+  }),
+  Plugin.addModule({
+    firesBeforeActivation: [AssistantEvents.SetupAiServiceProviders],
+    activatesOn: ActivationEvents.Startup,
+    activate: AiService,
+  }),
+  Plugin.addModule({
+    activatesOn: ActivationEvents.Startup,
+    activate: Toolkit,
+  }),
+  Plugin.addModule({
+    activatesOn: ClientEvents.SetupMigration,
+    activate: Migrations,
+  }),
+  Plugin.make,
+);

package/src/components/AssistantSettings/AssistantSettings.stories.tsx

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { AssistantSettings } from './AssistantSettings';
+
+const meta = {
+  title: 'plugins/plugin-assistant/components/AssistantSettings',
+  tags: ['settings'],
+  component: AssistantSettings,
+  decorators: [withTheme(), withLayout({ layout: 'fullscreen' })],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof AssistantSettings>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    settings: {
+      customPrompts: false,
+      modelProvider: 'edge',
+    },
+  },
+};

package/src/components/AssistantSettings/AssistantSettings.tsx

@@ -2,104 +2,42 @@
 // Copyright 2023 DXOS.org
 //
 
-import React from 'react';
-
-import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/ai';
-import { Input, Select, useTranslation } from '@dxos/react-ui';
-import { DeprecatedFormContainer, DeprecatedFormInput } from '@dxos/react-ui-form';
-
-import { ASSISTANT_PLUGIN } from '../../meta';
-import { LLM_PROVIDERS, type AssistantSettingsProps } from '../../types';
-
-// TODO(burdon): Factor out default Selector.
-const DEFAULT_VALUE = '__default';
-
-const LLM_PROVIDER_LABELS = {
-  edge: 'DXOS',
-  ollama: 'Ollama',
-  lmstudio: 'LM Studio',
-} as const;
-
-export const AssistantSettings = ({ settings }: { settings: AssistantSettingsProps }) => {
-  const { t } = useTranslation(ASSISTANT_PLUGIN);
+import React, { useMemo } from 'react';
+
+import { DEFAULT_EDGE_MODELS, DEFAULT_LMSTUDIO_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/ai';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { useTranslation } from '@dxos/react-ui';
+import { Settings as SettingsForm, createSelectField } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+import { Assistant } from '#types';
+
+export type AssistantSettingsProps = AppSurface.SettingsArticleProps<Assistant.Settings>;
+
+export const AssistantSettings = ({ settings, onSettingsChange }: AssistantSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+  const fieldMap = useMemo(
+    () => ({
+      modelDefaults: {
+        edge: createSelectField({ options: DEFAULT_EDGE_MODELS }),
+        ollama: createSelectField({ options: DEFAULT_OLLAMA_MODELS }),
+        lmstudio: createSelectField({ options: DEFAULT_LMSTUDIO_MODELS }),
+      },
+    }),
+    [],
+  );
 
   return (
-    <DeprecatedFormContainer>
-      <DeprecatedFormInput label={t('settings custom prompts label')}>
-        <Input.Switch
-          checked={!!settings.customPrompts}
-          onCheckedChange={(checked) => (settings.customPrompts = checked)}
+    <SettingsForm.Viewport>
+      <SettingsForm.Section title={t('settings.title', { ns: meta.id })}>
+        <SettingsForm.FieldSet<Assistant.Settings>
+          readonly={!onSettingsChange}
+          schema={Assistant.Settings}
+          fieldMap={fieldMap}
+          values={settings}
+          onValuesChanged={(values) => onSettingsChange?.(() => values)}
         />
-      </DeprecatedFormInput>
-
-      <DeprecatedFormInput label={t('settings llm provider label')}>
-        <Select.Root
-          value={settings.llmProvider ?? 'edge'}
-          onValueChange={(value) => {
-            settings.llmProvider = value === DEFAULT_VALUE ? undefined : (value as any);
-          }}
-        >
-          <Select.TriggerButton placeholder={t('settings llm provider label')} />
-          <Select.Portal>
-            <Select.Content>
-              <Select.Viewport>
-                <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
-                {LLM_PROVIDERS.map((model) => (
-                  <Select.Option key={model} value={model}>
-                    {LLM_PROVIDER_LABELS[model]}
-                  </Select.Option>
-                ))}
-              </Select.Viewport>
-            </Select.Content>
-          </Select.Portal>
-        </Select.Root>
-      </DeprecatedFormInput>
-
-      <DeprecatedFormInput label={t('settings edge llm model label')}>
-        <Select.Root
-          value={settings.edgeModel ?? DEFAULT_VALUE}
-          onValueChange={(value) => {
-            settings.edgeModel = value === DEFAULT_VALUE ? undefined : value;
-          }}
-        >
-          <Select.TriggerButton placeholder={t('settings default llm model label')} />
-          <Select.Portal>
-            <Select.Content>
-              <Select.Viewport>
-                <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
-                {DEFAULT_EDGE_MODELS.map((model) => (
-                  <Select.Option key={model} value={model}>
-                    {model}
-                  </Select.Option>
-                ))}
-              </Select.Viewport>
-            </Select.Content>
-          </Select.Portal>
-        </Select.Root>
-      </DeprecatedFormInput>
-
-      <DeprecatedFormInput label={t('settings ollama llm model label')}>
-        <Select.Root
-          value={settings.ollamaModel ?? DEFAULT_VALUE}
-          onValueChange={(value) => {
-            settings.ollamaModel = value === DEFAULT_VALUE ? undefined : value;
-          }}
-        >
-          <Select.TriggerButton placeholder={t('settings default llm model label')} />
-          <Select.Portal>
-            <Select.Content>
-              <Select.Viewport>
-                <Select.Option value={DEFAULT_VALUE}>{t('settings default label')}</Select.Option>
-                {DEFAULT_OLLAMA_MODELS.map((model) => (
-                  <Select.Option key={model} value={model}>
-                    {model}
-                  </Select.Option>
-                ))}
-              </Select.Viewport>
-            </Select.Content>
-          </Select.Portal>
-        </Select.Root>
-      </DeprecatedFormInput>
-    </DeprecatedFormContainer>
+      </SettingsForm.Section>
+    </SettingsForm.Viewport>
   );
 };

package/src/components/AssistantSettings/index.ts

@@ -1,5 +1,5 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-export * from './AssistantSettings';
+export { AssistantSettings as default } from './AssistantSettings';