@dxos/plugin-assistant 0.8.1-main.ae460ac → 0.8.1-staging.31c3ee1

package/src/components/Thread/ThreadContainer.tsx

@@ -2,20 +2,23 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { type FC, useCallback } from 'react';
+import React, { useCallback, type FC } from 'react';
 
+import { type AssociatedArtifact } from '@dxos/artifact';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 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';
+  associatedArtifact?: AssociatedArtifact;
 } & Pick<ThreadProps, 'debug' | 'transcription' | 'onOpenChange'>;
 
 // TODO(burdon): Since this only wraps Thread, just separate out hook?
@@ -23,12 +26,14 @@ export const ThreadContainer: FC<ThemedClassName<ThreadContainerProps>> = ({
   classNames,
   chat,
   settings,
+  part,
+  associatedArtifact,
   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, associatedArtifact });
   const messageQueue = useMessageQueue(chat);
   const messages = [...(messageQueue?.items ?? []), ...processor.messages.value];
 
@@ -73,6 +78,7 @@ export const ThreadContainer: FC<ThemedClassName<ThreadContainerProps>> = ({
       onCancel={handleCancel}
       onPrompt={handleSubmit}
       onOpenChange={onOpenChange}
+      contextProvider={contextProvider}
       {...props}
     />
   );

package/src/components/Thread/ThreadMessage.tsx

@@ -7,7 +7,7 @@ import React, { type PropsWithChildren, type FC } from 'react';
 import { type MessageContentBlock, type Message, type ToolType } from '@dxos/artifact';
 import { invariant } from '@dxos/invariant';
 import { type Space } from '@dxos/react-client/echo';
-import { Button, ButtonGroup, Icon, IconButton, type ThemedClassName } from '@dxos/react-ui';
+import { Button, Icon, IconButton, type ThemedClassName } from '@dxos/react-ui';
 import {
   MarkdownViewer,
   ToggleContainer as NativeToggleContainer,
@@ -21,7 +21,7 @@ import { ToolBlock, isToolMessage } from './ToolInvocations';
 import { ToolboxContainer } from '../Toolbox';
 
 const panelClassNames = 'flex flex-col w-full px-2 bg-groupSurface rounded-md';
-const userClassNames = 'bg-[--user-fill]';
+const userClassNames = 'bg-[--user-fill] text-inverse';
 
 const ToggleContainer = (props: ToggleContainerProps) => {
   return <NativeToggleContainer {...props} classNames={mx(panelClassNames, props.classNames)} />;
@@ -54,7 +54,7 @@ export const ThreadMessage: FC<ThreadMessageProps> = ({ classNames, space, messa
   // TODO(burdon): Restructure types to make check unnecessary.
   if (isToolMessage(message)) {
     return (
-      <MessageContainer classNames={classNames}>
+      <MessageContainer classNames={mx(classNames, 'animate-[fadeIn_0.5s]')}>
         <ToolBlock space={space} classNames={panelClassNames} message={message} tools={tools} />
       </MessageContainer>
     );
@@ -69,7 +69,11 @@ export const ThreadMessage: FC<ThreadMessageProps> = ({ classNames, space, messa
     const Component = components[block.type] ?? components.default;
 
     return (
-      <MessageContainer key={idx} classNames={classNames} user={block.type === 'text' && role === 'user'}>
+      <MessageContainer
+        key={idx}
+        classNames={mx(classNames, 'animate-[fadeIn_0.5s]')}
+        user={block.type === 'text' && role === 'user'}
+      >
         <Component space={space} block={block} onPrompt={onPrompt} />
       </MessageContainer>
     );
@@ -87,7 +91,7 @@ const components: Record<string, BlockComponent> = {
     // const [open, setOpen] = useState(block.disposition === 'cot' && block.pending);
     const title = block.disposition ? titles[block.disposition] : undefined;
     if (!title) {
-      return <MarkdownViewer content={block.text} />;
+      return <MarkdownViewer classNames='[&>p]:animate-[fadeIn_0.5s]' content={block.text} />;
     }
 
     // TOOD(burdon): Store last time user opened/closed COT.
@@ -140,13 +144,17 @@ const components: Record<string, BlockComponent> = {
       case 'select': {
         const { options = [] }: { options: string[] } = safeParseJson(block.json ?? '{}') ?? ({} as any);
         return (
-          <ButtonGroup>
-            {options.map((option) => (
-              <Button key={option} onClick={() => onPrompt?.(option)}>
+          <div className='flex flex-wrap gap-1'>
+            {options.map((option, idx) => (
+              <Button
+                classNames={'animate-[fadeIn_0.5s] rounded-2xl text-sm'}
+                key={option}
+                onClick={() => onPrompt?.(option)}
+              >
                 {option}
               </Button>
             ))}
-          </ButtonGroup>
+          </div>
         );
       }
 

package/src/components/Toolbox/Toolbox.stories.tsx

@@ -20,7 +20,7 @@ import { withLayout, withSignals, withTheme } from '@dxos/storybook-utils';
 import { Toolbox, type ToolboxProps } from './Toolbox';
 import translations from '../../translations';
 
-const Render = (props: ToolboxProps) => {
+const DefaultStory = (props: ToolboxProps) => {
   const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
   return (
     <Toolbox
@@ -34,7 +34,7 @@ const Render = (props: ToolboxProps) => {
 const meta: Meta<typeof Toolbox> = {
   title: 'plugins/plugin-automation/Toolbox',
   component: Toolbox,
-  render: Render,
+  render: DefaultStory,
   decorators: [
     withSignals,
     withPluginManager({

package/src/components/Toolbox/Toolbox.tsx

@@ -6,7 +6,7 @@ import React, { useState, useEffect, Fragment, type FC } from 'react';
 
 import { Capabilities, useCapabilities } from '@dxos/app-framework';
 import { parseToolName, type ArtifactDefinition, type Tool } from '@dxos/artifact';
-import { FunctionType } from '@dxos/functions';
+import { FunctionType } from '@dxos/functions/types';
 import { log } from '@dxos/log';
 import { Filter, type Space, useQuery } from '@dxos/react-client/echo';
 import { type ThemedClassName } from '@dxos/react-ui';

package/src/components/index.ts

@@ -10,6 +10,9 @@ export * from './TemplateEditor';
 export * from './Thread';
 export * from './Toolbox';
 
+// TODO(burdon): Lazy loading causes issues with Tabster.
+//  Repro: open assistant dialog then close.
+//  https://github.com/microsoft/fluentui/issues/34020
 export const AssistantDialog = lazy(() => import('./AssistantDialog'));
 export const ChatContainer = lazy(() => import('./ChatContainer'));
 export const TemplateContainer = lazy(() => import('./TemplateContainer'));

package/src/hooks/index.ts

@@ -9,3 +9,4 @@ export * from './useLocalTriggerManager';
 export * from './useMessageQueue';
 export * from './useServices';
 export * from './useTextInputEvents';
+export * from './useContextProvider';

package/src/hooks/invocation-handler.ts

@@ -5,8 +5,8 @@
 import { sleep } from '@dxos/async';
 import { getObjectCore, ResultFormat } from '@dxos/echo-db';
 import { type AnyObjectData } from '@dxos/echo-schema';
-import { FunctionType } from '@dxos/functions';
-import { type FunctionTrigger } from '@dxos/functions';
+import { FunctionType, getUserFunctionUrlInMetadata } from '@dxos/functions/types';
+import { type FunctionTrigger } from '@dxos/functions/types';
 import { invariant } from '@dxos/invariant';
 import { DXN, LOCAL_SPACE_TAG } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -53,7 +53,7 @@ export const invokeFunction = async (client: Client, space: Space, trigger: Func
       .query({ __typename: FunctionType.typename }, { format: ResultFormat.Plain })
       .run();
     const func = functions.find((fn) => referenceEquals(fn.source, trigger.function!)) as AnyObjectData | undefined;
-    const funcSlug = func?.__meta.keys.find((key) => key.source === USERFUNCTIONS_META_KEY)?.id;
+    const funcSlug = func && getUserFunctionUrlInMetadata(func.__meta);
     if (!funcSlug) {
       log.warn('function not deployed', { scriptId: script.id, name: script.name });
       return 404;
@@ -72,8 +72,6 @@ export const invokeFunction = async (client: Client, space: Space, trigger: Func
   }
 };
 
-const USERFUNCTIONS_META_KEY = 'dxos.org/service/function';
-
 const getFunctionUrl = (config: Config, slug: string, spaceId?: string) => {
   const baseUrl = new URL('functions/', config.values.runtime?.services?.edge?.url);
 

package/src/hooks/processor.ts

@@ -5,17 +5,8 @@
 import { type Signal, batch, computed, signal } from '@preact/signals-core';
 
 import { type PromiseIntentDispatcher } from '@dxos/app-framework';
-import { type Tool, Message, type MessageContentBlock } from '@dxos/artifact';
-import {
-  isToolUse,
-  runTools,
-  type GenerateRequest,
-  type GenerationStream,
-  MixedStreamParser,
-  DEFAULT_LLM_MODEL,
-  type AIServiceClient,
-} from '@dxos/assistant';
-import { createStatic } from '@dxos/echo-schema';
+import { type ArtifactDefinition, type Message, type MessageContentBlock, type Tool } from '@dxos/artifact';
+import { type AIServiceClient, AISession, DEFAULT_EDGE_MODEL, type GenerateRequest } from '@dxos/assistant';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { type Space } from '@dxos/react-client/echo';
@@ -36,7 +27,7 @@ type RequestOptions = {
 export type ChatProcessorOptions = Pick<GenerateRequest, 'model' | 'systemPrompt'>;
 
 const defaultOptions: ChatProcessorOptions = {
-  model: DEFAULT_LLM_MODEL,
+  model: DEFAULT_EDGE_MODEL,
   systemPrompt: 'you are a helpful assistant',
 };
 
@@ -47,20 +38,14 @@ const defaultOptions: ChatProcessorOptions = {
  * Supports cancellation of in-progress requests.
  */
 export class ChatProcessor {
-  /** SSE stream parser. */
-  private readonly _parser = new MixedStreamParser();
-
-  /** Current streaming response. */
-  private _stream: GenerationStream | undefined;
-
   /** Pending messages (incl. the current user request). */
   private readonly _pending: Signal<Message[]> = signal([]);
 
   /** Current streaming block (from the AI service). */
   private readonly _block: Signal<MessageContentBlock | undefined> = signal(undefined);
 
-  /** Prior history from queue. */
-  private _history: Message[] = [];
+  /** Current streaming response. */
+  private _session: AISession | undefined;
 
   /**
    * Streaming state.
@@ -94,24 +79,10 @@ export class ChatProcessor {
   constructor(
     private readonly _ai: AIServiceClient,
     private _tools?: Tool[],
+    private _artifacts?: ArtifactDefinition[],
     private readonly _extensions?: ToolContextExtensions,
     private readonly _options: ChatProcessorOptions = defaultOptions,
-  ) {
-    // Message complete.
-    this._parser.message.on((message) => {
-      batch(() => {
-        this._pending.value = [...this._pending.value, message];
-        this._block.value = undefined;
-      });
-    });
-
-    // Streaming update (happens before message complete).
-    this._parser.update.on((block) => {
-      batch(() => {
-        this._block.value = block;
-      });
-    });
-  }
+  ) {}
 
   get tools() {
     return this._tools;
@@ -128,19 +99,55 @@ export class ChatProcessor {
    * Make GPT request.
    */
   async request(message: string, options: RequestOptions = {}): Promise<Message[]> {
-    batch(() => {
-      this._history = options.history ?? [];
-      this._pending.value = [
-        createStatic(Message, {
-          role: 'user',
-          content: [{ type: 'text', text: message }],
-        }),
-      ];
-      this._block.value = undefined;
+    this._session = new AISession({ operationModel: 'immediate' });
+
+    // Message complete.
+    this._session.message.on((message) => {
+      batch(() => {
+        this._pending.value = [...this._pending.value, message];
+        this._block.value = undefined;
+      });
     });
 
-    await this._request();
-    options.onComplete?.(this._pending.value);
+    // Streaming update (happens before message complete).
+    this._session.update.on((block) => {
+      batch(() => {
+        this._block.value = block;
+      });
+    });
+
+    this._session.userMessage.on((message) => {
+      this._pending.value = [...this._pending.value, message];
+    });
+
+    try {
+      const messages = await this._session.run({
+        client: this._ai,
+        history: options.history ?? [],
+        artifacts: this._artifacts ?? [],
+        tools: this._tools ?? [],
+        prompt: message,
+        systemPrompt: this._options.systemPrompt,
+        extensions: this._extensions,
+        generationOptions: {
+          model: this._options.model,
+        },
+      });
+
+      log.info('completed', { messages });
+
+      options.onComplete?.(this._pending.value);
+    } catch (err) {
+      log.catch(err);
+      if (err instanceof Error && err.message.includes('Overloaded')) {
+        this.error.value = new AIServiceOverloadedError('AI service overloaded', { cause: err });
+      } else {
+        this.error.value = new Error('AI service error', { cause: err });
+      }
+    } finally {
+      this._session = undefined;
+    }
+
     return this._reset();
   }
 
@@ -150,79 +157,22 @@ export class ChatProcessor {
    */
   async cancel(): Promise<Message[]> {
     log.info('cancelling...');
-    this._stream?.abort();
+    this._session?.abort();
     return this._reset();
   }
 
   private async _reset(): Promise<Message[]> {
     const messages = this._pending.value;
     batch(() => {
-      this._history = [];
       this._pending.value = [];
       this._block.value = undefined;
     });
 
     return messages;
   }
+}
 
-  /**
-   * Generate a response from the AI service.
-   * Iterates over tool requests.
-   */
-  private async _request() {
-    try {
-      let more = false;
-      do {
-        log('request', {
-          pending: this._pending.value.length,
-          history: this._history.length,
-          tools: this._tools?.map((tool) => tool.name),
-        });
-
-        // Open request stream.
-        this._stream = await this._ai.exec({
-          ...this._options,
-          // TODO(burdon): Rename messages or separate history/message.
-          history: [...this._history, ...this._pending.value],
-          tools: this._tools,
-        });
-
-        // Wait until complete.
-        await this._parser.parse(this._stream);
-        await this._stream.complete();
-
-        // Add messages.
-        log('response', { pending: this._pending.value });
-
-        // Resolve tool use locally.
-        more = false;
-        const message = this._pending.value.at(-1);
-        invariant(message);
-        if (isToolUse(message)) {
-          log('tool request...');
-          const response = await runTools({
-            message: this._pending.value.at(-1)!,
-            tools: this._tools ?? [],
-            extensions: this._extensions,
-          });
-
-          log('tool response', { response });
-          switch (response.type) {
-            case 'continue': {
-              this._pending.value = [...this._pending.value, response.message];
-              more = true;
-              break;
-            }
-          }
-        }
-      } while (more);
-
-      this.error.value = undefined;
-    } catch (err) {
-      log.catch(err);
-      this.error.value = new Error('AI service error', { cause: err });
-    } finally {
-      this._stream = undefined;
-    }
-  }
+// TODO(wittjosiah): Move to ai-service-client.
+export class AIServiceOverloadedError extends Error {
+  code = 'AI_SERVICE_OVERLOADED';
 }

package/src/hooks/useChatProcessor.tsx

@@ -5,23 +5,37 @@
 import { useEffect, useMemo, useState } from 'react';
 
 import { Capabilities, useCapabilities, useCapability, useIntentDispatcher } from '@dxos/app-framework';
-import { createSystemPrompt, type Tool } from '@dxos/artifact';
-import { DEFAULT_LLM_MODEL } from '@dxos/assistant';
-import { FunctionType } from '@dxos/functions';
+import { type AssociatedArtifact, createSystemPrompt, type Tool } from '@dxos/artifact';
+import { DEFAULT_EDGE_MODEL, DEFAULT_OLLAMA_MODEL } from '@dxos/assistant';
+import { FunctionType } from '@dxos/functions/types';
 import { log } from '@dxos/log';
 import { useConfig } from '@dxos/react-client';
-import { Filter, type Space, useQuery } from '@dxos/react-client/echo';
+import { Filter, fullyQualifiedId, type Space, useQuery } from '@dxos/react-client/echo';
 import { isNonNullable } from '@dxos/util';
 
 import { AssistantCapabilities } from '../capabilities';
-import { ChatProcessor } from '../hooks';
+import { ChatProcessor, type ChatProcessorOptions } from '../hooks';
 import { covertFunctionToTool, createToolsFromService } from '../tools';
-import { type AssistantSettingsProps, ServiceType } from '../types';
+import { type AIChatType, type AssistantSettingsProps, ServiceType } from '../types';
+
+type UseChatProcessorProps = {
+  chat?: AIChatType;
+  space?: Space;
+  settings?: AssistantSettingsProps;
+  part?: 'deck' | 'dialog';
+  associatedArtifact?: AssociatedArtifact;
+};
 
 /**
  * Configure and create ChatProcessor.
  */
-export const useChatProcessor = (space?: Space, settings?: AssistantSettingsProps): ChatProcessor => {
+export const useChatProcessor = ({
+  chat,
+  space,
+  settings,
+  part = 'deck',
+  associatedArtifact,
+}: UseChatProcessorProps): ChatProcessor => {
   const aiClient = useCapability(AssistantCapabilities.AiClient);
   const globalTools = useCapabilities(Capabilities.Tools);
   const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
@@ -41,40 +55,42 @@ export const useChatProcessor = (space?: Space, settings?: AssistantSettingsProp
   // Tools and context.
   const config = useConfig();
   const functions = useQuery(space, Filter.schema(FunctionType));
+  const chatId = useMemo(() => (chat ? fullyQualifiedId(chat) : undefined), [chat]);
   const [tools, extensions] = useMemo(() => {
     log('creating tools...');
     const tools = [
       ...globalTools.flat(),
-      ...artifactDefinitions.flatMap((definition) => definition.tools),
       ...serviceTools,
       ...functions
         .map((fn) => covertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
         .filter(isNonNullable),
     ];
-    const extensions = { space, dispatch };
+    const extensions = { space, dispatch, pivotId: chatId, part };
     return [tools, extensions];
-  }, [dispatch, globalTools, artifactDefinitions, space, serviceTools, functions]);
+  }, [dispatch, globalTools, space, chatId, serviceTools, functions]);
 
   // Prompt.
   const systemPrompt = useMemo(
     () =>
       createSystemPrompt({
-        artifacts: artifactDefinitions.map((definition) => definition.instructions),
+        artifacts: artifactDefinitions.map((definition) => `${definition.name}\n${definition.instructions}`),
+        associatedArtifact,
       }),
-    [artifactDefinitions],
+    [artifactDefinitions, associatedArtifact],
   );
 
+  // TODO(burdon): Remove default (let backend decide if not specified).
+  const model: ChatProcessorOptions['model'] =
+    settings?.llmProvider === 'ollama'
+      ? ((settings?.ollamaModel ?? DEFAULT_OLLAMA_MODEL) as ChatProcessorOptions['model'])
+      : ((settings?.edgeModel ?? DEFAULT_EDGE_MODEL) as ChatProcessorOptions['model']);
+
   // Create processor.
-  // TODO(burdon): Updated on each query update above. Should just update current processor.
+  // TODO(burdon): Updated on each query update above; should just update current processor.
   const processor = useMemo(() => {
     log('creating processor...', { settings });
-    return new ChatProcessor(aiClient, tools, extensions, {
-      // TODO(burdon): Remove defualt (let backend decide if not specified).
-      model: settings?.llmModel ?? DEFAULT_LLM_MODEL,
-      // TOOD(burdon): Query.
-      systemPrompt,
-    });
-  }, [aiClient, tools, extensions, systemPrompt, settings?.llmModel]);
+    return new ChatProcessor(aiClient.value, tools, artifactDefinitions, extensions, { model, systemPrompt });
+  }, [aiClient.value, tools, extensions, model, systemPrompt]);
 
   return processor;
 };

package/src/hooks/useContextProvider.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { Capabilities, useCapabilities } from '@dxos/app-framework';
+import type { Space } from '@dxos/client/echo';
+import { getDXN, getLabel, getSchema } from '@dxos/echo-schema';
+import { log } from '@dxos/log';
+import { Filter } from '@dxos/react-client/echo';
+
+export type ContextProvider = {
+  query: (params: { query: string }) => Promise<Array<{ uri: string; label: string }>>;
+  resolveMetadata: (params: { uri: string }) => Promise<{ uri: string; label: string }>;
+};
+
+const stringMatch = (query: string, label: string) => label.toLowerCase().startsWith(query.toLowerCase());
+
+export const useContextProvider = (space?: Space): ContextProvider | undefined => {
+  const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
+
+  return useMemo<ContextProvider | undefined>((): ContextProvider | undefined => {
+    if (!space) {
+      return undefined;
+    }
+
+    return {
+      query: async ({ query }) => {
+        const artifactSchemas = artifactDefinitions.map((artifact) => artifact.schema);
+        const { objects } = await space.db
+          .query(Filter.or(...artifactSchemas.map((schema) => Filter.schema(schema))))
+          .run();
+        return objects
+          .map((object) => {
+            log.info('object', { object, label: getLabel(getSchema(object)!, object) });
+            return object;
+          })
+          .filter((object) => stringMatch(query, getLabel(getSchema(object)!, object) ?? ''))
+          .filter((object) => !!getDXN(object))
+          .map((object) => ({
+            uri: getDXN(object)!.toString(),
+            label: getLabel(getSchema(object)!, object) ?? '',
+          }));
+      },
+      resolveMetadata: async ({ uri }) => {
+        const object = await space.db.query({ id: uri }).first();
+        return {
+          uri,
+          label: getLabel(getSchema(object)!, object) ?? '',
+        };
+      },
+    };
+  }, [space, artifactDefinitions]);
+};

package/src/hooks/useLocalTriggerManager.ts

@@ -7,7 +7,7 @@ import { useEffect, useState } from 'react';
 import { Mutex } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { createSubscriptionTrigger, type TriggerFactory } from '@dxos/functions';
-import { FunctionTrigger } from '@dxos/functions';
+import { FunctionTrigger } from '@dxos/functions/types';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';

package/src/hooks/useMessageQueue.ts

@@ -6,18 +6,16 @@ import { useMemo } from 'react';
 
 import { type Message } from '@dxos/artifact';
 import { DXN, QueueSubspaceTags } from '@dxos/keys';
-import { getSpace } from '@dxos/react-client/echo';
-import { useEdgeClient, useQueue } from '@dxos/react-edge-client';
+import { getSpace, useQueue } from '@dxos/react-client/echo';
 
 import { type AIChatType } from '../types';
 
 export const useMessageQueue = (chat?: AIChatType) => {
   const space = getSpace(chat);
   const queueDxn = useMemo(() => {
-    const dxn = space && chat?.queue.dxn;
+    const dxn = space && chat?.assistantChatQueue.dxn;
     return dxn ? new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, space.id, dxn.parts.at(-1)!]) : undefined;
-  }, [space, chat?.queue.dxn]);
+  }, [space, chat?.assistantChatQueue.dxn]);
 
-  const edgeClient = useEdgeClient();
-  return useQueue<Message>(edgeClient, queueDxn);
+  return useQueue<Message>(queueDxn);
 };

package/src/meta.ts

@@ -8,11 +8,11 @@ export const ASSISTANT_PLUGIN = 'dxos.org/plugin/assistant';
 
 export const ASSISTANT_DIALOG = `${ASSISTANT_PLUGIN}/assistant/dialog`;
 
-export const meta = {
+export const meta: PluginMeta = {
   id: ASSISTANT_PLUGIN,
   name: 'Assistant',
   description: 'The Assistant tab allows you to chat with your spaces inside of Composer.',
   icon: 'ph--atom--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-assistant',
   tags: ['experimental'],
-} satisfies PluginMeta;
+};

package/src/testing/test-functions.ts

@@ -3,9 +3,9 @@
 //
 
 import { createSystemPrompt } from '@dxos/artifact';
-import { DEFAULT_LLM_MODEL, type GenerateRequest } from '@dxos/assistant';
+import { DEFAULT_EDGE_MODEL, type GenerateRequest } from '@dxos/assistant';
 
 export const createProcessorOptions = (artifacts: string[]): Pick<GenerateRequest, 'model' | 'systemPrompt'> => ({
-  model: DEFAULT_LLM_MODEL,
+  model: DEFAULT_EDGE_MODEL,
   systemPrompt: createSystemPrompt({ artifacts }),
 });

package/src/tools/function.ts

@@ -5,8 +5,8 @@
 import { defineTool, ToolResult } from '@dxos/artifact';
 import type { Tool } from '@dxos/artifact';
 import { toEffectSchema } from '@dxos/echo-schema';
-import { getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions';
-import type { FunctionType } from '@dxos/functions';
+import { getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions/types';
+import type { FunctionType } from '@dxos/functions/types';
 import { log } from '@dxos/log';
 import type { SpaceId } from '@dxos/react-client/echo';
 import { getMeta } from '@dxos/react-client/echo';