@dxos/plugin-thread 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/dist/types/src/types/Thread.d.ts

@@ -1,167 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { Obj, Type } from '@dxos/echo';
-export declare const ThreadStatus: Schema.Union<[Schema.Literal<["staged"]>, Schema.Literal<["active"]>, Schema.Literal<["resolved"]>]>;
-declare const _Thread: Type.obj<Schema.Struct<{
-    name: Schema.optional<typeof Schema.String>;
-    status: Schema.optional<Schema.Union<[Schema.Literal<["staged"]>, Schema.Literal<["active"]>, Schema.Literal<["resolved"]>]>>;
-    messages: Schema.mutable<Schema.Array$<Type.ref<Type.obj<Schema.Struct<{
-        id: import("@dxos/keys").ObjectIdClass;
-        parentMessage: Schema.optional<import("@dxos/keys").ObjectIdClass>;
-        created: Schema.SchemaClass<string, string, never>;
-        sender: Schema.mutable<Schema.Struct<{
-            contact: Schema.optional<Type.ref<Type.obj<Schema.extend<Schema.Struct<{
-                fullName: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                preferredName: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                nickname: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                image: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                organization: Schema.optional<Schema.Schema<import("@dxos/echo/internal").Ref<Type.OfKind<import("@dxos/echo/internal").EntityKind.Object> & {
-                    id: string;
-                    description?: string | undefined;
-                    name?: string | undefined;
-                    status?: "prospect" | "qualified" | "active" | "commit" | "reject" | undefined;
-                    image?: string | undefined;
-                    website?: string | undefined;
-                    location?: readonly [number, number, (number | undefined)?] | undefined;
-                }>, import("@dxos/echo-protocol").EncodedReference, never>>;
-                jobTitle: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                department: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                notes: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                emails: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: Schema.refine<string, typeof Schema.String>;
-                }>>>>;
-                identities: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: typeof Schema.String;
-                }>>>>;
-                phoneNumbers: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: typeof Schema.String;
-                }>>>>;
-                addresses: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: Schema.Struct<{
-                        street: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        extended: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        locality: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        region: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        postalCode: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        postOfficeBoxNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                        country: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                    }>;
-                }>>>>;
-                urls: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    label: Schema.optional<typeof Schema.String>;
-                    value: Schema.refine<string, typeof Schema.String>;
-                }>>>>;
-                birthday: Schema.optional<Schema.SchemaClass<string, string, never>>;
-                fields: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
-                    category: Schema.optional<typeof Schema.String>;
-                    label: typeof Schema.String;
-                    value: typeof Schema.String;
-                }>>>>;
-            }>, Schema.Struct<{
-                location: Schema.optional<Schema.Tuple<[Schema.filter<Schema.transform<Schema.SchemaClass<number, number, never>, Schema.filter<Schema.SchemaClass<number, number, never>>>>, Schema.filter<Schema.transform<Schema.SchemaClass<number, number, never>, Schema.filter<Schema.SchemaClass<number, number, never>>>>, Schema.Element<typeof Schema.Number, "?">]>>;
-            }>>>>>;
-            identityDid: Schema.optional<typeof Schema.String>;
-            identityKey: Schema.optional<typeof Schema.String>;
-            email: Schema.optional<typeof Schema.String>;
-            name: Schema.optional<typeof Schema.String>;
-            role: Schema.optional<Schema.Literal<["user", "assistant", "tool"]>>;
-        }>>;
-        blocks: Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.TaggedStruct<"anchor", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            objectId: import("@dxos/keys").ObjectIdClass;
-            version: typeof Schema.Unknown;
-        }>>, Schema.mutable<Schema.TaggedStruct<"file", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            url: typeof Schema.String;
-            name: Schema.optional<typeof Schema.String>;
-            mediaType: Schema.optional<typeof Schema.String>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"image", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            id: Schema.optional<typeof Schema.String>;
-            source: Schema.optional<Schema.Union<[Schema.mutable<Schema.Struct<{
-                type: Schema.Literal<["base64"]>;
-                mediaType: typeof Schema.String;
-                data: typeof Schema.String;
-            }>>, Schema.mutable<Schema.Struct<{
-                type: Schema.Literal<["http"]>;
-                url: typeof Schema.String;
-            }>>]>>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"json", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            disposition: Schema.optional<typeof Schema.String>;
-            data: typeof Schema.String;
-        }>>, Schema.mutable<Schema.TaggedStruct<"proposal", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            text: typeof Schema.String;
-        }>>, Schema.mutable<Schema.TaggedStruct<"reasoning", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            reasoningText: Schema.optional<typeof Schema.String>;
-            redactedText: Schema.optional<typeof Schema.String>;
-            signature: Schema.optional<typeof Schema.String>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"reference", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            reference: Type.ref<Schema.Schema<Type.Expando, {
-                [x: string]: any;
-                id: string;
-            }, never>>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"select", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            options: Schema.Array$<typeof Schema.String>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"status", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            statusText: typeof Schema.String;
-        }>>, Schema.mutable<Schema.TaggedStruct<"suggestion", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            text: typeof Schema.String;
-        }>>, Schema.mutable<Schema.TaggedStruct<"summary", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            mimeType: Schema.optional<typeof Schema.String>;
-            message: Schema.optional<typeof Schema.String>;
-            model: Schema.optional<typeof Schema.String>;
-            usage: Schema.optional<Schema.Struct<{
-                inputTokens: Schema.optional<typeof Schema.Number>;
-                outputTokens: Schema.optional<typeof Schema.Number>;
-                totalTokens: Schema.optional<typeof Schema.Number>;
-            }>>;
-            toolCalls: Schema.optional<typeof Schema.Number>;
-            errors: Schema.optional<typeof Schema.Number>;
-            duration: Schema.optional<typeof Schema.Number>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"text", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            mimeType: Schema.optional<typeof Schema.String>;
-            text: typeof Schema.String;
-            disposition: Schema.optional<typeof Schema.String>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"toolkit", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-        }>>, Schema.mutable<Schema.TaggedStruct<"toolCall", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            toolCallId: typeof Schema.String;
-            name: typeof Schema.String;
-            input: typeof Schema.String;
-            providerExecuted: typeof Schema.Boolean;
-        }>>, Schema.mutable<Schema.TaggedStruct<"toolResult", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            toolCallId: typeof Schema.String;
-            name: typeof Schema.String;
-            result: Schema.optional<typeof Schema.String>;
-            error: Schema.optional<typeof Schema.String>;
-            providerExecuted: typeof Schema.Boolean;
-        }>>, Schema.mutable<Schema.TaggedStruct<"transcript", {
-            pending: Schema.optional<typeof Schema.Boolean>;
-            started: typeof Schema.String;
-            text: typeof Schema.String;
-        }>>]>>>;
-        properties: Schema.optional<Schema.mutable<Schema.Record$<typeof Schema.String, typeof Schema.Any>>>;
-    }>>>>>;
-}>>;
-export interface Thread extends Schema.Schema.Type<typeof _Thread> {
-}
-export interface ThreadEncoded extends Schema.Schema.Encoded<typeof _Thread> {
-}
-export declare const Thread: Schema.Schema<Thread, ThreadEncoded>;
-export declare const make: ({ status, messages, ...props }?: Partial<Obj.MakeProps<typeof Thread>>) => import("@dxos/live-object").Live<Thread>;
-export {};
-//# sourceMappingURL=Thread.d.ts.map

