@dxos/plugin-assistant 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/src/capabilities/intent-resolver.ts

@@ -1,135 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
-import { AiContextBinder, AiConversation } from '@dxos/assistant';
-import { Agent } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt, Template } from '@dxos/blueprints';
-import { type Queue } from '@dxos/client/echo';
-import { Sequence } from '@dxos/conductor';
-import { Filter, Key, Obj, Ref, Type } from '@dxos/echo';
-import { TracingService, serializeFunction } from '@dxos/functions';
-import { AutomationCapabilities } from '@dxos/plugin-automation';
-import { getSpace } from '@dxos/react-client/echo';
-import { Collection } from '@dxos/schema';
-import { type Message } from '@dxos/types';
-
-import { type AiChatServices, updateName } from '../processor';
-import { Assistant, AssistantAction } from '../types';
-
-import { ASSISTANT_BLUEPRINT_KEY, createBlueprint } from './blueprint-definition';
-import { AssistantCapabilities } from './capabilities';
-
-export default (context: PluginContext) => [
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: AssistantAction.OnCreateSpace,
-      resolve: ({ space, rootCollection }) =>
-        Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const chatCollection = Collection.makeManaged({ key: Assistant.Chat.typename });
-          const blueprintCollection = Collection.makeManaged({ key: Blueprint.Blueprint.typename });
-          const promptCollection = Collection.makeManaged({ key: Type.getTypename(Prompt.Prompt) });
-          rootCollection.objects.push(
-            Ref.make(chatCollection),
-            Ref.make(blueprintCollection),
-            Ref.make(promptCollection),
-          );
-
-          // TODO(wittjosiah): Remove once function registry is avaiable.
-          space.db.add(serializeFunction(Agent.prompt));
-
-          // Create default chat.
-          const { object: chat } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
-          space.db.add(chat);
-        }),
-    }),
-    createResolver({
-      intent: AssistantAction.CreateChat,
-      resolve: async ({ space, name }) => {
-        const queue = space.queues.create();
-        const chat = Assistant.makeChat({ name, queue });
-
-        // TODO(wittjosiah): This should be a space-level setting.
-        // TODO(burdon): Clone when activated. Copy-on-write for template.
-        const { objects: blueprints } = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
-        let defaultBlueprint = blueprints.find((blueprint) => blueprint.key === ASSISTANT_BLUEPRINT_KEY);
-        if (!defaultBlueprint) {
-          defaultBlueprint = space.db.add(createBlueprint());
-        }
-
-        const binder = new AiContextBinder(queue);
-        await binder.use((binder) => binder.bind({ blueprints: [Ref.make(defaultBlueprint)] }));
-
-        return {
-          data: { object: chat },
-        };
-      },
-    }),
-    createResolver({
-      intent: AssistantAction.UpdateChatName,
-      resolve: async ({ chat }) => {
-        const space = getSpace(chat);
-        const queue = chat.queue.target as Queue<Message.Message>;
-        if (!space || !queue) {
-          return;
-        }
-
-        const runtimeResolver = context.getCapability(AutomationCapabilities.ComputeRuntime);
-        const runtime = await runtimeResolver
-          .getRuntime(space.id)
-          .runPromise(Effect.runtime<AiChatServices>().pipe(Effect.provide(TracingService.layerNoop)));
-
-        await new AiConversation(queue).use(async (conversation) => updateName(runtime, conversation, chat));
-      },
-    }),
-    createResolver({
-      intent: AssistantAction.CreateBlueprint,
-      resolve: ({ key, name, description }) => ({
-        data: {
-          object: Blueprint.make({
-            key,
-            name,
-            description,
-            instructions: Template.make(),
-          }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: AssistantAction.CreatePrompt,
-      resolve: ({ name }) => ({
-        data: {
-          object: Prompt.make({ name }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: AssistantAction.CreateSequence,
-      resolve: ({ name }) => ({
-        data: {
-          object: Obj.make(Sequence, {
-            name,
-            steps: [
-              {
-                id: Key.ObjectId.random(),
-                instructions: 'You are a helpful assistant.',
-              },
-            ],
-          }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: AssistantAction.SetCurrentChat,
-      resolve: ({ companionTo, chat }) =>
-        Effect.gen(function* () {
-          const state = context.getCapability(AssistantCapabilities.MutableState);
-          state.currentChat[Obj.getDXN(companionTo).toString()] = chat && Obj.getDXN(chat).toString();
-        }),
-    }),
-  ]),
-];

package/src/capabilities/repair.ts

@@ -1,49 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { contributes } from '@dxos/app-framework';
-import { Blueprint, Prompt } from '@dxos/blueprints';
-import { Obj, Ref, Type } from '@dxos/echo';
-import { SpaceCapabilities } from '@dxos/plugin-space';
-import { type Space } from '@dxos/react-client/echo';
-import { Collection } from '@dxos/schema';
-
-import { Assistant } from '../types';
-
-export default () =>
-  contributes(SpaceCapabilities.Repair, async ({ space }) => {
-    await ensureSystemCollections(space);
-  });
-
-/**
- * Ensure the root collection has system collections for AI Chats, Blueprints, and Prompts.
- */
-const ensureSystemCollections = async (space: Space) => {
-  const rootCollection: Collection.Collection = await space.properties[Collection.Collection.typename]?.load();
-  if (!rootCollection) {
-    return;
-  }
-
-  const objects = await Promise.all(rootCollection.objects.map((ref) => ref.load()));
-  const chats = objects.find(
-    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Assistant.Chat.typename,
-  );
-  if (!chats) {
-    rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Assistant.Chat.typename })));
-  }
-
-  const blueprints = objects.find(
-    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Blueprint.Blueprint.typename,
-  );
-  if (!blueprints) {
-    rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Blueprint.Blueprint.typename })));
-  }
-
-  const prompts = objects.find(
-    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Type.getTypename(Prompt.Prompt),
-  );
-  if (!prompts) {
-    rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Type.getTypename(Prompt.Prompt) })));
-  }
-};

