@dxos/plugin-assistant 0.9.1-main.c7dcc2e112 → 0.10.0

package/src/containers/AssistantSettings/OllamaModels.stories.tsx

@@ -0,0 +1,108 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import React, { useMemo } from 'react';
+
+import { Form } from '@dxos/react-ui-form';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+import { type Ollama } from '#types';
+
+import { OllamaModelsSection } from './OllamaModels';
+
+// In-memory manager that bypasses the (desktop-only) capability lookup; methods are no-ops so the
+// configured state is what renders.
+const makeFakeManager = (state: Ollama.ModelsState): Ollama.Manager => ({
+  endpoint: 'http://localhost:21434',
+  state: Atom.make(state),
+  refresh: Effect.void,
+  refreshLoaded: Effect.void,
+  pull: () => Effect.void,
+  cancel: () => Effect.void,
+  load: () => Effect.void,
+  unload: () => Effect.void,
+  remove: () => Effect.void,
+});
+
+const Render = ({ state }: { state: Ollama.ModelsState }) => {
+  const manager = useMemo(() => makeFakeManager(state), [state]);
+  return (
+    <Form.Root schema={Schema.Struct({})} values={{}} variant='settings'>
+      <Form.Viewport scroll>
+        <Form.Content>
+          <OllamaModelsSection manager={manager} />
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/OllamaModels',
+  render: Render,
+  decorators: [withTheme(), withLayout({ layout: 'column' })],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof Render>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Empty: Story = {
+  args: {
+    state: { kind: 'ready', models: [], loaded: [], pulls: {}, errors: {} },
+  },
+};
+
+export const Populated: Story = {
+  args: {
+    state: {
+      kind: 'ready',
+      models: [
+        { name: 'llama3.2:1b', size: 1_321_098_329 },
+        { name: 'qwen2.5:14b', size: 9_001_234_567 },
+      ],
+      // llama3.2:1b is currently loaded into memory.
+      loaded: [{ name: 'llama3.2:1b', sizeVram: 1_400_000_000 }],
+      pulls: {},
+      // A per-model action error shows inline on its row.
+      errors: { 'qwen2.5:14b': 'error starting llama-server: not enough memory' },
+    },
+  },
+};
+
+export const Pulling: Story = {
+  args: {
+    state: {
+      kind: 'ready',
+      models: [{ name: 'llama3.2:1b', size: 1_321_098_329 }],
+      loaded: [],
+      pulls: {
+        'gpt-oss:20b': { status: 'downloading', completed: 4_200_000_000, total: 13_000_000_000 },
+      },
+      errors: {},
+    },
+  },
+};
+
+export const Failed: Story = {
+  args: {
+    state: {
+      kind: 'failed',
+      models: [],
+      loaded: [],
+      pulls: {},
+      errors: {},
+      error: 'Connection refused',
+    },
+  },
+};

package/src/containers/AssistantSettings/OllamaModels.tsx

@@ -0,0 +1,255 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import React, { useCallback, useEffect, useState } from 'react';
+
+import { Model, Provider } from '@dxos/ai';
+import { useOptionalCapability } from '@dxos/app-framework/ui';
+import { EffectEx } from '@dxos/effect';
+import { List, ListItem } from '@dxos/react-list';
+import { IconButton, useTranslation } from '@dxos/react-ui';
+import { Form } from '@dxos/react-ui-form';
+import { Combobox } from '@dxos/react-ui-list';
+
+import { meta } from '#meta';
+import { AssistantCapabilities, type Ollama } from '#types';
+
+/** Quick-pick model names (Ollama pull tags) sourced from the curated catalog. */
+const QUICK_PICKS = Model.forProvider(Provider.ollama.id).map((model) => model.backend);
+
+/** Poll interval for the loaded-into-memory set while the settings panel is open. */
+const LOADED_POLL_INTERVAL = 3_000;
+
+/**
+ * Manage locally-installed Ollama models. The {@link AssistantCapabilities.OllamaManager}
+ * capability is only contributed by the native (desktop) runtime, so this renders nothing in the
+ * browser/mobile. Split from the section body so hooks are never called conditionally.
+ */
+export const OllamaModels = () => {
+  const manager = useOptionalCapability(AssistantCapabilities.OllamaManager);
+  if (!manager) {
+    return null;
+  }
+
+  return <OllamaModelsSection manager={manager} />;
+};
+
+export const OllamaModelsSection = ({ manager }: { manager: Ollama.Manager }) => {
+  const { t } = useTranslation(meta.profile.key);
+  // Explicit subscription: the list and badges must re-render as pulls/installs/loads land.
+  const state = useAtomValue(manager.state);
+  const [query, setQuery] = useState('');
+  const [open, setOpen] = useState(false);
+  // UI-level gate keyed by model name, guaranteeing a visible busy state across the click handler.
+  const [pending, setPending] = useState<Record<string, boolean>>({});
+
+  // Ensure the sidecar is up and list installed models on mount.
+  useEffect(() => {
+    void EffectEx.runPromise(manager.refresh);
+  }, [manager]);
+
+  // Poll the loaded-into-memory set so the panel reflects which model is resident in real time.
+  useEffect(() => {
+    const interval = setInterval(() => void EffectEx.runPromise(manager.refreshLoaded), LOADED_POLL_INTERVAL);
+    return () => clearInterval(interval);
+  }, [manager]);
+
+  const installed = new Set(state.models.map((model) => model.name));
+  const loaded = new Map(state.loaded.map((model) => [model.name, model]));
+  const pulling = Object.keys(state.pulls).filter((name) => !installed.has(name));
+
+  const withPending = useCallback(
+    (key: string, action: () => Promise<void>) => async () => {
+      setPending((prev) => ({ ...prev, [key]: true }));
+      try {
+        await action();
+      } finally {
+        setPending((prev) => ({ ...prev, [key]: false }));
+      }
+    },
+    [],
+  );
+
+  const handlePull = useCallback(
+    (target: string) => {
+      const trimmed = target.trim();
+      if (trimmed.length === 0) {
+        return;
+      }
+      setQuery('');
+      setOpen(false);
+      void withPending(trimmed, () => EffectEx.runPromise(manager.pull(trimmed)))();
+    },
+    [manager, withPending],
+  );
+
+  // Caller-driven filtering: curated picks not yet installed, matching the typed query.
+  const filter = query.trim();
+  const suggestions = QUICK_PICKS.filter((pick) => !installed.has(pick) && (filter === '' || pick.includes(filter)));
+  const offerCustom = filter.length > 0 && !installed.has(filter) && !suggestions.includes(filter);
+  const empty = state.models.length === 0 && pulling.length === 0;
+
+  return (
+    <Form.Section title={t('settings.ollama.title')}>
+      <Form.Row label={t('settings.ollama.installed.label')}>
+        {state.kind === 'failed' && state.error ? (
+          // Connection-level failure has no associated model, so it shows inline as the row content.
+          <p className='text-sm text-error-text'>{t('settings.ollama.failed.message', { error: state.error })}</p>
+        ) : empty ? (
+          <p className='text-sm text-description'>{t('settings.ollama.empty.message')}</p>
+        ) : (
+          // Plain `List`/`ListItem` (non-select), with the trigger editor's "fatter" two-line row
+          // treatment: a name line plus a secondary meta line, on a surface-styled row. Rows are
+          // actioned via their trailing buttons (no selection semantics).
+          <List variant='unordered' className='flex flex-col gap-1 grow is-full text-left'>
+            {state.models.map((model) => {
+              const running = loaded.get(model.name);
+              const error = state.errors[model.name];
+              const size = model.size != null ? formatBytes(model.size) : undefined;
+              const loadedLabel = running
+                ? running.sizeVram
+                  ? t('settings.ollama.loaded.vram', { size: formatBytes(running.sizeVram) })
+                  : t('settings.ollama.loaded.label')
+                : undefined;
+              return (
+                <ListItem
+                  key={model.name}
+                  className='flex flex-col gap-0.5 rounded-sm bg-input-surface px-2 py-1.5 is-full'
+                >
+                  <div className='flex items-center gap-2'>
+                    <span className='grow truncate font-medium'>{model.name}</span>
+                    <IconButton
+                      icon={running ? 'ph--eject--regular' : 'ph--play--regular'}
+                      iconOnly
+                      label={running ? t('settings.ollama.unload.label') : t('settings.ollama.load.label')}
+                      disabled={pending[model.name]}
+                      onClick={() =>
+                        void withPending(model.name, () =>
+                          EffectEx.runPromise(running ? manager.unload(model.name) : manager.load(model.name)),
+                        )()
+                      }
+                    />
+                    <IconButton
+                      icon='ph--trash--regular'
+                      iconOnly
+                      label={t('settings.ollama.remove.label')}
+                      disabled={pending[model.name]}
+                      onClick={() =>
+                        void withPending(model.name, () => EffectEx.runPromise(manager.remove(model.name)))()
+                      }
+                    />
+                  </div>
+                  {(size || loadedLabel || error) && (
+                    <div className='flex items-center gap-2 text-sm'>
+                      {size && <span className='text-description'>{size}</span>}
+                      {loadedLabel && <span className='text-success-text'>{loadedLabel}</span>}
+                      {error && <span className='truncate text-error-text'>{shortError(error)}</span>}
+                    </div>
+                  )}
+                </ListItem>
+              );
+            })}
+            {pulling.map((name) => {
+              const progress = state.pulls[name];
+              const status = progress?.total
+                ? t('settings.ollama.pulling.message', { percent: percentOf(progress) })
+                : (progress?.status ?? t('settings.ollama.pulling.label'));
+              return (
+                <ListItem key={name} className='flex flex-col gap-0.5 rounded-sm bg-input-surface px-2 py-1.5 is-full'>
+                  <div className='flex items-center gap-2'>
+                    <span className='grow truncate font-medium text-description'>{name}</span>
+                    <IconButton
+                      icon='ph--x--regular'
+                      iconOnly
+                      label={t('settings.ollama.cancel.label')}
+                      onClick={() => void EffectEx.runPromise(manager.cancel(name))}
+                    />
+                  </div>
+                  <span className='text-sm text-description'>{status}</span>
+                </ListItem>
+              );
+            })}
+          </List>
+        )}
+      </Form.Row>
+
+      <Form.Row label={t('settings.ollama.pull.label')}>
+        {/* Pull failures for not-yet-installed models surface here (no model row to attach to). */}
+        {Object.entries(state.errors)
+          .filter(([name]) => !installed.has(name))
+          .map(([name, error]) => (
+            <p key={name} className='text-xs text-error-text'>
+              {name}: {shortError(error)}
+            </p>
+          ))}
+        {/* Root value is held empty so the trigger always shows the placeholder; the live text is
+            the separate `query` driving the input and suggestion filter. */}
+        <Combobox.Root
+          open={open}
+          onOpenChange={setOpen}
+          value=''
+          onValueChange={() => {}}
+          placeholder={t('settings.ollama.pull.placeholder')}
+        >
+          <Combobox.Trigger classNames='is-full' />
+          <Combobox.Portal>
+            <Combobox.Content>
+              <Combobox.Input
+                value={query}
+                onValueChange={setQuery}
+                placeholder={t('settings.ollama.pull.placeholder')}
+                onKeyDown={(event) => {
+                  if (event.key === 'Enter' && filter.length > 0) {
+                    handlePull(filter);
+                  }
+                }}
+              />
+              <Combobox.List>
+                {offerCustom && (
+                  <Combobox.Item
+                    value={filter}
+                    label={t('settings.ollama.pull-custom.label', { name: filter })}
+                    icon='ph--download-simple--regular'
+                    onSelect={() => handlePull(filter)}
+                  />
+                )}
+                {suggestions.map((pick) => (
+                  <Combobox.Item key={pick} value={pick} label={pick} onSelect={() => handlePull(pick)} />
+                ))}
+              </Combobox.List>
+              <Combobox.Arrow />
+            </Combobox.Content>
+          </Combobox.Portal>
+        </Combobox.Root>
+      </Form.Row>
+    </Form.Section>
+  );
+};
+
+/**
+ * Condense a verbose service error for inline display: drop Ollama's "(checked: <paths>)" path dump
+ * and cap the length. The full message is still logged to the console.
+ */
+const shortError = (error: string): string => {
+  const head = error.split(/\s*\(checked:/)[0].trim();
+  return head.length > 160 ? `${head.slice(0, 160)}…` : head;
+};
+
+/** Percent complete for an in-flight pull, or 0 when totals are not yet known. */
+const percentOf = (progress: Ollama.ModelsState['pulls'][string] | undefined): number =>
+  progress && progress.total && progress.total > 0 ? Math.round(((progress.completed ?? 0) / progress.total) * 100) : 0;
+
+const UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
+
+/** Human-readable byte size (binary units). */
+const formatBytes = (bytes: number): string => {
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < UNITS.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value.toFixed(unit === 0 ? 0 : 1)} ${UNITS[unit]}`;
+};

package/src/containers/ChatArticle/ChatArticle.stories.tsx

@@ -12,9 +12,9 @@ import { AppActivationEvents } from '@dxos/app-toolkit';
 import { Chat } from '@dxos/assistant-toolkit';
 import { capabilities } from '@dxos/assistant-toolkit/testing';
 import { Feed, Filter, Ref } from '@dxos/echo';
-import { AutomationPlugin } from '@dxos/plugin-automation/testing';
-import { initializeIdentity, ClientPlugin } from '@dxos/plugin-client/testing';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
 import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { RoutinePlugin } from '@dxos/plugin-routine/testing';
 import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
 import { Config } from '@dxos/react-client';
 import { useQuery, useSpaces } from '@dxos/react-client/echo';
@@ -57,7 +57,7 @@ const meta = {
               yield* Effect.promise(() => space.db.flush({ indexes: true }));
             }),
         }),
-        AutomationPlugin(),
+        RoutinePlugin(),
         AssistantPlugin(),
         PreviewPlugin(),
         StorybookPlugin({}),

package/src/containers/ChatArticle/ChatArticle.tsx

@@ -4,6 +4,7 @@
 
 import React, { forwardRef, useCallback, useEffect, useRef } from 'react';
 
+import { Provider } from '@dxos/ai';
 import { Capabilities } from '@dxos/app-framework';
 import { useAtomCapability, useCapability, useOperationInvoker } from '@dxos/app-framework/ui';
 import { type AppSurface } from '@dxos/app-toolkit/ui';
@@ -14,7 +15,7 @@ import { useObject, useRegistry } from '@dxos/react-client/echo';
 import { Panel } from '@dxos/react-ui';
 
 import { Chat as ChatComponent, type ChatRootProps } from '#components';
-import { useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { useChatProcessor, useChatServices, usePresets } from '#hooks';
 import { type Assistant, AssistantCapabilities, type ChatType } from '#types';
 
 export type ChatArticleProps = AppSurface.ObjectSectionProps<ChatType.Chat> & {
@@ -31,8 +32,9 @@ export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>(
     const space = getSpace(chat) ?? getSpace(companionTo);
     const runtime = useChatServices({ id: space?.id });
 
-    const [online, setOnline] = useOnline();
-    const { preset, ...chatProps } = usePresets(online);
+    const { preset, ...chatProps } = usePresets(settings);
+    // The provider is configured in settings; the chat surfaces it as a read-only online indicator.
+    const online = preset?.provider === Provider.edge.id;
     const processor = useChatProcessor({ space, chat, preset, runtime, registry, settings });
 
     // Subscribe to the view type via `useObject` so the thread re-renders when ChatOptions changes it;
@@ -75,16 +77,9 @@ export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>(
     }
 
     return (
-      <ChatComponent.Root
-        chat={chat}
-        feed={chat?.feed.target}
-        db={space?.db}
-        processor={processor}
-        onEvent={onEvent}
-        onSubmit={onSubmit}
-      >
+      <ChatComponent.Root chat={chat} db={space?.db} processor={processor} onEvent={onEvent} onSubmit={onSubmit}>
         <Panel.Root role={role} ref={forwardedRef}>
-          <Panel.Toolbar className='bg-toolbar-surface'>
+          <Panel.Toolbar>
             <ChatComponent.Toolbar classNames='dx-document' attendableId={attendableId} companionTo={companionTo} />
           </Panel.Toolbar>
           <Panel.Content>
@@ -103,13 +98,7 @@ export const ChatArticle = forwardRef<HTMLDivElement, ChatArticleProps>(
                 <div className='flex flex-col items-center py-2 overflow-hidden'>
                   <ChatComponent.TaskList classNames='max-h-[120px] border border-separator rounded-sm text-description' />
                 </div>
-                <ChatComponent.Prompt
-                  {...chatProps}
-                  outline
-                  preset={preset?.id}
-                  online={online}
-                  onOnlineChange={setOnline}
-                />
+                <ChatComponent.Prompt {...chatProps} outline preset={preset?.id} online={online} />
               </div>
             </ChatComponent.Content>
           </Panel.Content>

package/src/containers/ChatCompanion/ChatCompanion.tsx

@@ -10,10 +10,10 @@ import { AppAnnotation } from '@dxos/app-toolkit';
 import { type AppSurface } from '@dxos/app-toolkit/ui';
 import { Chat } from '@dxos/assistant-toolkit';
 import { getSpace } from '@dxos/client/echo';
-import { Blueprint } from '@dxos/compute';
+import { Skill } from '@dxos/compute';
 import { Entity, Filter, Obj, Ref, Type } from '@dxos/echo';
 import { SpaceOperation } from '@dxos/plugin-space';
-import { useQuery, useRegistry } from '@dxos/react-client/echo';
+import { useObject, useQuery, useRegistry } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
 import { useContextBinder } from '#hooks';
@@ -27,7 +27,7 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
   ({ role = 'article', subject: chat, companionTo, attendableId }, forwardedRef) => {
     const { invokePromise } = useOperationInvoker();
     const space = getSpace(companionTo);
-    useBlueprints({ subject: chat, companionTo });
+    useSkills({ subject: chat, companionTo });
 
     // Persist (and flush) a transient chat before the first request so the agent can resolve
     // the now-durable conversation feed; subsequent submits are a no-op once persisted.
@@ -39,7 +39,6 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
       await invokePromise(SpaceOperation.AddObject, {
         object: chat,
         target: space.db,
-        hidden: true,
       });
       await invokePromise(SpaceOperation.AddRelation, {
         db: space.db,
@@ -68,32 +67,33 @@ export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
 );
 
 /**
- * Bind blueprints to the context.
+ * Bind skills to the context.
  */
 // TODO(burdon): Why is this only in the companion?
-const useBlueprints = ({ subject: chat, companionTo }: Pick<ChatCompanionProps, 'subject' | 'companionTo'>) => {
+const useSkills = ({ subject: chat, companionTo }: Pick<ChatCompanionProps, 'subject' | 'companionTo'>) => {
   const registry = useRegistry();
   const space = getSpace(companionTo);
-  const feedTarget = chat?.feed.target;
+  const [feedSnapshot] = useObject(chat?.feed);
+  const feedTarget = Obj.getReactiveOrUndefined(feedSnapshot);
   const binder = useContextBinder(space, feedTarget);
 
-  const blueprintKeys = useMemo(() => {
+  const skillKeys = useMemo(() => {
     const schema = companionTo ? Obj.getType(companionTo) : undefined;
     if (!schema) {
       return [] as string[];
     }
 
-    return Option.getOrElse(() => [] as string[])(AppAnnotation.BlueprintsAnnotation.get(Type.getSchema(schema)));
+    return Option.getOrElse(() => [] as string[])(AppAnnotation.SkillsAnnotation.get(Type.getSchema(schema)));
   }, [companionTo]);
 
-  const existingBlueprints = useQuery(space?.db, Filter.type(Blueprint.Blueprint));
-  const pluginBlueprints = useMemo(
+  const existingSkills = useQuery(space?.db, Filter.type(Skill.Skill));
+  const pluginSkills = useMemo(
     () =>
-      existingBlueprints.filter((blueprint) => {
-        const key = Obj.getMeta(blueprint).key;
-        return key !== undefined && blueprintKeys.includes(key);
+      existingSkills.filter((skill) => {
+        const key = Obj.getMeta(skill).key;
+        return key !== undefined && skillKeys.includes(key);
       }),
-    [existingBlueprints, blueprintKeys],
+    [existingSkills, skillKeys],
   );
 
   useAsyncEffect(async () => {
@@ -101,27 +101,27 @@ const useBlueprints = ({ subject: chat, companionTo }: Pick<ChatCompanionProps,
       return;
     }
 
-    // Bind annotated blueprints: use key URI for registry blueprints (no DB clone needed).
-    if (blueprintKeys.length > 0) {
-      const registryKeys = blueprintKeys.filter((key) => {
+    // Bind annotated skills: use key URI for registry skills (no DB clone needed).
+    if (skillKeys.length > 0) {
+      const registryKeys = skillKeys.filter((key) => {
         const candidate = registry.list().find((e) => Entity.getMeta(e)?.key === key);
-        return candidate != null && Obj.instanceOf(Blueprint.Blueprint, candidate);
+        return candidate != null && Obj.instanceOf(Skill.Skill, candidate);
       });
 
-      // DB-forked blueprints (in space but not in registry).
-      const dbForks = pluginBlueprints.filter((bp) => !registryKeys.includes(Obj.getMeta(bp).key ?? ''));
+      // DB-forked skills (in space but not in registry).
+      const dbForks = pluginSkills.filter((bp) => !registryKeys.includes(Obj.getMeta(bp).key ?? ''));
       if (registryKeys.length > 0) {
-        await binder.bind({ blueprints: registryKeys.map((key) => Ref.fromURI(Blueprint.registryURI(key))) });
+        await binder.bind({ skills: registryKeys.map((key) => Ref.fromURI(Skill.registryURI(key))) });
       }
       if (dbForks.length > 0) {
-        await binder.bind({ blueprints: dbForks.map((blueprint) => Ref.make(blueprint)) });
+        await binder.bind({ skills: dbForks.map((skill) => Ref.make(skill)) });
       }
     }
 
-    if (Obj.instanceOf(Blueprint.Blueprint, companionTo)) {
-      await binder.bind({ blueprints: [Ref.make(companionTo)] });
+    if (Obj.instanceOf(Skill.Skill, companionTo)) {
+      await binder.bind({ skills: [Ref.make(companionTo)] });
     } else {
       await binder.bind({ objects: [Ref.make(companionTo)] });
     }
-  }, [binder, blueprintKeys, pluginBlueprints, companionTo]);
+  }, [binder, skillKeys, pluginSkills, companionTo]);
 };

package/src/containers/ChatDialog/ChatDialog.tsx

@@ -4,6 +4,7 @@
 
 import React, { useCallback, useState } from 'react';
 
+import { Provider } from '@dxos/ai';
 import { useAtomCapability } from '@dxos/app-framework/ui';
 import { type Chat as ChatTypes } from '@dxos/assistant-toolkit';
 import { Obj } from '@dxos/echo';
@@ -12,7 +13,7 @@ import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
 import { Chat, type ChatRootProps } from '#components';
-import { useChatProcessor, useChatServices, useOnline, usePresets } from '#hooks';
+import { useChatProcessor, useChatServices, usePresets } from '#hooks';
 import { meta } from '#meta';
 import { type Assistant, AssistantCapabilities } from '#types';
 
@@ -26,8 +27,8 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
   const db = chat && Obj.getDatabase(chat);
   const settings = useAtomCapability(AssistantCapabilities.Settings);
   const runtime = useChatServices({ id: db?.spaceId });
-  const [online, setOnline] = useOnline();
-  const { preset, ...chatProps } = usePresets(online);
+  const { preset, ...chatProps } = usePresets(settings);
+  const online = preset?.provider === Provider.edge.id;
   const registry = useRegistry();
   const processor = useChatProcessor({ chat, preset, runtime, registry, settings });
   // Subscribe via `useObject` so the thread re-renders when ChatOptions changes the view type.
@@ -61,7 +62,7 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
           <Chat.Thread viewType={(chatViewType as Assistant.ChatView | undefined) ?? settings.chatView} />
         </NaturalChatDialog.Content>
         <NaturalChatDialog.Footer classNames='p-1.5'>
-          <Chat.Prompt {...chatProps} preset={preset?.id} online={online} onOnlineChange={setOnline} expandable />
+          <Chat.Prompt {...chatProps} preset={preset?.id} online={online} expandable />
         </NaturalChatDialog.Footer>
       </NaturalChatDialog.Root>
     </Chat.Root>