@dxos/plugin-assistant 0.8.0 → 0.8.1-main.013e445

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/TemplateEditor/TemplateForm.tsx

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Schema as S } from '@effect/schema';
+import { type Schema as S } from 'effect';
 import React, { Fragment, useEffect } from 'react';
 
 import { Input, Select, useTranslation } from '@dxos/react-ui';

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

@@ -19,9 +19,8 @@ import {
 import { withPluginManager } from '@dxos/app-framework/testing';
 import { Message, type Tool } from '@dxos/artifact';
 import { genericTools, localServiceEndpoints, type IsObject } from '@dxos/artifact-testing';
-import { AIServiceClientImpl } from '@dxos/assistant';
+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 AIServiceClientImpl({ endpoint: endpoints.ai }));
-  const [edgeClient] = useState(() => new EdgeHttpClient(endpoints.edge));
+  const [aiClient] = useState(() => new AIServiceEdgeClient({ endpoint: endpoints.ai }));
   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}
     />
   );

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.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/email.ts

@@ -6,8 +6,8 @@ import { findObjectWithForeignKey } from '@dxos/echo-db';
 import { foreignKey } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 import { MailboxType } from '@dxos/plugin-inbox/types';
-import { MessageType } from '@dxos/plugin-space/types';
 import { type Space, Filter, create, makeRef } from '@dxos/react-client/echo';
+import { MessageType } from '@dxos/schema';
 
 export const SOURCE_ID = 'hub.dxos.network/api/mailbox';
 
@@ -29,8 +29,8 @@ export const handleEmail = async (space: Space, data: any) => {
           MessageType,
           {
             sender: { email: message.from },
-            timestamp: new Date(message.created).toISOString(),
-            text: message.body,
+            created: new Date(message.created).toISOString(),
+            blocks: [{ type: 'text', text: message.body }],
             properties: {
               subject: message.subject,
               to: [{ email: message.to }],

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 AIService,
-} 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.
@@ -92,26 +77,12 @@ export class ChatProcessor {
   });
 
   constructor(
-    private readonly _service: AIService,
+    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,
+        extensions: this._extensions,
+        generationOptions: {
+          model: this._options.model,
+          systemPrompt: this._options.systemPrompt,
+        },
+      });
+
+      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._service.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';
 }