package/src/components/BlueprintArticle.tsx

@@ -1,29 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { type SurfaceComponentProps } from '@dxos/app-framework/react';
-import { type Blueprint } from '@dxos/blueprints';
-import { Obj } from '@dxos/echo';
-import { Toolbar } from '@dxos/react-ui';
-import { useAttention } from '@dxos/react-ui-attention';
-import { StackItem } from '@dxos/react-ui-stack';
-
-import { TemplateEditor } from './TemplateEditor';
-
-export type BlueprintArticleProps = SurfaceComponentProps<Blueprint.Blueprint>;
-
-export const BlueprintArticle = ({ subject }: BlueprintArticleProps) => {
-  const { hasAttention } = useAttention(Obj.getDXN(subject).toString());
-
-  return (
-    <StackItem.Content toolbar>
-      <Toolbar.Root disabled={!hasAttention} />
-      <TemplateEditor id={subject.id} template={subject.instructions} classNames='container-max-width' />
-    </StackItem.Content>
-  );
-};
-
-export default BlueprintArticle;

package/src/components/ChatCompanion.tsx

@@ -1,155 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Array from 'effect/Array';
-import * as Function from 'effect/Function';
-import * as Option from 'effect/Option';
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-
-import { Capabilities, createIntent } from '@dxos/app-framework';
-import { useCapabilities, useIntentDispatcher } from '@dxos/app-framework/react';
-import { Blueprint } from '@dxos/blueprints';
-import { getSpace } from '@dxos/client/echo';
-import { Filter, Obj, Ref } from '@dxos/echo';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { useQuery } from '@dxos/react-client/echo';
-import { useAsyncEffect } from '@dxos/react-ui';
-
-import { ChatContainer, type ChatEvent } from '../components';
-import { useBlueprintRegistry, useContextBinder } from '../hooks';
-import { Assistant, AssistantAction } from '../types';
-
-export type ChatCompanionProps = {
-  role?: string;
-  data: { subject: Assistant.Chat | 'assistant-chat'; companionTo: Obj.Any };
-};
-
-export const ChatCompanion = ({ role, data }: ChatCompanionProps) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const blueprintRegistry = useBlueprintRegistry();
-  const companionTo = data.companionTo;
-
-  const space = getSpace(companionTo);
-  const [chat, setChat] = useState(data.subject === 'assistant-chat' ? undefined : data.subject);
-  useEffect(() => {
-    setChat(data.subject === 'assistant-chat' ? undefined : data.subject);
-  }, [data.subject]);
-
-  const chatQueue = space && chat ? space.queues.get(chat.queue.dxn) : undefined;
-  const binder = useContextBinder(chatQueue);
-
-  // Initialize companion chat if it doesn't exist, but don't add it to the space immediately.
-  useAsyncEffect(async () => {
-    if (!space || chat) {
-      return;
-    }
-
-    const { data } = await dispatch(createIntent(AssistantAction.CreateChat, { space }));
-    setChat(data?.object);
-  }, [chat, space]);
-
-  // Add chat to space when user submits the first message.
-  const handleEvent = useCallback(
-    async (event: ChatEvent) => {
-      const chatInSpace = !!getSpace(chat);
-      if (chatInSpace || !chat || !space) {
-        return;
-      }
-
-      if (event.type === 'submit') {
-        await dispatch(
-          createIntent(SpaceAction.AddObject, {
-            object: chat,
-            target: space,
-            hidden: true,
-          }),
-        );
-        await dispatch(
-          createIntent(SpaceAction.AddRelation, {
-            space,
-            schema: Assistant.CompanionTo,
-            source: chat,
-            target: companionTo,
-          }),
-        );
-        await dispatch(
-          createIntent(AssistantAction.SetCurrentChat, {
-            companionTo,
-            chat,
-          }),
-        );
-      }
-    },
-    [chat, space, companionTo, dispatch],
-  );
-
-  const metadata = useCapabilities(Capabilities.Metadata);
-  const blueprintKeys = useMemo(
-    () =>
-      Function.pipe(
-        metadata,
-        Array.findFirst(
-          (
-            capability,
-          ): capability is {
-            id: string;
-            metadata: { blueprints?: string[] };
-          } => capability.id === Obj.getTypename(companionTo),
-        ),
-        Option.flatMap((c) => Option.fromNullable(c.metadata.blueprints)),
-        Option.getOrElse(() => [] as string[]),
-      ),
-    [metadata, companionTo],
-  );
-  const existingBlueprints = useQuery(space, Filter.type(Blueprint.Blueprint));
-  const pluginBlueprints = useMemo(
-    () => existingBlueprints.filter((blueprint) => blueprintKeys.includes(blueprint.key)),
-    [existingBlueprints, blueprintKeys],
-  );
-
-  // Initialize related blueprints that are not already in the space.
-  useAsyncEffect(async () => {
-    if (!space) {
-      return;
-    }
-
-    // NOTE: This must be run instead of using the useQuery result to avoid duplicates.
-    const { objects: existingBlueprints } = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
-    for (const key of blueprintKeys) {
-      const existingBlueprint = existingBlueprints.find((blueprint) => blueprint.key === key);
-      if (existingBlueprint) {
-        continue;
-      }
-
-      const blueprint = blueprintRegistry.getByKey(key);
-      if (!blueprint) {
-        continue;
-      }
-
-      space.db.add(Obj.clone(blueprint));
-    }
-  }, [space, blueprintRegistry, blueprintKeys]);
-
-  useAsyncEffect(async () => {
-    if (!binder?.isOpen) {
-      return;
-    }
-
-    if (pluginBlueprints.length > 0) {
-      await binder.bind({
-        blueprints: pluginBlueprints.map((blueprint) => Ref.make(blueprint)),
-      });
-    }
-
-    if (Obj.instanceOf(Blueprint.Blueprint, companionTo)) {
-      await binder.bind({ blueprints: [Ref.make(companionTo)] });
-    } else {
-      await binder.bind({ objects: [Ref.make(companionTo)] });
-    }
-  }, [binder, companionTo, blueprintKeys]);
-
-  return <ChatContainer role={role} space={space} chat={chat} companionTo={companionTo} onEvent={handleEvent} />;
-};
-
-export default ChatCompanion;

