@dxos/plugin-assistant 0.8.1-staging.391c573 → 0.8.1-staging.5be625a

package/src/components/AssistantSettings/AssistantSettings.tsx

@@ -4,13 +4,16 @@
 
 import React from 'react';
 
-import { DEFAULT_LLM_MODELS } from '@dxos/assistant';
+import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/assistant';
 import { Input, Select, useTranslation } from '@dxos/react-ui';
 import { DeprecatedFormContainer, DeprecatedFormInput } from '@dxos/react-ui-form';
 
 import { ASSISTANT_PLUGIN } from '../../meta';
 import { type AssistantSettingsProps } from '../../types';
 
+// TODO(burdon): Factor out.
+const DEFAULT_VALUE = '__default';
+
 export const AssistantSettings = ({ settings }: { settings: AssistantSettingsProps }) => {
   const { t } = useTranslation(ASSISTANT_PLUGIN);
 
@@ -23,18 +26,49 @@ export const AssistantSettings = ({ settings }: { settings: AssistantSettingsPro
         />
       </DeprecatedFormInput>
 
-      <DeprecatedFormInput label={t('settings llm model label')}>
+      <DeprecatedFormInput label={t('settings llm provider label')}>
+        <Input.Switch
+          checked={settings.llmProvider === 'ollama'}
+          onCheckedChange={(checked) => (settings.llmProvider = checked ? 'ollama' : 'edge')}
+        />
+      </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.llmModel ?? 'default'}
+          value={settings.ollamaModel ?? DEFAULT_VALUE}
           onValueChange={(value) => {
-            settings.llmModel = value;
+            settings.ollamaModel = value === DEFAULT_VALUE ? undefined : value;
           }}
         >
           <Select.TriggerButton placeholder={t('settings default llm model label')} />
           <Select.Portal>
             <Select.Content>
               <Select.Viewport>
-                {DEFAULT_LLM_MODELS.map((model) => (
+                <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>

package/src/components/Prompt/Prompt.stories.tsx

@@ -11,6 +11,7 @@ import { withTheme, withLayout } from '@dxos/storybook-utils';
 
 import { Prompt } from './Prompt';
 import { PromptBar } from './PromptBar';
+import type { ReferenceData } from './references';
 import translations from '../../translations';
 
 const meta: Meta<typeof Prompt> = {
@@ -77,3 +78,36 @@ export const Toolbar: Story = {
     );
   },
 };
+
+export const Includes: Story = {
+  args: {
+    classNames: 'w-96 p-4 rounded outline outline-gray-200',
+    references: {
+      getReferences: async ({ query }) => {
+        const res = references.filter((i) => i.label.toLowerCase().startsWith(query.toLowerCase()));
+        console.log('getReferences', { query, res });
+        return res;
+      },
+      resolveReference: async ({ uri }) => {
+        const res = references.find((i) => i.uri === uri);
+        console.log('resolveReference', { uri, res });
+        return res ?? null;
+      },
+    },
+  },
+};
+
+const references: ReferenceData[] = [
+  {
+    uri: 'dxn:echo:@:AAAAAAAA',
+    label: 'Meeting Notes',
+  },
+  {
+    uri: 'dxn:echo:@:BBBBBBBB',
+    label: 'Project Plan',
+  },
+  {
+    uri: 'dxn:echo:@:CCCCCCCC',
+    label: 'Meeting Plan',
+  },
+];

package/src/components/Prompt/Prompt.tsx

@@ -2,6 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Prec } from '@codemirror/state';
 import React, { forwardRef, useImperativeHandle } from 'react';
 
 import { type ThemedClassName, useThemeContext } from '@dxos/react-ui';
@@ -16,6 +17,7 @@ import {
 import { mx } from '@dxos/react-ui-theme';
 
 import { createAutocompleteExtension, type AutocompleteOptions } from './autocomplete';
+import { promptReferences, type ReferencesProvider } from './references';
 
 // TODO(burdon): Handle object references.
 
@@ -27,16 +29,21 @@ export interface PromptController {
 export type PromptProps = ThemedClassName<
   {
     onOpenChange?: (open: boolean) => void;
+    references?: ReferencesProvider;
   } & AutocompleteOptions &
     Pick<UseTextEditorProps, 'autoFocus'> &
     Pick<BasicExtensionsOptions, 'lineWrapping' | 'placeholder'>
 >;
 
 export const Prompt = forwardRef<PromptController, PromptProps>(
-  ({ classNames, autoFocus, lineWrapping = false, placeholder, onSubmit, onSuggest, onOpenChange }, forwardRef) => {
+  (
+    { classNames, autoFocus, lineWrapping = false, placeholder, onSubmit, onSuggest, onOpenChange, references },
+    forwardRef,
+  ) => {
     const { themeMode } = useThemeContext();
     const { parentRef, view } = useTextEditor(
       {
+        debug: true,
         autoFocus,
         extensions: [
           createBasicExtensions({
@@ -45,25 +52,28 @@ export const Prompt = forwardRef<PromptController, PromptProps>(
             placeholder,
           }),
           createThemeExtensions({ themeMode }),
+          references ? promptReferences({ provider: references }) : [],
           createAutocompleteExtension({ onSubmit, onSuggest }),
-          keymap.of([
-            {
-              key: 'Alt-ArrowUp',
-              preventDefault: true,
-              run: (view) => {
-                onOpenChange?.(true);
-                return true;
+          Prec.highest(
+            keymap.of([
+              {
+                key: 'cmd-ArrowUp',
+                preventDefault: true,
+                run: (view) => {
+                  onOpenChange?.(true);
+                  return true;
+                },
               },
-            },
-            {
-              key: 'Alt-ArrowDown',
-              preventDefault: true,
-              run: (view) => {
-                onOpenChange?.(false);
-                return true;
+              {
+                key: 'cmd-ArrowDown',
+                preventDefault: true,
+                run: (view) => {
+                  onOpenChange?.(false);
+                  return true;
+                },
               },
-            },
-          ]),
+            ]),
+          ),
         ],
       },
       [themeMode, onSubmit, onSuggest],
@@ -95,6 +105,6 @@ export const Prompt = forwardRef<PromptController, PromptProps>(
       [view, onSubmit],
     );
 
-    return <div ref={parentRef} className={mx('w-full overflow-hidden', classNames)} />;
+    return <div ref={parentRef} className={mx('w-full', classNames)} />;
   },
 );

package/src/components/Prompt/PromptBar.tsx

@@ -13,7 +13,7 @@ import { Prompt, type PromptController, type PromptProps } from './Prompt';
 import { ASSISTANT_PLUGIN } from '../../meta';
 
 export type PromptBarProps = ThemedClassName<
-  Pick<PromptProps, 'placeholder' | 'lineWrapping' | 'onSubmit' | 'onSuggest' | 'onOpenChange'> & {
+  Pick<PromptProps, 'placeholder' | 'lineWrapping' | 'onSubmit' | 'onSuggest' | 'onOpenChange' | 'references'> & {
     processing?: boolean;
     error?: Error;
     microphone?: boolean;
@@ -28,6 +28,7 @@ export const PromptBar = ({
   error,
   microphone,
   onCancel,
+  references,
   ...props
 }: PromptBarProps) => {
   const { t } = useTranslation(ASSISTANT_PLUGIN);
@@ -72,6 +73,7 @@ export const PromptBar = ({
         classNames='pbs-2'
         lineWrapping={true}
         placeholder={placeholder ?? t('prompt placeholder')}
+        references={references}
         {...props}
       />
       {(onCancel || microphone) && (

package/src/components/Prompt/references.ts

@@ -0,0 +1,180 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { autocompletion, completionKeymap, type CompletionResult } from '@codemirror/autocomplete';
+import { type Extension, RangeSet } from '@codemirror/state';
+import {
+  Decoration,
+  EditorView,
+  keymap,
+  ViewPlugin,
+  WidgetType,
+  type DecorationSet,
+  type ViewUpdate,
+} from '@codemirror/view';
+
+import { Mutex } from '@dxos/async';
+
+export type ReferenceData = {
+  uri: string;
+  label: string;
+  // TODO(dmaretskyi): Consider adding details renderer for when you hover over the reference.
+};
+
+export interface ReferencesProvider {
+  getReferences({ query }: { query: string }): Promise<ReferenceData[]>;
+
+  resolveReference({ uri }: { uri: string }): Promise<ReferenceData | null>;
+}
+
+export type PromptReferencesOptions = {
+  provider: ReferencesProvider;
+  /**
+   * Will prevent the autocomplete from closing when the user blurs the editor.
+   * @default false
+   */
+  debug?: boolean;
+  /**
+   * @default '@'
+   */
+  triggerCharacter?: string;
+};
+
+/**
+ * Include references into text.
+ */
+export const promptReferences = ({
+  provider,
+  debug = false,
+  triggerCharacter = '@',
+}: PromptReferencesOptions): Extension => {
+  if (triggerCharacter.length !== 1) {
+    throw new Error('triggerCharacter must be a single character');
+  }
+
+  const decorationField = ViewPlugin.fromClass(
+    class ReferenceView {
+      private _mutex = new Mutex();
+
+      decorations: DecorationSet = Decoration.set([]);
+
+      constructor(view: EditorView) {
+        queueMicrotask(async () => {
+          const guard = await this._mutex.acquire();
+          try {
+            this.decorations = await this._computeDecorations(view);
+          } finally {
+            guard.release();
+          }
+        });
+      }
+
+      update(update: ViewUpdate) {
+        if (update.docChanged) {
+          queueMicrotask(async () => {
+            const guard = await this._mutex.acquire();
+            try {
+              this.decorations = await this._computeDecorations(update.view);
+            } finally {
+              guard.release();
+            }
+          });
+        }
+      }
+
+      private async _computeDecorations(view: EditorView): Promise<DecorationSet> {
+        const text = view.state.doc.toString();
+        const references = text.matchAll(new RegExp(`${triggerCharacter}[a-zA-Z0-9@:]+\\s`, 'g'));
+
+        const decorations = [];
+        for (const match of references) {
+          const reference = match[0];
+          const uri = reference.slice(1, -1);
+          const data = await provider.resolveReference({ uri });
+          if (data) {
+            decorations.push(
+              Decoration.replace({
+                widget: new ReferenceWidget(data),
+              }).range(match.index!, match.index! + reference.length),
+            );
+          }
+        }
+
+        return Decoration.set(decorations);
+      }
+    },
+    {
+      decorations: (v) => v.decorations,
+      provide: (plugin) => [
+        EditorView.atomicRanges.of(
+          (view): DecorationSet => view.plugin(decorationField)?.decorations ?? RangeSet.empty,
+        ),
+      ],
+    },
+  );
+
+  return [
+    decorationField,
+
+    EditorView.theme({
+      '.cm-reference-pill': {
+        borderRadius: '0.25rem',
+        borderWidth: '1px',
+        marginRight: '0.25rem',
+        marginLeft: '0.25rem',
+      },
+    }),
+
+    autocompletion({
+      activateOnTyping: true,
+      override: [
+        async (context): Promise<CompletionResult | null> => {
+          const match = context.matchBefore(new RegExp(`${triggerCharacter}[a-zA-Z0-9]+`));
+
+          if (!match || match?.to === match?.from) {
+            return null;
+          }
+
+          const query = match.text.slice(1);
+          const references = await provider.getReferences({ query });
+
+          return {
+            from: match.from,
+            filter: false,
+            options: references.map((reference) => ({
+              label: reference.label,
+              apply: `${triggerCharacter}${reference.uri} `,
+            })),
+          };
+        },
+      ],
+      closeOnBlur: !debug,
+      tooltipClass: () => 'shadow rounded',
+      aboveCursor: true,
+    }),
+
+    keymap.of(completionKeymap),
+  ];
+};
+
+class ReferenceWidget extends WidgetType {
+  constructor(private data: ReferenceData) {
+    super();
+  }
+
+  override toDOM() {
+    const span = document.createElement('span');
+    span.textContent = `@ ${this.data.label}`;
+    span.className = 'cm-reference-pill';
+    return span;
+  }
+
+  override eq(other: ReferenceWidget) {
+    return other.data.uri === this.data.uri;
+  }
+
+  override ignoreEvent() {
+    return true;
+  }
+}

package/src/components/TemplateContainer.tsx

@@ -2,17 +2,92 @@
 // Copyright 2025 DXOS.org
 //
 
-import React from 'react';
+import { Match, type Schema as S } from 'effect';
+import React, { type ChangeEvent, useCallback } from 'react';
 
+import { debounce } from '@dxos/async';
+import { Input, Select, Toolbar, useTranslation } from '@dxos/react-ui';
 import { StackItem } from '@dxos/react-ui-stack';
 
 import { TemplateEditor } from './TemplateEditor';
-import { type TemplateType } from '../types';
+import { ASSISTANT_PLUGIN } from '../meta';
+import { TemplateKinds, type TemplateKindSchema, type TemplateType } from '../types';
 
-// TODO(burdon): Attention.
 export const TemplateContainer = ({ template, role }: { template: TemplateType; role: string }) => {
+  const { t } = useTranslation(ASSISTANT_PLUGIN);
+
+  const handleKindChange = useCallback(
+    (value: string) => {
+      const kind = Match.type<string>().pipe(
+        Match.withReturnType<S.Schema.Type<typeof TemplateKindSchema>>(),
+        Match.when('always', () => ({ include: 'always' })),
+        Match.when('schema-matching', () => ({ include: 'schema-matching', typename: '' })),
+        Match.when('automatically', () => ({ include: 'automatically', description: '' })),
+        Match.orElse(() => ({ include: 'manual' })),
+      )(value);
+
+      template.kind = kind;
+    },
+    [template],
+  );
+
+  const handleTypenameChange = useCallback(
+    debounce((event: ChangeEvent<HTMLInputElement>) => {
+      if (template.kind.include === 'schema-matching') {
+        template.kind.typename = event.target.value;
+      }
+    }, 300),
+    [template.kind.include],
+  );
+
+  const handleDescriptionChange = useCallback(
+    debounce((event: ChangeEvent<HTMLInputElement>) => {
+      if (template.kind.include === 'automatically') {
+        template.kind.description = event.target.value;
+      }
+    }, 300),
+    [template.kind.include],
+  );
+
   return (
-    <StackItem.Content toolbar={false} role={role} classNames='mli-auto w-full max-w-[50rem]'>
+    <StackItem.Content toolbar role={role} classNames='mli-auto w-full max-w-[50rem]'>
+      {/* TODO(wittjosiah): Move this toolbar into c11y sidebar. */}
+      <Toolbar.Root>
+        <Select.Root value={template.kind.include} onValueChange={handleKindChange}>
+          <Toolbar.Button asChild>
+            <Select.TriggerButton />
+          </Toolbar.Button>
+          <Select.Portal>
+            <Select.Content>
+              <Select.Viewport>
+                {TemplateKinds.map((kind) => (
+                  <Select.Option key={kind} value={kind}>
+                    {kind}
+                  </Select.Option>
+                ))}
+              </Select.Viewport>
+            </Select.Content>
+          </Select.Portal>
+        </Select.Root>
+        {template.kind.include === 'schema-matching' && (
+          <Input.Root>
+            <Input.TextInput
+              placeholder={t('typename placeholder')}
+              defaultValue={template.kind.typename}
+              onChange={handleTypenameChange}
+            />
+          </Input.Root>
+        )}
+        {template.kind.include === 'automatically' && (
+          <Input.Root>
+            <Input.TextInput
+              placeholder={t('description placeholder')}
+              defaultValue={template.kind.description}
+              onChange={handleDescriptionChange}
+            />
+          </Input.Root>
+        )}
+      </Toolbar.Root>
       <TemplateEditor template={template} />
     </StackItem.Content>
   );

package/src/components/TemplateEditor/TemplateEditor.stories.tsx

@@ -38,7 +38,7 @@ const Render = ({ text }: TemplateEditorProps & { text: string }) => {
   const client = useClient();
   const [template] = useState(() => {
     const space = client.spaces.default;
-    return space.db.add(create(TemplateType, { source: text }));
+    return space.db.add(create(TemplateType, { source: text, kind: { include: 'manual' } }));
   });
 
   return (

package/src/components/TemplateEditor/TemplateForm.stories.tsx

@@ -30,7 +30,7 @@ const Render = () => {
   const client = useClient();
   const [template] = useState(() => {
     const space = client.spaces.default;
-    return space.db.add(create(TemplateType, { source: TEMPLATE }));
+    return space.db.add(create(TemplateType, { source: TEMPLATE, kind: { include: 'manual' } }));
   });
 
   return (

package/src/components/Thread/Thread.tsx

@@ -15,6 +15,13 @@ import { keyToFallback } from '@dxos/util';
 import { ThreadMessage, type ThreadMessageProps } from './ThreadMessage';
 import { messageReducer } from './reducer';
 import { PromptBar, type PromptBarProps } from '../Prompt';
+import type { ReferenceData, ReferencesProvider } from '../Prompt/references';
+
+export interface ContextProvider {
+  query({ query }: { query: string }): Promise<ReferenceData[]>;
+
+  resolveMetadata({ uri }: { uri: string }): Promise<ReferenceData | null>;
+}
 
 export type ThreadProps = ThemedClassName<{
   space?: Space;
@@ -22,6 +29,7 @@ export type ThreadProps = ThemedClassName<{
   collapse?: boolean;
   transcription?: boolean;
   onOpenChange?: (open: boolean) => void;
+  contextProvider?: ContextProvider;
 }> &
   Pick<PromptBarProps, 'processing' | 'error' | 'onSubmit' | 'onSuggest' | 'onCancel'> &
   Pick<ThreadMessageProps, 'debug' | 'tools' | 'onPrompt' | 'onDelete'>;
@@ -40,6 +48,7 @@ export const Thread = ({
   onSubmit,
   onCancel,
   onOpenChange,
+  contextProvider,
   ...props
 }: ThreadProps) => {
   const scroller = useRef<ScrollController>(null);
@@ -68,6 +77,17 @@ export const Thread = ({
     }
   }, [messages, collapse]);
 
+  const references = useMemo<ReferencesProvider | undefined>(() => {
+    if (!contextProvider) {
+      return undefined;
+    }
+
+    return {
+      getReferences: async ({ query }: { query: string }) => contextProvider.query({ query }),
+      resolveReference: async ({ uri }: { uri: string }) => contextProvider.resolveMetadata({ uri }),
+    };
+  }, [contextProvider]);
+
   return (
     <div role='none' className={mx('flex flex-col grow overflow-hidden', classNames)}>
       <ScrollContainer ref={scroller} fade>
@@ -90,6 +110,7 @@ export const Thread = ({
           onSubmit={handleSubmit}
           onCancel={onCancel}
           onOpenChange={onOpenChange}
+          references={references}
         />
       )}
     </div>

package/src/components/Thread/ThreadContainer.stories.tsx

@@ -21,7 +21,6 @@ import { Message, type Tool } from '@dxos/artifact';
 import { genericTools, localServiceEndpoints, type IsObject } from '@dxos/artifact-testing';
 import { AIServiceEdgeClient } from '@dxos/assistant';
 import { createStatic, ObjectId } from '@dxos/echo-schema';
-import { EdgeHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { DXN, QueueSubspaceTags, SpaceId } from '@dxos/keys';
 import { ChessPlugin } from '@dxos/plugin-chess';
@@ -31,9 +30,8 @@ import { InboxPlugin } from '@dxos/plugin-inbox';
 import { MapPlugin } from '@dxos/plugin-map';
 import { SpacePlugin } from '@dxos/plugin-space';
 import { TablePlugin } from '@dxos/plugin-table';
-import { useSpace } from '@dxos/react-client/echo';
+import { useQueue, useSpace } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
-import { useQueue } from '@dxos/react-edge-client';
 import { IconButton, Input, Toolbar } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
 import { withLayout, withSignals, withTheme } from '@dxos/storybook-utils';
@@ -54,13 +52,9 @@ type RenderProps = {
 const Render = ({ items: _items, prompts = [], ...props }: RenderProps) => {
   const space = useSpace();
   const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
-  const tools = useMemo<Tool[]>(
-    () => [...genericTools, ...artifactDefinitions.flatMap((definition) => definition.tools)],
-    [genericTools, artifactDefinitions],
-  );
+  const tools = useMemo<Tool[]>(() => [...genericTools], []);
 
   const [aiClient] = useState(() => new AIServiceEdgeClient({ endpoint: endpoints.ai }));
-  const [edgeClient] = useState(() => new EdgeHttpClient(endpoints.edge));
   const { dispatchPromise: dispatch } = useIntentDispatcher();
 
   // TODO(burdon): Replace with useChatProcessor.
@@ -73,6 +67,7 @@ const Render = ({ items: _items, prompts = [], ...props }: RenderProps) => {
     return new ChatProcessor(
       aiClient,
       tools,
+      artifactDefinitions,
       {
         space,
         dispatch,
@@ -82,8 +77,8 @@ const Render = ({ items: _items, prompts = [], ...props }: RenderProps) => {
   }, [aiClient, tools, space, dispatch, artifactDefinitions]);
 
   // Queue.
-  const [queueDxn, setQueueDxn] = useState(() => randomQueueDxn());
-  const queue = useQueue<Message>(edgeClient, DXN.tryParse(queueDxn));
+  const [queueDxn, setQueueDxn] = useState<string>(() => randomQueueDxn());
+  const queue = useQueue<Message>(DXN.tryParse(queueDxn));
 
   useEffect(() => {
     if (queue?.items.length === 0 && !queue.isLoading && prompts.length > 0) {

package/src/components/Thread/ThreadContainer.tsx

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type FC, useCallback } from 'react';
+import React, { useCallback, type FC } from 'react';
 
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
@@ -10,12 +10,13 @@ import { getSpace } from '@dxos/react-client/echo';
 import { type ThemedClassName } from '@dxos/react-ui';
 
 import { Thread, type ThreadProps } from './Thread';
-import { useChatProcessor, useMessageQueue } from '../../hooks';
+import { useChatProcessor, useContextProvider, useMessageQueue } from '../../hooks';
 import { type AIChatType, type AssistantSettingsProps } from '../../types';
 
 export type ThreadContainerProps = {
   chat?: AIChatType;
   settings?: AssistantSettingsProps;
+  part?: 'deck' | 'dialog';
 } & Pick<ThreadProps, 'debug' | 'transcription' | 'onOpenChange'>;
 
 // TODO(burdon): Since this only wraps Thread, just separate out hook?
@@ -23,12 +24,13 @@ export const ThreadContainer: FC<ThemedClassName<ThreadContainerProps>> = ({
   classNames,
   chat,
   settings,
+  part,
   onOpenChange,
   ...props
 }) => {
-  // Push up capabilities hooks out of components.
   const space = getSpace(chat);
-  const processor = useChatProcessor(space, settings);
+  const contextProvider = useContextProvider(space);
+  const processor = useChatProcessor({ chat, space, settings, part });
   const messageQueue = useMessageQueue(chat);
   const messages = [...(messageQueue?.items ?? []), ...processor.messages.value];
 
@@ -73,6 +75,7 @@ export const ThreadContainer: FC<ThemedClassName<ThreadContainerProps>> = ({
       onCancel={handleCancel}
       onPrompt={handleSubmit}
       onOpenChange={onOpenChange}
+      contextProvider={contextProvider}
       {...props}
     />
   );