@dxos/plugin-assistant 0.8.2-main.f11618f → 0.8.2-staging.42af850

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 { getVersion, 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;
   }
 
@@ -120,6 +129,33 @@ 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,
@@ -130,28 +166,7 @@ export class ChatProcessor {
         prompt: message,
         systemPrompt: this._options.systemPrompt,
         extensions: this._extensions,
-        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({ id: artifact.id }).run();
-              if (!object) {
-                return;
-              }
-              versions.set(artifact.id, {
-                version: getVersion(object),
-                diff: `Current state: ${JSON.stringify(object)}`,
-              });
-            }),
-          );
-          return versions;
-        },
+        artifactDiffResolver: this._artifactDiffResolver,
         generationOptions: {
           model: this._options.model,
         },
@@ -192,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 = {
@@ -43,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 () => {
@@ -55,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 };

package/src/hooks/useContextProvider.ts

@@ -2,13 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
+import type { Schema } from 'effect';
 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 } from '@dxos/echo';
+import { type BaseEchoObject, getDXN, 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 +30,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 Schema.Schema<BaseEchoObject>))))
           .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) => !!getDXN(object))
+            .map((object) => ({
+              uri: getDXN(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';

package/src/parser/query-parser.test.ts

@@ -0,0 +1,139 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { QueryParser } from './query-parser';
+
+describe('QueryParser', () => {
+  test('empty', ({ expect }) => {
+    const parser = new QueryParser('');
+    expect(parser.parse()).toEqual({
+      type: 'literal',
+      value: '*',
+    });
+  });
+
+  test('invalid queries', ({ expect }) => {
+    const cases = [
+      //
+      '!',
+      'X:',
+      ':Y',
+      'X;Y',
+      'x==100',
+    ];
+
+    for (const query of cases) {
+      const parser = new QueryParser(query);
+      expect(() => parser.parse()).toThrow();
+    }
+  });
+
+  test('valid queries', ({ expect }) => {
+    const cases = [
+      //
+      '',
+      'type:Person',
+      '$title = "foo"',
+      '(type:Person OR type:Organization) AND $title = "DXOS" AND $ts < TODAY',
+    ];
+
+    for (const query of cases) {
+      const parser = new QueryParser(query);
+      expect(parser.parse()).to.exist;
+    }
+  });
+
+  test('simple queries', ({ expect }) => {
+    const cases = [
+      {
+        query: 'type:Person',
+        ast: {
+          type: 'binary',
+          operator: 'EQ',
+          left: { type: 'identifier', name: 'type' },
+          right: { type: 'literal', value: 'Person' },
+        },
+      },
+      {
+        query: '$title = "DXOS"',
+        ast: {
+          type: 'binary',
+          operator: 'EQ',
+          left: { type: 'identifier', name: '$title' },
+          right: { type: 'literal', value: 'DXOS' },
+        },
+      },
+      {
+        query: '(type:Person OR type:Organization) AND $title = "DXOS" AND $ts < TODAY',
+        ast: {
+          left: {
+            left: {
+              left: {
+                left: {
+                  name: 'type',
+                  type: 'identifier',
+                },
+                operator: 'EQ',
+                right: {
+                  type: 'literal',
+                  value: 'Person',
+                },
+                type: 'binary',
+              },
+              operator: 'OR',
+              right: {
+                left: {
+                  name: 'type',
+                  type: 'identifier',
+                },
+                operator: 'EQ',
+                right: {
+                  type: 'literal',
+                  value: 'Organization',
+                },
+                type: 'binary',
+              },
+              type: 'binary',
+            },
+            operator: 'AND',
+            right: {
+              left: {
+                name: '$title',
+                type: 'identifier',
+              },
+              operator: 'EQ',
+              right: {
+                type: 'literal',
+                value: 'DXOS',
+              },
+              type: 'binary',
+            },
+            type: 'binary',
+          },
+          operator: 'AND',
+          right: {
+            left: {
+              name: '$ts',
+              type: 'identifier',
+            },
+            operator: 'LT',
+            right: {
+              type: 'literal',
+              value: 'TODAY',
+            },
+            type: 'binary',
+          },
+          type: 'binary',
+        },
+      },
+    ];
+
+    for (const { query, ast } of cases) {
+      const parser = new QueryParser(query);
+      expect(parser.parse()).toEqual(ast);
+    }
+  });
+});