@dxos/plugin-assistant 0.8.3 → 0.8.4-main.1c7ec43d41

package/src/hooks/useChatProcessor.tsx

@@ -1,97 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-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 } 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';
-import { isNonNullable } from '@dxos/util';
-
-import { AssistantCapabilities } from '../capabilities';
-import { ChatProcessor, type ChatProcessorOptions } from '../hooks';
-import { convertFunctionToTool, createToolsFromService } from '../tools';
-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 = ({
-  chat,
-  space,
-  settings,
-  // part = 'deck',
-  part,
-  associatedArtifact,
-}: UseChatProcessorProps): ChatProcessor => {
-  const aiClient = useCapability(AssistantCapabilities.AiClient);
-  const globalTools = useCapabilities(Capabilities.Tools);
-  const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-
-  // Services.
-  const services = useQuery(space, Filter.type(ServiceType));
-  const [serviceTools, setServiceTools] = useState<ExecutableTool[]>([]);
-  useEffect(() => {
-    log('creating service tools...');
-    queueMicrotask(async () => {
-      const tools = await Promise.all(services.map((service) => createToolsFromService(service)));
-      setServiceTools(tools.flat());
-    });
-  }, [services]);
-
-  // Tools and context.
-  const config = useConfig();
-  const functions = useQuery(space, Filter.type(FunctionType));
-  const chatId = useMemo(() => (chat ? fullyQualifiedId(chat) : undefined), [chat]);
-  const [tools, extensions] = useMemo(() => {
-    log('creating tools...');
-    const tools: ExecutableTool[] = [
-      ...globalTools.flat(),
-      ...serviceTools,
-      ...functions
-        .map((fn) => convertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
-        .filter(isNonNullable),
-    ];
-    const extensions = { space, dispatch, pivotId: chatId, part };
-    return [tools, extensions];
-  }, [dispatch, globalTools, space, chatId, serviceTools, functions]);
-
-  // Prompt.
-  const systemPrompt = useMemo(
-    () =>
-      createSystemPrompt({
-        artifacts: artifactDefinitions.map((definition) => `${definition.name}\n${definition.instructions}`),
-        associatedArtifact,
-      }),
-    [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.
-  const processor = useMemo(() => {
-    log('creating processor...', { settings });
-    return new ChatProcessor(aiClient.value, tools, artifactDefinitions, extensions, { model, systemPrompt });
-  }, [aiClient.value, tools, artifactDefinitions, extensions, model, systemPrompt]);
-
-  return processor;
-};

package/src/hooks/useContextProvider.ts

@@ -1,55 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useMemo } from 'react';
-
-import { Capabilities, useCapabilities } from '@dxos/app-framework';
-import { type Space } from '@dxos/client/echo';
-import { Filter, Obj, type Type } from '@dxos/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.type(schema as Type.Schema))))
-          .run();
-
-        return (
-          objects
-            // TODO(burdon): Remove cast ??? (+ two instances below).
-            // .map((object) => {
-            //   log.info('object', { object, label: Obj.getLabel(object as any) });
-            //   return object;
-            // })
-            .filter((object) => stringMatch(query, Obj.getLabel(object as any) ?? ''))
-            // TODO(dmaretskyi): `Type.getDXN` (at the point of writing) didn't work here as it was schema-only.
-            .filter((object) => !!Obj.getDXN(object as Obj.Any))
-            .map((object) => ({
-              uri: Obj.getDXN(object as any)!.toString(),
-              label: Obj.getLabel(object as any) ?? '',
-            }))
-        );
-      },
-      resolveMetadata: async ({ uri }) => {
-        const object = await space.db.query(Filter.ids(uri)).first();
-        return { uri, label: Obj.getLabel(object) ?? '' };
-      },
-    };
-  }, [space, artifactDefinitions]);
-};

package/src/hooks/useMessageQueue.ts

@@ -1,22 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useMemo } from 'react';
-
-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';
-
-export const useMessageQueue = (chat?: AIChatType) => {
-  const space = getSpace(chat);
-  const queueDxn = useMemo(() => {
-    // TODO(dmaretskyi): Chat.queue.dxn should be a valid DXN already.
-    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/hooks/useServices.ts

@@ -1,28 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useEffect, useMemo, useState } from 'react';
-
-import { type Space } from '@dxos/client/echo';
-
-import { MockServiceRegistry } from '../testing';
-import { type ServiceType, type ServiceQuery } from '../types';
-
-/**
- * Retrieves matching services from the registry.
- */
-export const useServices = (space: Space, query?: ServiceQuery): ServiceType[] => {
-  const registry = useMemo(() => new MockServiceRegistry(), []);
-  const [services, setServices] = useState<ServiceType[]>([]);
-  useEffect(() => {
-    const t = setTimeout(async () => {
-      const services = await registry.queryServices(query);
-      setServices(services);
-    });
-
-    return () => clearTimeout(t);
-  }, [query, registry]);
-
-  return services;
-};

package/src/hooks/useTextInputEvents.ts

@@ -1,49 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useState, useCallback, type KeyboardEventHandler, type ChangeEventHandler } from 'react';
-
-/**
- * Hook that handles text input events.
- */
-// TODO(burdon): Factor out.
-export const useTextInputEvents = ({
-  onEnter,
-  onEscape,
-}: {
-  onEnter?: (text: string) => boolean | void;
-  onEscape?: () => void;
-}) => {
-  const [value, setValue] = useState('');
-
-  const onKeyDown = useCallback<KeyboardEventHandler<HTMLInputElement>>(
-    (ev) => {
-      switch (ev.key) {
-        case 'Escape': {
-          onEscape?.();
-          setValue('');
-          break;
-        }
-
-        case 'Enter': {
-          const value = (ev.target as HTMLInputElement).value.trim();
-          if (value.length > 0) {
-            const reset = onEnter?.(value);
-            if (reset) {
-              setValue('');
-            }
-          }
-          break;
-        }
-      }
-    },
-    [onEnter, onEscape],
-  );
-
-  const onChange = useCallback<ChangeEventHandler<HTMLInputElement>>((ev) => {
-    setValue(ev.target.value);
-  }, []);
-
-  return [{ value, onKeyDown, onChange }, setValue];
-};

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

@@ -1,32 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, test } from 'vitest';
-
-import { Filter } from '@dxos/echo';
-
-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

@@ -1,81 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Filter } from '@dxos/echo';
-
-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

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

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

@@ -1,139 +0,0 @@
-//
-// 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);
-    }
-  });
-});