@dxos/plugin-assistant 0.8.4-main.f5c0578 → 0.8.4-main.fcfe5033a5

package/src/hooks/chat-processor.ts

@@ -1,260 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Registry, Result, Rx } from '@effect-rx/rx-react';
-import { Effect, type Layer, Option, Stream, pipe } from 'effect';
-
-import { AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry } from '@dxos/ai';
-import { type PromiseIntentDispatcher } from '@dxos/app-framework';
-import {
-  type AiConversation,
-  type AiConversationRunParams,
-  AiSession,
-  ArtifactDiffResolver,
-  createSystemPrompt,
-} from '@dxos/assistant';
-import { type Blueprint } from '@dxos/blueprints';
-import { Context } from '@dxos/context';
-import { Obj } from '@dxos/echo';
-import { runAndForwardErrors } from '@dxos/effect';
-import { log } from '@dxos/log';
-import { Filter, type Space, getVersion } from '@dxos/react-client/echo';
-import { type ContentBlock, DataType } from '@dxos/schema';
-
-import { AiServiceOverloadedError } from './errors';
-import { type AiChatServices } from './useChatServices';
-
-// TODO(burdon): Is this still used?
-declare global {
-  interface ToolContextExtensions {
-    space?: Space;
-    dispatch?: PromiseIntentDispatcher;
-  }
-}
-
-export type AiRequestOptions = {
-  // Empty for now.
-};
-
-export type AiChatProcessorOptions = {
-  model?: ModelName;
-  modelRegistry?: ModelRegistry;
-  blueprintRegistry?: Blueprint.Registry;
-  observableRegistry?: Registry.Registry;
-  extensions?: ToolContextExtensions;
-} & Pick<AiConversationRunParams<any>, 'system'>;
-
-const defaultOptions: Partial<AiChatProcessorOptions> = {
-  model: DEFAULT_EDGE_MODEL,
-};
-
-/**
- * Handles interactions with the AI service.
- * Maintains a queue of messages and handles streaming responses from the AI service.
- * Executes tools based on AI responses.
- * Supports cancellation of in-progress requests.
- */
-export class AiChatProcessor {
-  /**
-   * Last error.
-   */
-  // TODO(wittjosiah): Error should come from the message stream.
-  readonly error = Rx.make<Option.Option<Error>>(Option.none());
-
-  /** Rx registry. */
-  private readonly _observableRegistry: Registry.Registry;
-
-  /** Current session. */
-  private readonly _session = Rx.make<Option.Option<AiSession>>(Option.none());
-
-  /**
-   * Current streaming message (from the AI service).
-   */
-  private readonly _streaming: Rx.Rx<Result.Result<Option.Option<DataType.Message>, Error>> = Rx.make((get) => {
-    return pipe(
-      get(this._session),
-      Option.map((session) => Stream.fromQueue(session.blockQueue)),
-      Option.getOrElse(() => Stream.make()),
-      Stream.scan<Option.Option<DataType.Message>, Option.Option<ContentBlock.Any>>(Option.none(), (acc, blockOption) =>
-        Option.flatMap(blockOption, (block) =>
-          acc.pipe(
-            Option.match({
-              onNone: () => [block],
-              onSome: (message) => [...message.blocks.filter((b) => !b.pending), block],
-            }),
-            Option.some,
-            Option.map((blocks) =>
-              Obj.make(DataType.Message, {
-                created: new Date().toISOString(),
-                sender: { role: 'assistant' },
-                blocks,
-              }),
-            ),
-          ),
-        ),
-      ),
-    );
-  });
-
-  /**
-   * Streaming state.
-   */
-  readonly streaming: Rx.Rx<boolean> = Rx.make((get) => {
-    return pipe(
-      get(this._streaming),
-      Result.map((streaming) => Option.isSome(streaming)),
-      Result.getOrElse(() => false),
-    );
-  });
-
-  /**
-   * Pending messages (incl. the current user request).
-   */
-  private readonly _pending: Rx.Rx<Result.Result<DataType.Message[], Error>> = Rx.make((get) => {
-    // TODO(wittjosiah): For some reason using Option.map here loses reactivity.
-    const session = get(this._session);
-    return Option.isSome(session)
-      ? pipe(
-          session.value.messageQueue,
-          Stream.fromQueue,
-          Stream.scan<DataType.Message[], DataType.Message>([], (acc, message) => [...acc, message]),
-        )
-      : Stream.make();
-  });
-
-  /**
-   * Array of Messages (incl. the current message being streamed).
-   */
-  readonly messages: Rx.Rx<Result.Result<DataType.Message[], Error>> = Rx.make((get) => {
-    const streaming = get(this._streaming);
-    return Result.map(get(this._pending), (pending) =>
-      Result.match(streaming, {
-        onInitial: () => pending,
-        onSuccess: (streaming) =>
-          Option.match(streaming.value, {
-            onNone: () => pending,
-            onSome: (message) => [...pending, message],
-          }),
-        onFailure: () => pending,
-      }),
-    );
-  });
-
-  constructor(
-    // TODO(dmaretskyi): Replace this with effect's ManagedRuntime wrapping this layer.
-    private readonly _services: Layer.Layer<AiChatServices>,
-    private readonly _conversation: AiConversation,
-    private readonly _options: AiChatProcessorOptions = defaultOptions,
-  ) {
-    // Initialize registries and defaults before using in other logic.
-    this._observableRegistry = this._options.observableRegistry ?? Registry.make();
-    if (this._options.model && !this._options.system) {
-      const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
-      this._options.system = createSystemPrompt(capabilities);
-    }
-  }
-
-  get context() {
-    return this._conversation.context;
-  }
-
-  get conversation() {
-    return this._conversation;
-  }
-
-  get blueprintRegistry() {
-    return this._options.blueprintRegistry;
-  }
-
-  /**
-   * Make GPT request.
-   */
-  async request(message: string, _options: AiRequestOptions = {}): Promise<void> {
-    await using ctx = Context.default(); // Auto-disposed at the end of this block.
-
-    const session = new AiSession();
-    this._observableRegistry.set(this._session, Option.some(session));
-
-    ctx.onDispose(() => {
-      log.info('onDispose', { session, isDisposed: ctx.disposed });
-      Option.match(this._observableRegistry.get(this._session), {
-        onSome: (s) => {
-          if (s === session) {
-            this._observableRegistry.set(this._session, Option.none());
-          }
-        },
-        onNone: () => {},
-      });
-    });
-
-    try {
-      const messages = await runAndForwardErrors(
-        this._conversation
-          .run({
-            session,
-            prompt: message,
-            system: this._options.system,
-          })
-          .pipe(
-            Effect.provide(AiService.model(this._options.model ?? DEFAULT_EDGE_MODEL)),
-            // TODO(dmaretskyi): Move ArtifactDiffResolver upstream.
-            Effect.provideService(ArtifactDiffResolver, this._artifactDiffResolver),
-            Effect.provide(this._services),
-            Effect.tapErrorCause((cause) => {
-              log.error('error', { cause });
-              return Effect.void;
-            }),
-          ),
-      );
-
-      log('completed', { messages });
-    } catch (err) {
-      log.catch(err);
-      if (err instanceof Error && err.message.includes('Overloaded')) {
-        this._observableRegistry.set(
-          this.error,
-          Option.some(new AiServiceOverloadedError('AI service overloaded', { cause: err })),
-        );
-      } else {
-        this._observableRegistry.set(this.error, Option.some(new Error('AI service error', { cause: err })));
-      }
-    }
-  }
-
-  /**
-   * Cancel pending requests.
-   */
-  async cancel(): Promise<void> {
-    log.info('cancelling...');
-
-    // TODO(dmaretskyi): Abort using Fiber.interrupt.
-  }
-
-  private _artifactDiffResolver: ArtifactDiffResolver.Service = {
-    resolve: async (artifacts) => {
-      const space = this._options.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;
-    },
-  };
-}