package/src/components/ChatContainer.tsx

@@ -1,61 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities } from '@dxos/app-framework';
-import { useCapability } from '@dxos/app-framework/react';
-import { type Space, getSpace } from '@dxos/client/echo';
-import { type Obj } from '@dxos/echo';
-import { StackItem } from '@dxos/react-ui-stack';
-
-import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
-import { meta } from '../meta';
-import { type Assistant } from '../types';
-
-import { Chat, type ChatRootProps } from './Chat';
-
-export type ChatContainerProps = {
-  role?: string;
-  space?: Space;
-  chat?: Assistant.Chat;
-  companionTo?: Obj.Any;
-} & Pick<ChatRootProps, 'onEvent'>;
-
-export const ChatContainer = ({ space: spaceProp, chat, companionTo, onEvent }: ChatContainerProps) => {
-  const space = spaceProp ?? getSpace(chat);
-  const settings = useCapability(Capabilities.SettingsStore).getStore<Assistant.Settings>(meta.id)?.value;
-  const services = useChatServices({ space, chat });
-  const [online, setOnline] = useOnline();
-  const { preset, ...chatProps } = usePresets(online);
-  const blueprintRegistry = useBlueprintRegistry();
-  const processor = useChatProcessor({
-    space,
-    chat,
-    preset,
-    services,
-    blueprintRegistry,
-    settings,
-  });
-
-  if (!processor) {
-    return null;
-  }
-
-  return (
-    <StackItem.Content toolbar>
-      <Chat.Root space={space} chat={chat} processor={processor} onEvent={onEvent}>
-        <Chat.Toolbar companionTo={companionTo} />
-        <Chat.Viewport classNames='container-max-width'>
-          <Chat.Thread />
-          <div role='none' className='p-4'>
-            <Chat.Prompt {...chatProps} outline preset={preset?.id} online={online} onOnlineChange={setOnline} />
-          </div>
-        </Chat.Viewport>
-      </Chat.Root>
-    </StackItem.Content>
-  );
-};
-
-export default ChatContainer;

