@dxos/plugin-assistant 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/src/queue-logger.ts

@@ -1,125 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Queue, Ref, type Space, getSpace } from '@dxos/client/echo';
-import { type Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
-import { DXN, Key, Obj } from '@dxos/echo';
-import {
-  InvocationOutcome,
-  InvocationTraceEndEvent,
-  type InvocationTraceEvent,
-  InvocationTraceEventType,
-  InvocationTraceStartEvent,
-  TraceEvent,
-} from '@dxos/functions';
-import { invariant } from '@dxos/invariant';
-import { QueueSubspaceTags } from '@dxos/keys';
-
-export class QueueLogger implements SequenceLogger {
-  private _space: Space;
-  private _invocationTraceQueue: Queue<InvocationTraceEvent>;
-
-  constructor(private readonly sequence: Sequence) {
-    const space = getSpace(sequence);
-    invariant(space, 'Space not found');
-    this._space = space;
-    let dxn = this._space.properties.invocationTraceQueue?.dxn;
-    if (!dxn) {
-      dxn = DXN.fromQueue(QueueSubspaceTags.TRACE, this._space.id, Key.ObjectId.random());
-      this._space.properties.invocationTraceQueue = Ref.fromDXN(dxn);
-    }
-    this._invocationTraceQueue = this._space.queues.get(dxn);
-  }
-
-  log(event: SequenceEvent) {
-    switch (event.type) {
-      case 'begin':
-        void this._invocationTraceQueue.append([
-          Obj.make(InvocationTraceStartEvent, {
-            type: InvocationTraceEventType.START,
-            invocationId: event.invocationId,
-            timestamp: Date.now(),
-            input: {},
-            invocationTraceQueue: Ref.fromDXN(this._getTraceQueueDxn(event.invocationId)),
-            invocationTarget: Ref.make(this.sequence),
-          }),
-        ]);
-        break;
-      case 'end':
-        void this._invocationTraceQueue.append([
-          Obj.make(InvocationTraceEndEvent, {
-            type: InvocationTraceEventType.END,
-            invocationId: event.invocationId,
-            timestamp: Date.now(),
-            outcome: InvocationOutcome.SUCCESS,
-          }),
-        ]);
-        break;
-      case 'step-start':
-      case 'step-complete':
-        void this._getTraceEventQueue(event.invocationId).append([
-          Obj.make(TraceEvent, {
-            outcome: event.type,
-            truncated: false,
-            ingestionTimestamp: Date.now(),
-            logs: [
-              {
-                timestamp: Date.now(),
-                level: 'info',
-                message: event.type,
-                context: { step: event.step },
-              },
-            ],
-            exceptions: [],
-          }),
-        ]);
-        break;
-      case 'message':
-        void this._getTraceEventQueue(event.invocationId).append([
-          Obj.make(TraceEvent, {
-            outcome: event.type,
-            truncated: false,
-            ingestionTimestamp: Date.now(),
-            logs: [
-              {
-                timestamp: Date.now(),
-                level: 'info',
-                message: event.type,
-                context: { message: event.message },
-              },
-            ],
-            exceptions: [],
-          }),
-        ]);
-        break;
-      case 'block':
-        void this._getTraceEventQueue(event.invocationId).append([
-          Obj.make(TraceEvent, {
-            outcome: event.type,
-            truncated: false,
-            ingestionTimestamp: Date.now(),
-            logs: [
-              {
-                timestamp: Date.now(),
-                level: 'info',
-                message: event.type,
-                context: { block: event.block },
-              },
-            ],
-            exceptions: [],
-          }),
-        ]);
-        break;
-    }
-  }
-
-  private _getTraceQueueDxn(invocationId: string): DXN {
-    return DXN.fromQueue(QueueSubspaceTags.TRACE, this._space.id, invocationId);
-  }
-
-  private _getTraceEventQueue(invocationId: string): Queue<TraceEvent> {
-    const dxn = this._getTraceQueueDxn(invocationId);
-    return this._space.queues.get(dxn);
-  }
-}

package/src/toolkits/AssistantToolkit.ts

@@ -1,55 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
-import * as Effect from 'effect/Effect';
-import type * as Layer from 'effect/Layer';
-import * as Record from 'effect/Record';
-import * as Schema from 'effect/Schema';
-
-import { type PluginContext } from '@dxos/app-framework';
-import { AiContextService, ArtifactId } from '@dxos/assistant';
-import { Ref } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { trim } from '@dxos/util';
-
-const Toolkit$ = Toolkit.make(
-  Tool.make('add-to-context', {
-    description: trim`
-      Adds the object to the chat context.
-    `,
-    parameters: {
-      id: ArtifactId.annotations({
-        description: 'The ID of the document to read.',
-      }),
-    },
-    success: Schema.Void,
-    failure: Schema.Never,
-    dependencies: [AiContextService, DatabaseService],
-  }),
-);
-
-export namespace AssistantToolkit {
-  export const Toolkit = Toolkit$;
-
-  export const tools = Record.keys(Toolkit$.tools);
-
-  export const createLayer = (
-    _context: PluginContext,
-  ): Layer.Layer<Tool.Handler<any>, never, AiContextService | DatabaseService> =>
-    Toolkit$.toLayer({
-      'add-to-context': Effect.fnUntraced(function* ({ id }) {
-        const { binder } = yield* AiContextService;
-        const { db } = yield* DatabaseService;
-        const ref = Ref.fromDXN(ArtifactId.toDXN(id, db.spaceId));
-        yield* Effect.promise(() =>
-          binder.bind({
-            blueprints: [],
-            objects: [ref],
-          }),
-        );
-      }),
-    });
-}

package/src/toolkits/SystemToolkit.ts

@@ -1,292 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
-import * as Effect from 'effect/Effect';
-import type * as Layer from 'effect/Layer';
-import * as Record from 'effect/Record';
-import * as Schema from 'effect/Schema';
-
-import { Capabilities, type PluginContext, createIntent } from '@dxos/app-framework';
-import { ArtifactId } from '@dxos/assistant';
-import { DXN, Filter, Obj, Relation, SchemaNotFoundError, Tag, Type } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { invariant } from '@dxos/invariant';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { SpaceCapabilities, getActiveSpace } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { DataType } from '@dxos/schema';
-import { trim } from '@dxos/util';
-
-// TODO(burdon): Factor out (is there a way to remove plugin deps?)
-// TODO(burdon): Reconcile with functions (currently reuses plugin framework intents).
-
-const Toolkit$ = Toolkit.make(
-  //
-  // Schema
-  //
-
-  Tool.make('schema-list', {
-    description: trim`
-      Lists schemas definitions.
-    `,
-    parameters: {
-      // TODO(wittjosiah): Remove this once parameter-less tools are fixed.
-      limit: Schema.Number,
-    },
-    // TODO(dmaretskyi): Effect returns ({ result, encodedResult })
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  Tool.make('schema-add', {
-    description: trim`
-      Adds a schema to the space.
-      The name will be used when displayed to the user.
-      The typename must be in the format of "example.com/type/Type".
-    `,
-    parameters: {
-      name: Schema.String,
-      typename: Schema.String,
-      jsonSchema: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  //
-  // Objects
-  //
-
-  Tool.make('object-create', {
-    description: trim`
-      Creates a new object and adds it to the current space.
-      Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
-    `,
-    parameters: {
-      typename: Schema.String,
-      data: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  Tool.make('object-remove', {
-    description: trim`
-      Removes an object or relation from the database.
-    `,
-    parameters: {
-      id: ArtifactId.annotations({
-        description: 'The ID of the object.',
-      }),
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  //
-  // Relations
-  //
-
-  Tool.make('relation-create', {
-    description: trim`
-      Creates a new relation and adds it to the current space.
-      Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
-    `,
-    parameters: {
-      typename: Schema.String,
-      source: ArtifactId.annotations({
-        description: 'The ID of the source object.',
-      }),
-      target: ArtifactId.annotations({
-        description: 'The ID of the target object.',
-      }),
-      data: Schema.Any.annotations({
-        description: 'The data to be stored in the relation.',
-      }),
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  //
-  // Tags
-  //
-
-  Tool.make('tag-add', {
-    description: trim`
-      Adds a tag to an object.
-      Tags are objects of type ${Tag.Tag.typename}.
-    `,
-    parameters: {
-      tagId: ArtifactId.annotations({
-        description: 'The ID of the tag.',
-      }),
-      objectId: ArtifactId.annotations({
-        description: 'The ID of the object.',
-      }),
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  Tool.make('tag-remove', {
-    description: trim`
-      Removes a tag from an object.
-      Tags are objects of type ${Tag.Tag.typename}.
-    `,
-    parameters: {
-      tagId: ArtifactId.annotations({
-        description: 'The ID of the tag.',
-      }),
-      objectId: ArtifactId.annotations({
-        description: 'The ID of the object.',
-      }),
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-);
-
-export namespace SystemToolkit {
-  export const Toolkit = Toolkit$;
-
-  export const tools = Record.keys(Toolkit$.tools);
-
-  export const createLayer = (context: PluginContext): Layer.Layer<Tool.Handler<any>, never, never> =>
-    Toolkit$.toLayer({
-      'schema-list': () => {
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const registered = context
-            // TODO(burdon): Can we remove plugin dependency? Get from layer?
-            .getCapabilities(ClientCapabilities.Schema)
-            .flat()
-            .map((schema) => {
-              const meta = Type.getMeta(schema);
-              return {
-                typename: Type.getTypename(schema),
-                jsonSchema: Type.toJsonSchema(schema),
-                kind: meta?.sourceSchema ? 'relation' : 'record',
-              };
-            });
-
-          // TODO(burdon): Can we remove plugin dependency? Get from layer?
-          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
-            typename: Type.getTypename(form.objectSchema),
-            jsonSchema: Type.toJsonSchema(form.objectSchema),
-            kind: 'item',
-          }));
-
-          const schemas = [...registered, ...forms];
-          if (space) {
-            const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-            schemas.push(
-              ...objects.map((object) => ({
-                typename: object.typename,
-                jsonSchema: object.jsonSchema,
-                kind: 'record',
-              })),
-            );
-          }
-
-          return schemas;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)));
-      },
-
-      'schema-add': ({ name, typename, jsonSchema }) => {
-        return Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const space = getActiveSpace(context);
-          invariant(space, 'No active space');
-
-          const schema = Type.toEffectSchema(jsonSchema).pipe(Type.Obj({ typename, version: '0.1.0' }));
-          yield* dispatch(createIntent(SpaceAction.AddSchema, { space, name, typename, schema }));
-        }).pipe(Effect.orDie);
-      },
-
-      'object-create': ({ typename, data }) => {
-        const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const schemas = context.getCapabilities(ClientCapabilities.Schema).flat();
-          const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-          schemas.push(...objects.map((object) => Type.toEffectSchema(object.jsonSchema)));
-          const schema = schemas.find((schema) => Type.getTypename(schema) === typename);
-          if (!schema) {
-            throw new SchemaNotFoundError(typename);
-          }
-
-          const object = Obj.make(schema, data);
-          yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-          return object;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
-      },
-
-      'object-remove': ({ id }) => {
-        const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const object = yield* DatabaseService.resolve(DXN.parse(id));
-          yield* dispatch(createIntent(SpaceAction.RemoveObjects, { objects: [object] }));
-          return object;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
-      },
-
-      'relation-create': ({ typename, source, target, data }) => {
-        const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const schemas = context.getCapabilities(ClientCapabilities.Schema).flat();
-          const schema = schemas.find((schema) => Type.getTypename(schema) === typename);
-          if (!schema) {
-            throw new SchemaNotFoundError(typename);
-          }
-
-          const sourceObj = yield* DatabaseService.resolve(DXN.parse(source));
-          const targetObj = yield* DatabaseService.resolve(DXN.parse(target));
-          const relation = Relation.make(schema, {
-            [Relation.Source]: sourceObj,
-            [Relation.Target]: targetObj,
-            ...data,
-          });
-          yield* dispatch(createIntent(SpaceAction.AddObject, { object: relation, target: space, hidden: true }));
-          return relation;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
-      },
-
-      'tag-add': ({ tagId, objectId }) => {
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const object = yield* DatabaseService.resolve(DXN.parse(objectId));
-          const meta = Obj.getMeta(object);
-          meta.tags = [DXN.parse(tagId).toString()];
-          return object;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
-      },
-
-      'tag-remove': ({ tagId, objectId }) => {
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const object = yield* DatabaseService.resolve(DXN.parse(objectId));
-          const meta = Obj.getMeta(object);
-          meta.tags = meta.tags?.filter((tag) => tag !== DXN.parse(tagId).toString());
-          return object;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
-      },
-    });
-}

package/src/toolkits/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './AssistantToolkit';
-export * from './SystemToolkit';

package/src/types/AssistantAction.ts

@@ -1,70 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { Blueprint } from '@dxos/blueprints';
-import { EchoObjectSchema, SpaceSchema } from '@dxos/client/echo';
-import { Sequence } from '@dxos/conductor';
-import { DataType } from '@dxos/schema';
-
-import { meta } from '../meta';
-
-import { Chat } from './Assistant';
-
-// TODO(burdon): Name?
-export class onCreateSpace extends Schema.TaggedClass<onCreateSpace>()(`${meta.id}/on-space-created`, {
-  input: Schema.Struct({
-    space: SpaceSchema,
-    rootCollection: DataType.Collection,
-  }),
-  output: Schema.Void,
-}) {}
-
-export class CreateChat extends Schema.TaggedClass<CreateChat>()(`${meta.id}/action/create-chat`, {
-  input: Schema.Struct({
-    space: SpaceSchema,
-    name: Schema.optional(Schema.String),
-  }),
-  output: Schema.Struct({
-    object: Chat,
-  }),
-}) {}
-
-export class UpdateChatName extends Schema.TaggedClass<UpdateChatName>()(`${meta.id}/action/update-name`, {
-  input: Schema.Struct({
-    chat: Chat,
-  }),
-  output: Schema.Void,
-}) {}
-
-export const BlueprintForm = Schema.Struct({
-  key: Schema.String,
-  name: Schema.String,
-  description: Schema.optional(Schema.String),
-});
-
-export class CreateBlueprint extends Schema.TaggedClass<CreateBlueprint>()(`${meta.id}/action/create-blueprint`, {
-  input: BlueprintForm,
-  output: Schema.Struct({
-    object: Blueprint.Blueprint,
-  }),
-}) {}
-
-export class CreateSequence extends Schema.TaggedClass<CreateSequence>()(`${meta.id}/action/create-sequence`, {
-  input: Schema.Struct({
-    name: Schema.optional(Schema.String),
-  }),
-  output: Schema.Struct({
-    object: Sequence,
-  }),
-}) {}
-
-export class SetCurrentChat extends Schema.TaggedClass<SetCurrentChat>()(`${meta.id}/action/set-current-chat`, {
-  input: Schema.Struct({
-    companionTo: EchoObjectSchema,
-    chat: Chat,
-  }),
-  output: Schema.Void,
-}) {}

package/src/types/defs.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export const LLM_PROVIDERS = ['edge', 'ollama', 'lmstudio'] as const;