package/dist/types/src/types/Thread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Thread.d.ts","sourceRoot":"","sources":["../../../../src/types/Thread.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGvC,eAAO,MAAM,YAAY,sGAIxB,CAAC;AAEF,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;+BAWo3e,CAAC;wBAA0C,CAAC;0BAA4C,CAAC;yBAA8F,CAAC;2BAA6C,CAAC;4BAA8C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAP7kf,CAAC;AAC1E,MAAM,WAAW,MAAO,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC;CAAG;AACrE,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,OAAO,CAAC;CAAG;AAC/E,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAW,CAAC;AAEpE,eAAO,MAAM,IAAI,GAAI,iCAAgD,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,OAAO,MAAM,CAAC,CAAM,6CAC7D,CAAC"}

package/src/capabilities/capabilities.ts

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineCapability } from '@dxos/app-framework';
-import { type DeepReadonly } from '@dxos/util';
-
-import { type CallManager, type CallState, type MediaState } from '../calls';
-import { meta } from '../meta';
-import { type Channel, type ThreadState, type ViewState } from '../types';
-
-export namespace ThreadCapabilities {
-  export const CallManager = defineCapability<CallManager>(`${meta.id}/capability/call-manager`);
-
-  // TODO(burdon): Better way to define specific extensions for meeting companions.
-  // TODO(burdon): This brings in deps from ../calls; how should we manage/minimize explicit type exposure to other plugins?
-  // TODO(wittjosiah): These callbacks could be intents once we support broadcast.
-  export type CallProperties = {
-    onJoin: (state: { channel?: Channel.Channel; roomId?: string }) => Promise<void>;
-    onLeave: (roomId?: string) => Promise<void>;
-    onCallStateUpdated: (callState: CallState) => Promise<void>;
-    onMediaStateUpdated: ([mediaState, isSpeaking]: [MediaState, boolean]) => Promise<void>;
-  };
-  export const CallExtension = defineCapability<CallProperties>(`${meta.id}/capability/call-extension`);
-
-  type GetViewState = (subjectId: string) => ViewState;
-  export const State = defineCapability<{ state: DeepReadonly<ThreadState>; getViewState: GetViewState }>(
-    `${meta.id}/capability/state`,
-  );
-  export const MutableState = defineCapability<{ state: ThreadState; getViewState: GetViewState }>(
-    `${meta.id}/capability/state`,
-  );
-}