package/src/components/ChatProgress/ChatProgress.tsx

@@ -1,67 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-
-import { addEventListener } from '@dxos/async';
-import { Flex, ProgressBar, type ProgressBarProps, TextCrawl, useExecutionGraph } from '@dxos/react-ui-components';
-
-import { type Assistant } from '../../types';
-
-// TODO(burdon): Reset after each session.
-// TODO(burdon): Show after delay.
-// TODO(burdon): Test with errors.
-// TODO(burdon): Filter out empty trace messages.
-
-// {
-//   "id": "01K3TE3C2VAXETP500QKDHK3C4_block_3",
-//   "branch": "main",
-//   "parents": [],
-//   "icon": "ph--robot--regular",
-//   "message": "\n"
-// }
-
-export type ChatProgressProps = {
-  chat: Assistant.Chat;
-};
-
-export const ChatProgress = ({ chat }: ChatProgressProps) => {
-  const { commits } = useExecutionGraph(chat.traceQueue?.target, true);
-  const nodes = useMemo(() => commits.map((commit) => ({ id: commit.id, message: commit.message })), [commits]);
-  const lines = useMemo(() => commits.map((commit) => commit.message), [commits]);
-
-  const [index, setIndex] = useState<number | undefined>(undefined);
-  const handleSelect = useCallback<NonNullable<ProgressBarProps['onSelect']>>(({ index }) => {
-    setIndex((current) => {
-      return current === index ? undefined : index;
-    });
-  }, []);
-
-  const ref = useRef<HTMLDivElement>(null);
-  useEffect(() => {
-    if (!ref.current) {
-      return;
-    }
-
-    return addEventListener(ref.current, 'keydown', (event) => {
-      switch (event.key) {
-        case 'ArrowLeft': {
-          setIndex((current) => (current === undefined || current <= 0 ? 0 : current - 1));
-          break;
-        }
-        case 'ArrowRight': {
-          setIndex((current) => (current === undefined || current >= nodes.length ? nodes.length - 1 : current + 1));
-          break;
-        }
-      }
-    });
-  }, [nodes.length]);
-
-  return (
-    <Flex column tabIndex={0} ref={ref} classNames='outline-none'>
-      <ProgressBar nodes={nodes} index={index} onSelect={handleSelect} />
-      <TextCrawl classNames='pis-4 text-sm text-description' lines={lines} autoAdvance />
-    </Flex>
-  );
-};

package/src/components/ChatThread/reducers.ts