package/src/hooks/errors.ts

@@ -1,8 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// TODO(wittjosiah): Move to ai-service-client.
-export class AiServiceOverloadedError extends Error {
-  code = 'AI_SERVICE_OVERLOADED';
-}

package/src/hooks/useExecutionGraph.ts

@@ -1,16 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Queue } from '@dxos/client/echo';
-import { Obj, type Ref } from '@dxos/echo';
-import { useQueue } from '@dxos/react-client/echo';
-
-import { ExecutionGraph } from '../execution-graph/execution-graph';
-
-export const useExecutionGraph = (traceQueueRef?: Ref.Ref<Queue>) => {
-  const traceQueue = useQueue(traceQueueRef?.dxn);
-  const graph = new ExecutionGraph();
-  graph.addEvents(traceQueue?.objects.filter(Obj.isObject) ?? []);
-  return graph.getGraph();
-};

package/src/hooks/useResolveRef.ts

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useMemo, useSyncExternalStore } from 'react';
-
-import { type Space } from '@dxos/client/echo';
-import { type Ref } from '@dxos/echo';
-
-// TODO(burdon): Factor out.
-export const useResolvedRef = <T>(space: Space, ref: Ref.Ref<T>): T | undefined => {
-  const { subscribe, getSnapshot } = useMemo(() => {
-    const resolver = space.db.graph.createRefResolver({});
-    let currentCallback: (() => void) | undefined = undefined;
-
-    return {
-      subscribe: (cb: () => void) => {
-        currentCallback = cb;
-        return () => {
-          if (currentCallback === cb) {
-            currentCallback = undefined;
-          }
-        };
-      },
-      getSnapshot: () =>
-        resolver?.resolveSync(ref.dxn, true, () => {
-          currentCallback?.();
-        }) as T | undefined,
-    };
-  }, [space, ref.dxn.toString()]);
-
-  return useSyncExternalStore<T | undefined>(subscribe, getSnapshot);
-};

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,74 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Filter } from '@dxos/echo';
-
-import { type Expression, type Identifier, type Literal, type RelationalOperator } 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;
-
-      // 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];
-      if (filterFn) {
-        return filterFn((right as Literal).value);
-      }
-
-      throw new Error(`Unsupported operator: ${operator}`);
-    }
-
-    case 'unary': {
-      const { operator, argument } = ast;
-      if (operator === 'NOT') {
-        return Filter.not(createFilter(argument));
-      }
-      throw new Error(`Unsupported unary operator: ${operator}`);
-    }
-
-    case 'identifier': {
-      const { name } = ast;
-      return Filter._props({ [name]: true });
-    }
-
-    case 'literal': {
-      const { value } = ast;
-      // 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 type * 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);
-    }
-  });
-});