package/src/capabilities/intent-resolver.ts

@@ -1,344 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
-import { sleep } from '@dxos/async';
-import { Obj, Relation, Type } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
-import { ObservabilityAction } from '@dxos/plugin-observability/types';
-import { CollectionAction, SpaceAction } from '@dxos/plugin-space/types';
-import { Ref, fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
-import { AnchoredTo, DataType } from '@dxos/schema';
-
-import { meta } from '../meta';
-import { Channel, Thread, ThreadAction } from '../types';
-
-import { ThreadCapabilities } from './capabilities';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: ThreadAction.onCreateSpace,
-      resolve: ({ space, rootCollection }) =>
-        Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const { object: collection } = yield* dispatch(
-            createIntent(CollectionAction.CreateQueryCollection, { typename: Type.getTypename(Channel.Channel) }),
-          );
-          rootCollection.objects.push(Ref.make(collection));
-
-          const { object: channel } = yield* dispatch(
-            createIntent(ThreadAction.CreateChannel, { name: 'General', spaceId: space.id }),
-          );
-          space.db.add(channel);
-        }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannel,
-      resolve: ({ name }) => ({
-        data: {
-          object: Channel.make({ name }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: ThreadAction.CreateChannelThread,
-      resolve: ({ channel }) => {
-        const thread = Thread.make({ status: 'active' });
-        channel.threads.push(Ref.make(thread));
-        return {
-          data: {
-            object: thread,
-          },
-        };
-      },
-    }),
-    // TODO(wittjosiah): Break this up into more composable pieces.
-    createResolver({
-      intent: ThreadAction.Create,
-      resolve: ({ name, anchor: _anchor, subject }) => {
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const thread = Thread.make({ name });
-        const anchor = Relation.make(AnchoredTo, {
-          [Relation.Source]: thread,
-          [Relation.Target]: subject,
-          anchor: _anchor,
-        });
-
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          draft.push(anchor);
-        } else {
-          state.drafts[subjectId] = [anchor];
-        }
-
-        return {
-          intents: [
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
-            createIntent(DeckAction.ChangeCompanion, {
-              primary: subjectId,
-              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.AddProposal,
-      resolve: ({ text, anchor, sender, subject }) => {
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const subjectId = fullyQualifiedId(subject);
-        const proposal = Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender,
-          blocks: [{ _tag: 'proposal', text }],
-        });
-        const thread = Thread.make({ name: 'Proposal', messages: [Ref.make(proposal)], status: 'active' });
-
-        return {
-          intents: [
-            createIntent(SpaceAction.AddObject, { object: thread, target: space, hidden: true }),
-            createIntent(SpaceAction.AddRelation, {
-              space,
-              schema: AnchoredTo,
-              source: thread,
-              target: subject,
-              fields: { anchor },
-            }),
-            createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
-            createIntent(DeckAction.ChangeCompanion, {
-              primary: subjectId,
-              companion: `${subjectId}${ATTENDABLE_PATH_SEPARATOR}comments`,
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.Select,
-      resolve: ({ current }) => {
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        state.current = current;
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.ToggleResolved,
-      resolve: ({ thread }) => {
-        if (thread.status === 'active' || thread.status === undefined) {
-          thread.status = 'resolved';
-        } else if (thread.status === 'resolved') {
-          thread.status = 'active';
-        }
-
-        const space = getSpace(thread);
-        invariant(space, 'Space not found');
-        const spaceId = space.id;
-
-        return {
-          intents: [
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.toggle-resolved',
-              properties: {
-                spaceId,
-                threadId: thread.id,
-              },
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.Delete,
-      resolve: async ({ subject, anchor, thread: _thread }, undo) => {
-        const thread = _thread ?? (Relation.getSource(anchor) as Thread.Thread);
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const draft = state.drafts[subjectId];
-        if (draft) {
-          // Check if we're deleting a draft; if so, remo ve it.
-          const index = draft.findIndex((a) => a.id === anchor.id);
-          if (index !== -1) {
-            draft.splice(index, 1);
-            return;
-          }
-        }
-
-        const space = getSpace(anchor);
-        if (!space) {
-          return;
-        }
-
-        if (!undo) {
-          // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-          space.db.remove(anchor);
-          await sleep(100);
-          space.db.remove(thread);
-
-          return {
-            undoable: {
-              message: ['thread deleted label', { ns: meta.id }],
-              data: { thread, anchor },
-            },
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                },
-              }),
-            ],
-          };
-        } else {
-          // TODO(wittjosiah): Without sleep, rendering crashes at `Relation.setSource(anchor)`.
-          space.db.add(thread);
-          await sleep(100);
-          space.db.add(anchor);
-
-          return {
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.undo-delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.AddMessage,
-      resolve: ({ anchor, subject, sender, text }) => {
-        const thread = Relation.getSource(anchor) as Thread.Thread;
-        const { state } = context.getCapability(ThreadCapabilities.MutableState);
-        const subjectId = fullyQualifiedId(subject);
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        const message = Obj.make(DataType.Message, {
-          created: new Date().toISOString(),
-          sender,
-          blocks: [{ _tag: 'text', text }],
-          // TODO(wittjosiah): Context based on attention.
-          // context: context ? Ref.make(context) : undefined,
-        });
-        thread.messages.push(Ref.make(message));
-
-        const intents = [];
-        const draft = state.drafts[subjectId]?.find((a) => a.id === anchor.id);
-        if (draft) {
-          // Move draft to document.
-          thread.status = 'active';
-          // TODO(wittjosiah): This causes the thread to flash as it transitions from draft to db.
-          state.drafts[subjectId] = state.drafts[subjectId]?.filter((a) => a.id !== anchor.id);
-          intents.push(createIntent(SpaceAction.AddObject, { object: thread, target: space, hidden: true }));
-          intents.push(
-            createIntent(SpaceAction.AddRelation, {
-              space,
-              schema: AnchoredTo,
-              source: thread,
-              target: subject,
-              fields: { anchor: draft.anchor },
-            }),
-          );
-          intents.push(
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'threads.create',
-              properties: {
-                spaceId: space.id,
-                threadId: thread.id,
-              },
-            }),
-          );
-        }
-
-        intents.push(
-          createIntent(ObservabilityAction.SendEvent, {
-            name: 'threads.message.add',
-            properties: {
-              spaceId: space.id,
-              threadId: thread.id,
-              threadLength: thread.messages.length,
-              messageId: message.id,
-              messageLength: text.length,
-            },
-          }),
-        );
-
-        return { intents };
-      },
-    }),
-    createResolver({
-      intent: ThreadAction.DeleteMessage,
-      resolve: ({ subject, anchor, messageId, message, messageIndex }, undo) => {
-        const thread = Relation.getSource(anchor) as Thread.Thread;
-        const space = getSpace(subject);
-        invariant(space, 'Space not found');
-
-        if (!undo) {
-          const messageIndex = thread.messages.findIndex(Ref.hasObjectId(messageId));
-          const message = thread.messages[messageIndex]?.target;
-          if (!message) {
-            return;
-          }
-
-          if (messageIndex === 0 && thread.messages.length === 1) {
-            // If the message is the only message in the thread, delete the thread.
-            return {
-              intents: [createIntent(ThreadAction.Delete, { subject, anchor })],
-            };
-          } else {
-            thread.messages.splice(messageIndex, 1);
-          }
-
-          return {
-            undoable: {
-              message: ['message deleted label', { ns: meta.id }],
-              data: { message, messageIndex },
-            },
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.message.delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                  messageId: message.id,
-                },
-              }),
-            ],
-          };
-        } else {
-          if (messageIndex === undefined || !message) {
-            return;
-          }
-
-          thread.messages.splice(messageIndex, 0, Ref.make(message));
-          return {
-            intents: [
-              createIntent(ObservabilityAction.SendEvent, {
-                name: 'threads.message.undo-delete',
-                properties: {
-                  spaceId: space.id,
-                  threadId: thread.id,
-                  messageId: message.id,
-                },
-              }),
-            ],
-          };
-        }
-      },
-    }),
-  ]);

package/src/capabilities/toolkit.ts

@@ -1,85 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
-import * as Array from 'effect/Array';
-import * as Effect from 'effect/Effect';
-import * as Function from 'effect/Function';
-import * as Schema from 'effect/Schema';
-
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { ArtifactId, computeDiffsWithCursors } from '@dxos/assistant';
-import { type SpaceId } from '@dxos/keys';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { type Markdown } from '@dxos/plugin-markdown/types';
-import { createDocAccessor } from '@dxos/react-client/echo';
-import { trim } from '@dxos/util';
-
-import { ThreadAction } from '../types';
-
-// TODO(wittjosiah): How to make this work for more than Documents?
-const Toolkit$ = Toolkit.make(
-  Tool.make('add-proposals', {
-    description: trim`
-      Proposes a set of changes to a document.
-    `,
-    parameters: {
-      id: ArtifactId,
-      diffs: Schema.Array(Schema.String).annotations({
-        description: 'The diffs to propose for the document.',
-      }),
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-);
-
-export namespace ThreadToolkit {
-  export const Toolkit = Toolkit$;
-
-  export const createLayer = (context: PluginContext) =>
-    Toolkit$.toLayer({
-      'add-proposals': ({ id, diffs: _diffs }) =>
-        Effect.gen(function* () {
-          // TODO(wittjosiah): Get capabilities via layers.
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const client = context.getCapability(ClientCapabilities.Client);
-          const state = context.getCapability(Capabilities.Layout);
-
-          const dxn = ArtifactId.toDXN(id, state.workspace as SpaceId);
-          const echoDxn = dxn.asEchoDXN();
-          if (!echoDxn) {
-            throw new Error(`Invalid object ID: ${id}`);
-          }
-
-          const space = client.spaces.get(echoDxn.spaceId!);
-          const object = space?.db.getObjectById<Markdown.Document>(echoDxn.echoId);
-          if (!object) {
-            throw new Error(`Object not found: ${id}`);
-          }
-
-          const content = yield* Effect.promise(() => object.content.load());
-          const accessor = createDocAccessor(content, ['content']);
-          yield* Function.pipe(
-            computeDiffsWithCursors(accessor, _diffs),
-            Array.map(({ cursor, text }) =>
-              createIntent(ThreadAction.AddProposal, {
-                subject: object,
-                sender: { role: 'assistant' },
-                anchor: cursor,
-                text,
-              }),
-            ),
-            Array.map(dispatch),
-            Effect.allWith({ concurrency: 'unbounded' }),
-          );
-        }).pipe(Effect.orDie),
-    });
-}
-
-export default (context: PluginContext) => [
-  contributes(Capabilities.Toolkit, ThreadToolkit.Toolkit),
-  contributes(Capabilities.ToolkitHandler, ThreadToolkit.createLayer(context)),
-];

package/src/components/CallSidebar.tsx

@@ -1,18 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import React from 'react';
-
-import { useCapability } from '@dxos/app-framework';
-
-import { ThreadCapabilities } from '../capabilities';
-
-import { ChannelContainer } from './ChannelContainer';
-
-export const CallSidebar = () => {
-  const call = useCapability(ThreadCapabilities.CallManager);
-  return <ChannelContainer roomId={call.roomId} />;
-};
-
-export default CallSidebar;