@@ -1,151 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type ContentBlock, type Message } from '@dxos/types';
-
-type Reducer<R, I> = (acc: R, value: I, idx: number) => R;
-
-/**
- * Reducer that collapses related message blocks into single messages.
- * For example, combines tool request/response pairs into a single message.
- *
- * Typical order:
- * - message 0
- *  - text
- * - message 1
- *  - text
- *  - toolCall
- *  - summary
- * - message 2
- *  - toolResult
- * - message 3
- *  - text
- *  - summary
- *
- * Coverts to:
- * - message 0
- *  - text
- * - message 1
- *  - text
- * - message 2
- *  - toolCall
- *  - toolResult
- *  - summary
- * - message 3
- *  - text
- *  - summary
- */
-export const reduceMessages: Reducer<
-  {
-    messages: Message.Message[];
-    current?: Message.Message;
-    toolBlock?: boolean;
-    assistantMessages?: Message.Message[];
-  },
-  Message.Message
-> = ({ messages, current, toolBlock, assistantMessages = [] }, message) => {
-  // Treat tool calls as assistant messages.
-  let assistant = message?.sender.role === 'assistant';
-  let i = 0;
-  for (const block of message.blocks) {
-    switch (block._tag) {
-      // TODO(burdon): Preserve call tool title.
-      case 'toolCall': {
-        assistant = true;
-        if (!toolBlock) {
-          current = {
-            ...message,
-            id: [message.id, i++].join('_'),
-            blocks: [block],
-          };
-          messages.push(current);
-          toolBlock = true;
-        } else {
-          current!.blocks.push(block);
-        }
-        break;
-      }
-
-      case 'toolResult': {
-        assistant = true;
-        if (toolBlock) {
-          current!.blocks.push(block);
-        }
-        break;
-      }
-
-      case 'summary': {
-        assistant = true;
-        if (toolBlock) {
-          current!.blocks.push(block);
-        } else {
-          const summary = reduceSummary([...assistantMessages, message]);
-          current!.blocks.push(summary);
-        }
-        break;
-      }
-
-      default: {
-        assistant = message.sender.role === 'assistant';
-        current = {
-          ...message,
-          id: [message.id, i++].join('_'),
-          blocks: [block],
-        };
-        messages.push(current);
-        toolBlock = false;
-        break;
-      }
-    }
-  }
-
-  return {
-    messages,
-    current,
-    toolBlock,
-    assistantMessages: assistant ? [...assistantMessages, message] : undefined,
-  };
-};
-
-/**
- * Accumulate token counts from all summary blocks in pending messages.
- */
-const reduceSummary = (messages: Message.Message[]): ContentBlock.Summary => {
-  let start: number | undefined;
-  return messages.reduce<ContentBlock.Summary>(
-    (acc, msg) => {
-      const time = new Date(msg.created).getTime();
-      if (!start) {
-        start = time;
-      }
-      msg.blocks.forEach((block) => {
-        switch (block._tag) {
-          case 'toolCall': {
-            acc.toolCalls = (acc.toolCalls ?? 0) + 1;
-            break;
-          }
-          case 'summary': {
-            acc.model = block.model;
-            if (block.usage) {
-              acc.message = block.message;
-              acc.usage = {
-                inputTokens: (acc.usage?.inputTokens ?? 0) + (block.usage.inputTokens ?? 0),
-                outputTokens: (acc.usage?.outputTokens ?? 0) + (block.usage.outputTokens ?? 0),
-                totalTokens: (acc.usage?.totalTokens ?? 0) + (block.usage.totalTokens ?? 0),
-              };
-              acc.duration = time - (start ?? time);
-            }
-            break;
-          }
-        }
-      });
-
-      return acc;
-    },
-    {
-      _tag: 'summary',
-      duration: 0,
-    } satisfies ContentBlock.Summary,
-  );
-};

package/src/components/PromptArticle.tsx

@@ -1,51 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React, { useMemo } from 'react';
-
-import { type SurfaceComponentProps } from '@dxos/app-framework/react';
-import { Agent } from '@dxos/assistant-toolkit';
-import { type Prompt } from '@dxos/blueprints';
-import { Obj } from '@dxos/echo';
-import { invokeFunctionWithTracing, useComputeRuntimeCallback } from '@dxos/plugin-automation';
-import { getSpace } from '@dxos/react-client/echo';
-import { Toolbar, useTranslation } from '@dxos/react-ui';
-import { useAttention } from '@dxos/react-ui-attention';
-import { StackItem } from '@dxos/react-ui-stack';
-
-import { meta } from '../meta';
-
-import { TemplateEditor } from './TemplateEditor';
-
-export type PromptArticleProps = SurfaceComponentProps<Prompt.Prompt>;
-
-export const PromptArticle = ({ subject }: PromptArticleProps) => {
-  const { t } = useTranslation(meta.id);
-  const space = getSpace(subject);
-  const { hasAttention } = useAttention(Obj.getDXN(subject).toString());
-
-  const inputData = useMemo(
-    () =>
-      subject && {
-        prompt: space?.db.makeRef(Obj.getDXN(subject)),
-        input: {},
-      },
-    [subject, space],
-  );
-
-  const handleRun = useComputeRuntimeCallback(space, () => invokeFunctionWithTracing(Agent.prompt, inputData), [
-    inputData,
-  ]);
-
-  return (
-    <StackItem.Content toolbar>
-      <Toolbar.Root disabled={!hasAttention} onClick={handleRun}>
-        <Toolbar.IconButton iconOnly icon='ph--play--regular' label={t('run prompt label')} onClick={handleRun} />
-      </Toolbar.Root>
-      <TemplateEditor id={subject.id} template={subject.instructions} classNames='container-max-width' />
-    </StackItem.Content>
-  );
-};
-
-export default PromptArticle;