@dxos/plugin-assistant 0.8.2-staging.7ac8446 → 0.8.3-main.672df60

package/src/components/Thread/ToolInvocations.tsx

@@ -4,7 +4,7 @@
 
 import React, { type FC, useEffect, useMemo, useRef, useState } from 'react';
 
-import { type Message, type ToolType } from '@dxos/artifact';
+import { type AgentStatus, type Message, type Tool } from '@dxos/ai';
 import { log } from '@dxos/log';
 import { type ThemedClassName } from '@dxos/react-ui';
 import { NumericTabs, StatusRoll, ToggleContainer } from '@dxos/react-ui-components';
@@ -17,22 +17,22 @@ export const isToolMessage = (message: Message) => {
   return message.content.some((block) => block.type === 'tool_use' || block.type === 'tool_result');
 };
 
-const getToolName = (tool: ToolType) => {
+const getToolName = (tool: Tool) => {
   return tool.namespace && tool.function ? `${tool.namespace}:${tool.function}` : tool.name.split('_').pop();
 };
 
-const getToolCaption = (tool: ToolType | undefined) => {
+const getToolCaption = (tool: Tool | undefined, status: AgentStatus | undefined) => {
   if (!tool) {
     return 'Calling tool...';
   }
 
-  return tool.caption ?? `Calling ${getToolName(tool)}...`;
+  return status?.message ?? tool.caption ?? `Calling ${getToolName(tool)}...`;
 };
 
 export const ToolBlock: FC<ThemedClassName<ThreadMessageProps>> = ({ classNames, message, tools }) => {
   const { content = [] } = message;
 
-  let request: { tool: ToolType | undefined; block: any } | undefined;
+  let request: { tool: Tool | undefined; block: any } | undefined;
   const blocks = content.filter((block) => block.type === 'tool_use' || block.type === 'tool_result');
   const items = blocks
     .map((block) => {
@@ -43,8 +43,10 @@ export const ToolBlock: FC<ThemedClassName<ThreadMessageProps>> = ({ classNames,
             return null;
           }
 
+          log.info('tool_use', { tool: request?.tool, status: block.currentStatus });
+
           request = { tool: tools?.find((tool) => tool.name === block.name), block };
-          return { title: getToolCaption(request.tool), block };
+          return { title: getToolCaption(request.tool, block.currentStatus), block };
         }
 
         case 'tool_result': {
@@ -53,7 +55,7 @@ export const ToolBlock: FC<ThemedClassName<ThreadMessageProps>> = ({ classNames,
             return { title: 'Error', block };
           }
 
-          return { title: `${getToolCaption(request.tool)} (Success)`, block };
+          return { title: `${getToolCaption(request.tool, undefined)} (Success)`, block };
         }
 
         default: {

package/src/components/Thread/reducer.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Message } from '@dxos/artifact';
+import { type Message } from '@dxos/ai';
 
 // TODO(burdon): Move to util?
 type Reducer<R, I> = (acc: R, value: I) => R;

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

@@ -32,7 +32,7 @@ const DefaultStory = (props: ToolboxProps) => {
 };
 
 const meta: Meta<typeof Toolbox> = {
-  title: 'plugins/plugin-automation/Toolbox',
+  title: 'plugins/plugin-assistant/Toolbox',
   component: Toolbox,
   render: DefaultStory,
   decorators: [
@@ -44,7 +44,7 @@ const meta: Meta<typeof Toolbox> = {
             await client.halo.createIdentity();
           },
         }),
-        SpacePlugin({ observability: false }),
+        SpacePlugin(),
         SettingsPlugin(),
         IntentPlugin(),
         ChessPlugin(),
@@ -54,11 +54,11 @@ const meta: Meta<typeof Toolbox> = {
       capabilities,
     }),
     withTheme,
-    withLayout({ tooltips: true }),
+    withLayout(),
   ],
   parameters: {
-    translations,
     layout: 'centered',
+    translations,
   },
 };
 

package/src/components/Toolbox/Toolbox.tsx

@@ -4,9 +4,10 @@
 
 import React, { useState, useEffect, Fragment, type FC } from 'react';
 
+import { parseToolName, type Tool } from '@dxos/ai';
 import { Capabilities, useCapabilities } from '@dxos/app-framework';
-import { parseToolName, type ArtifactDefinition, type Tool } from '@dxos/artifact';
-import { FunctionType } from '@dxos/functions/types';
+import { type ArtifactDefinition } from '@dxos/artifact';
+import { FunctionType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { Filter, type Space, useQuery } from '@dxos/react-client/echo';
 import { type ThemedClassName } from '@dxos/react-ui';
@@ -93,7 +94,7 @@ export const ToolboxContainer = ({ classNames, space }: ThemedClassName<{ space?
   const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
 
   // Registered services.
-  const services = useQuery(space, Filter.schema(ServiceType));
+  const services = useQuery(space, Filter.type(ServiceType));
   const [serviceTools, setServiceTools] = useState<{ service: ServiceType; tools: Tool[] }[]>([]);
   useEffect(() => {
     log('creating service tools...', { services: services.length });
@@ -107,7 +108,7 @@ export const ToolboxContainer = ({ classNames, space }: ThemedClassName<{ space?
   }, [services]);
 
   // Deployed functions.
-  const functions = useQuery(space, Filter.schema(FunctionType));
+  const functions = useQuery(space, Filter.type(FunctionType));
 
   return (
     <Toolbox classNames={classNames} artifacts={artifactDefinitions} services={serviceTools} functions={functions} />

package/src/components/index.ts

@@ -4,8 +4,10 @@
 
 import { lazy } from 'react';
 
+export * from './AmbientDialog';
 export * from './AssistantSettings';
-export * from './ServiceRegistry';
+export * from './Prompt';
+export * from './PromptSettings';
 export * from './TemplateEditor';
 export * from './Thread';
 export * from './Toolbox';
@@ -14,5 +16,6 @@ export * from './Toolbox';
 //  Repro: open assistant dialog then close.
 //  https://github.com/microsoft/fluentui/issues/34020
 export const AssistantDialog = lazy(() => import('./AssistantDialog'));
+export const BlueprintEditor = lazy(() => import('./BlueprintEditor'));
 export const ChatContainer = lazy(() => import('./ChatContainer'));
 export const TemplateContainer = lazy(() => import('./TemplateContainer'));

package/src/experimental/transcription/index.ts

@@ -0,0 +1,3 @@
+//
+// Copyright 2025 DXOS.org
+//

package/src/hooks/index.ts

@@ -5,7 +5,6 @@
 export * from './processor';
 
 export * from './useChatProcessor';
-export * from './useLocalTriggerManager';
 export * from './useMessageQueue';
 export * from './useServices';
 export * from './useTextInputEvents';

package/src/hooks/processor.ts

@@ -4,12 +4,21 @@
 
 import { type Signal, batch, computed, signal } from '@preact/signals-core';
 
+import {
+  DEFAULT_EDGE_MODEL,
+  type ExecutableTool,
+  type AIServiceClient,
+  type GenerateRequest,
+  type Message,
+  type MessageContentBlock,
+  type ToolUseContentBlock,
+} from '@dxos/ai';
 import { type PromiseIntentDispatcher } from '@dxos/app-framework';
-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 { type ArtifactDefinition } from '@dxos/artifact';
+import { AISession, type ArtifactDiffResolver } from '@dxos/assistant';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { type Space } from '@dxos/react-client/echo';
+import { Filter, getVersion, type Space } from '@dxos/react-client/echo';
 
 // TODO(burdon): Factor out.
 declare global {
@@ -78,7 +87,7 @@ export class ChatProcessor {
 
   constructor(
     private readonly _ai: AIServiceClient,
-    private _tools?: Tool[],
+    private _tools?: ExecutableTool[],
     private _artifacts?: ArtifactDefinition[],
     private readonly _extensions?: ToolContextExtensions,
     private readonly _options: ChatProcessorOptions = defaultOptions,
@@ -91,7 +100,7 @@ export class ChatProcessor {
   /**
    * Update tools.
    */
-  setTools(tools: Tool[]) {
+  setTools(tools: ExecutableTool[]): void {
     this._tools = tools;
   }
 
@@ -99,7 +108,7 @@ export class ChatProcessor {
    * Make GPT request.
    */
   async request(message: string, options: RequestOptions = {}): Promise<Message[]> {
-    this._session = new AISession({ operationModel: 'immediate' });
+    this._session = new AISession({ operationModel: 'configured' });
 
     // Message complete.
     this._session.message.on((message) => {
@@ -120,22 +129,50 @@ export class ChatProcessor {
       this._pending.value = [...this._pending.value, message];
     });
 
+    this._session.toolStatusReport.on(({ message, status }) => {
+      const msg = this._pending.peek().find((m) => m.id === message.id);
+      const toolUse = msg?.content.find((block) => block.type === 'tool_use');
+      if (!toolUse) {
+        return;
+      }
+
+      const block = msg?.content.find(
+        (block): block is ToolUseContentBlock => block.type === 'tool_use' && block.id === toolUse.id,
+      );
+      if (block) {
+        this._pending.value = this._pending.value.map((m) => {
+          if (m.id === message.id) {
+            return {
+              ...m,
+              content: m.content.map((b) =>
+                b.type === 'tool_use' && b.id === toolUse.id ? { ...b, currentStatus: status } : b,
+              ),
+            };
+          }
+          return m;
+        });
+      } else {
+        log.warn('no block for status report');
+      }
+    });
+
     try {
       const messages = await this._session.run({
         client: this._ai,
         history: options.history ?? [],
         artifacts: this._artifacts ?? [],
+        requiredArtifactIds: this._artifacts?.map((artifact) => artifact.id) ?? [],
         tools: this._tools ?? [],
         prompt: message,
         systemPrompt: this._options.systemPrompt,
         extensions: this._extensions,
+        artifactDiffResolver: this._artifactDiffResolver,
         generationOptions: {
           model: this._options.model,
         },
       });
 
-      log.info('completed', { messages });
-
+      log('completed', { messages });
       options.onComplete?.(this._pending.value);
     } catch (err) {
       log.catch(err);
@@ -170,6 +207,29 @@ export class ChatProcessor {
 
     return messages;
   }
+
+  private _artifactDiffResolver: ArtifactDiffResolver = async (artifacts) => {
+    const space = this._extensions?.space;
+    if (!space) {
+      return new Map();
+    }
+    const versions = new Map();
+    await Promise.all(
+      artifacts.map(async (artifact) => {
+        const {
+          objects: [object],
+        } = await space.db.query(Filter.ids(artifact.id)).run();
+        if (!object) {
+          return;
+        }
+        versions.set(artifact.id, {
+          version: getVersion(object),
+          diff: `Current state: ${JSON.stringify(object)}`,
+        });
+      }),
+    );
+    return versions;
+  };
 }
 
 // TODO(wittjosiah): Move to ai-service-client.

package/src/hooks/useChatProcessor.tsx

@@ -4,10 +4,10 @@
 
 import { useEffect, useMemo, useState } from 'react';
 
+import { DEFAULT_EDGE_MODEL, DEFAULT_OLLAMA_MODEL, type ExecutableTool } from '@dxos/ai';
 import { Capabilities, useCapabilities, useCapability, useIntentDispatcher } from '@dxos/app-framework';
-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 { type AssociatedArtifact, createSystemPrompt } from '@dxos/artifact';
+import { FunctionType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { useConfig } from '@dxos/react-client';
 import { Filter, fullyQualifiedId, type Space, useQuery } from '@dxos/react-client/echo';
@@ -15,7 +15,7 @@ import { isNonNullable } from '@dxos/util';
 
 import { AssistantCapabilities } from '../capabilities';
 import { ChatProcessor, type ChatProcessorOptions } from '../hooks';
-import { covertFunctionToTool, createToolsFromService } from '../tools';
+import { convertFunctionToTool, createToolsFromService } from '../tools';
 import { type AIChatType, type AssistantSettingsProps, ServiceType } from '../types';
 
 type UseChatProcessorProps = {
@@ -33,7 +33,8 @@ export const useChatProcessor = ({
   chat,
   space,
   settings,
-  part = 'deck',
+  // part = 'deck',
+  part,
   associatedArtifact,
 }: UseChatProcessorProps): ChatProcessor => {
   const aiClient = useCapability(AssistantCapabilities.AiClient);
@@ -42,8 +43,8 @@ export const useChatProcessor = ({
   const { dispatchPromise: dispatch } = useIntentDispatcher();
 
   // Services.
-  const services = useQuery(space, Filter.schema(ServiceType));
-  const [serviceTools, setServiceTools] = useState<Tool[]>([]);
+  const services = useQuery(space, Filter.type(ServiceType));
+  const [serviceTools, setServiceTools] = useState<ExecutableTool[]>([]);
   useEffect(() => {
     log('creating service tools...');
     queueMicrotask(async () => {
@@ -54,15 +55,15 @@ export const useChatProcessor = ({
 
   // Tools and context.
   const config = useConfig();
-  const functions = useQuery(space, Filter.schema(FunctionType));
+  const functions = useQuery(space, Filter.type(FunctionType));
   const chatId = useMemo(() => (chat ? fullyQualifiedId(chat) : undefined), [chat]);
   const [tools, extensions] = useMemo(() => {
     log('creating tools...');
-    const tools = [
+    const tools: ExecutableTool[] = [
       ...globalTools.flat(),
       ...serviceTools,
       ...functions
-        .map((fn) => covertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
+        .map((fn) => convertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
         .filter(isNonNullable),
     ];
     const extensions = { space, dispatch, pivotId: chatId, part };
@@ -90,7 +91,7 @@ export const useChatProcessor = ({
   const processor = useMemo(() => {
     log('creating processor...', { settings });
     return new ChatProcessor(aiClient.value, tools, artifactDefinitions, extensions, { model, systemPrompt });
-  }, [aiClient.value, tools, extensions, model, systemPrompt]);
+  }, [aiClient.value, tools, artifactDefinitions, extensions, model, systemPrompt]);
 
   return processor;
 };

package/src/hooks/useContextProvider.ts

@@ -5,10 +5,10 @@
 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 { Filter, type Space } from '@dxos/client/echo';
+import { Obj, type Type } from '@dxos/echo';
+import { getObjectDXN, getLabel } 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 }>>;
@@ -29,25 +29,28 @@ export const useContextProvider = (space?: Space): ContextProvider | undefined =
       query: async ({ query }) => {
         const artifactSchemas = artifactDefinitions.map((artifact) => artifact.schema);
         const { objects } = await space.db
-          .query(Filter.or(...artifactSchemas.map((schema) => Filter.schema(schema))))
+          .query(Filter.or(...artifactSchemas.map((schema) => Filter.type(schema as Type.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) ?? '',
-          }));
+        return (
+          objects
+            .map((object) => {
+              log.info('object', { object, label: getLabel(Obj.getSchema(object)!, object) });
+              return object;
+            })
+            .filter((object) => stringMatch(query, getLabel(Obj.getSchema(object)!, object) ?? ''))
+            // TODO(dmaretskyi): `Type.getDXN` (at the point of writing) didn't work here as it was schema-only.
+            .filter((object) => !!getObjectDXN(object))
+            .map((object) => ({
+              uri: getObjectDXN(object as any)!.toString(),
+              label: getLabel(Obj.getSchema(object)!, object) ?? '',
+            }))
+        );
       },
       resolveMetadata: async ({ uri }) => {
-        const object = await space.db.query({ id: uri }).first();
+        const object = await space.db.query(Filter.ids(uri)).first();
         return {
           uri,
-          label: getLabel(getSchema(object)!, object) ?? '',
+          label: getLabel(Obj.getSchema(object)!, object) ?? '',
         };
       },
     };

package/src/hooks/useMessageQueue.ts

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

package/src/meta.ts

@@ -13,6 +13,6 @@ export const meta: PluginMeta = {
   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'],
+  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-assistant',
+  tags: ['labs'],
 };

package/src/parser/filter-generator.test.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { Filter } from '@dxos/echo-schema';
+
+import { createFilter } from './filter-generator';
+import { QueryParser } from './query-parser';
+
+describe('FilterGenerator', () => {
+  test('simple queries', ({ expect }) => {
+    const parser = new QueryParser('type:example.com/type/Person');
+    const ast = parser.parse();
+    expect(ast).toEqual({
+      type: 'binary',
+      operator: 'EQ',
+      left: {
+        type: 'identifier',
+        name: 'type',
+      },
+      right: {
+        type: 'literal',
+        value: 'example.com/type/Person',
+      },
+    });
+
+    const filter = createFilter(ast);
+    expect(filter).toEqual(Filter.typename('example.com/type/Person'));
+  });
+});

package/src/parser/filter-generator.ts

@@ -0,0 +1,81 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Filter } from '@dxos/echo-schema';
+
+import {
+  type BinaryExpression,
+  type Expression,
+  type Identifier,
+  type Literal,
+  type RelationalOperator,
+  type UnaryExpression,
+} from './types';
+
+const relationalOperators: Record<RelationalOperator, (value: any) => Filter<any>> = {
+  EQ: Filter.eq,
+  LT: Filter.lt,
+  GT: Filter.gt,
+};
+
+const specialPredicates: Record<string, (value: string) => Filter<any>> = {
+  ['type' as const]: Filter.typename,
+};
+
+export const createFilter = (ast: Expression): Filter<any> => {
+  switch (ast.type) {
+    case 'binary': {
+      const { operator, left, right } = ast as BinaryExpression;
+
+      // Handle logical operators.
+      if (operator === 'AND') {
+        return Filter.and(createFilter(left), createFilter(right));
+      }
+      if (operator === 'OR') {
+        return Filter.or(createFilter(left), createFilter(right));
+      }
+
+      // Handle special predicates (e.g., "type:Person")
+      const predicateName = (left as Identifier).name;
+      const specialFilter = specialPredicates[predicateName];
+      if (specialFilter) {
+        return specialFilter((right as Literal).value);
+      }
+
+      // Handle relational operators
+      const filterFn = relationalOperators[operator as RelationalOperator];
+      if (filterFn) {
+        return filterFn((right as Literal).value);
+      }
+
+      throw new Error(`Unsupported operator: ${operator}`);
+    }
+
+    case 'unary': {
+      const { operator, argument } = ast as UnaryExpression;
+      if (operator === 'NOT') {
+        return Filter.not(createFilter(argument));
+      }
+      throw new Error(`Unsupported unary operator: ${operator}`);
+    }
+
+    case 'identifier': {
+      const { name } = ast as Identifier;
+      return Filter._props({ [name]: true });
+    }
+
+    case 'literal': {
+      const { value } = ast as Literal;
+      // Handle special '*' value for empty input.
+      if (value === '*') {
+        return Filter.everything();
+      }
+
+      return Filter.eq(value);
+    }
+
+    default:
+      throw new Error(`Unsupported expression type: ${(ast as any).type}`);
+  }
+};

package/src/parser/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './filter-generator';
+export * from './query-parser';
+export * from './types';