@dxos/plugin-assistant 0.8.4-main.70d3990 → 0.8.4-main.7996785055

package/dist/types/src/functions/object-load.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object-load.d.ts","sourceRoot":"","sources":["../../../../src/functions/object-load.ts"],"names":[],"mappings":";;;;;;AAcA,wBA8BG"}

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

@@ -1,129 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { Prompt } from '@dxos/blueprints';
-declare const OnCreateSpace_base: Schema.TaggedClass<OnCreateSpace, `${string}/on-space-created`, {
-    readonly _tag: Schema.tag<`${string}/on-space-created`>;
-} & {
-    input: Schema.Struct<{
-        space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
-        rootCollection: import("@dxos/echo/Type").obj<Schema.Struct<{
-            name: Schema.optional<typeof Schema.String>;
-            objects: Schema.mutable<Schema.Array$<import("@dxos/echo/internal").RefSchema<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & {}>>>;
-        }>>;
-    }>;
-    output: typeof Schema.Void;
-}>;
-export declare class OnCreateSpace extends OnCreateSpace_base {
-}
-declare const CreateChat_base: Schema.TaggedClass<CreateChat, `${string}/action/create-chat`, {
-    readonly _tag: Schema.tag<`${string}/action/create-chat`>;
-} & {
-    input: Schema.Struct<{
-        space: Schema.Schema<import("@dxos/client-protocol").Space, import("@dxos/client-protocol").Space, never>;
-        name: Schema.optional<typeof Schema.String>;
-    }>;
-    output: Schema.Struct<{
-        object: import("@dxos/echo/Type").obj<Schema.Struct<{
-            name: Schema.optional<typeof Schema.String>;
-            queue: import("@dxos/echo/internal").RefSchema<import("@dxos/echo-db").Queue<import("@dxos/echo/Entity").Unknown>>;
-            traceQueue: Schema.optional<import("@dxos/echo/internal").RefSchema<import("@dxos/echo-db").Queue<import("@dxos/echo/Entity").Unknown>>>;
-        }>>;
-    }>;
-}>;
-export declare class CreateChat extends CreateChat_base {
-}
-declare const UpdateChatName_base: Schema.TaggedClass<UpdateChatName, `${string}/action/update-name`, {
-    readonly _tag: Schema.tag<`${string}/action/update-name`>;
-} & {
-    input: Schema.Struct<{
-        chat: import("@dxos/echo/Type").obj<Schema.Struct<{
-            name: Schema.optional<typeof Schema.String>;
-            queue: import("@dxos/echo/internal").RefSchema<import("@dxos/echo-db").Queue<import("@dxos/echo/Entity").Unknown>>;
-            traceQueue: Schema.optional<import("@dxos/echo/internal").RefSchema<import("@dxos/echo-db").Queue<import("@dxos/echo/Entity").Unknown>>>;
-        }>>;
-    }>;
-    output: typeof Schema.Void;
-}>;
-export declare class UpdateChatName extends UpdateChatName_base {
-}
-export declare const BlueprintForm: Schema.Struct<{
-    key: typeof Schema.String;
-    name: typeof Schema.String;
-    description: Schema.optional<typeof Schema.String>;
-}>;
-declare const CreateBlueprint_base: Schema.TaggedClass<CreateBlueprint, `${string}/action/create-blueprint`, {
-    readonly _tag: Schema.tag<`${string}/action/create-blueprint`>;
-} & {
-    input: Schema.Struct<{
-        key: typeof Schema.String;
-        name: typeof Schema.String;
-        description: Schema.optional<typeof Schema.String>;
-    }>;
-    output: Schema.Struct<{
-        object: import("@dxos/echo/Type").obj<Schema.Struct<{
-            key: Schema.SchemaClass<string, string, never>;
-            name: Schema.SchemaClass<string, string, never>;
-            description: Schema.optional<typeof Schema.String>;
-            instructions: Schema.mutable<Schema.Struct<{
-                source: Schema.SchemaClass<import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & {
-                    content: string;
-                }>, import("@dxos/echo-protocol").EncodedReference, never>;
-                inputs: Schema.optional<Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
-                    name: typeof Schema.String;
-                    kind: Schema.optional<Schema.Literal<["value", "pass-through", "retriever", "function", "query", "resolver", "context", "schema"]>>;
-                    default: Schema.optional<typeof Schema.Any>;
-                }>>>>>;
-            }>>;
-            tools: Schema.Array$<Schema.brand<typeof Schema.String, "ToolId">>;
-        }>>;
-    }>;
-}>;
-export declare class CreateBlueprint extends CreateBlueprint_base {
-}
-declare const CreatePrompt_base: Schema.TaggedClass<CreatePrompt, `${string}/action/create-prompt`, {
-    readonly _tag: Schema.tag<`${string}/action/create-prompt`>;
-} & {
-    input: Schema.Struct<{
-        name: Schema.optional<typeof Schema.String>;
-    }>;
-    output: Schema.Struct<{
-        object: Schema.Schema<Prompt.Prompt, Prompt.Prompt_Encoded, never>;
-    }>;
-}>;
-export declare class CreatePrompt extends CreatePrompt_base {
-}
-declare const CreateSequence_base: Schema.TaggedClass<CreateSequence, `${string}/action/create-sequence`, {
-    readonly _tag: Schema.tag<`${string}/action/create-sequence`>;
-} & {
-    input: Schema.Struct<{
-        name: Schema.optional<typeof Schema.String>;
-    }>;
-    output: Schema.Struct<{
-        object: import("@dxos/echo/Type").obj<Schema.Struct<{
-            name: Schema.optional<typeof Schema.String>;
-            steps: Schema.Array$<Schema.Struct<{
-                id: import("@dxos/keys").ObjectIdClass;
-                instructions: typeof Schema.String;
-                tools: Schema.optional<Schema.Array$<Schema.brand<typeof Schema.String, "ToolId">>>;
-            }>>;
-        }>>;
-    }>;
-}>;
-export declare class CreateSequence extends CreateSequence_base {
-}
-declare const SetCurrentChat_base: Schema.TaggedClass<SetCurrentChat, `${string}/action/set-current-chat`, {
-    readonly _tag: Schema.tag<`${string}/action/set-current-chat`>;
-} & {
-    input: Schema.Struct<{
-        companionTo: Schema.Schema<any, any, never>;
-        chat: Schema.optional<import("@dxos/echo/Type").obj<Schema.Struct<{
-            name: Schema.optional<typeof Schema.String>;
-            queue: import("@dxos/echo/internal").RefSchema<import("@dxos/echo-db").Queue<import("@dxos/echo/Entity").Unknown>>;
-            traceQueue: Schema.optional<import("@dxos/echo/internal").RefSchema<import("@dxos/echo-db").Queue<import("@dxos/echo/Entity").Unknown>>>;
-        }>>>;
-    }>;
-    output: typeof Schema.Void;
-}>;
-export declare class SetCurrentChat extends SetCurrentChat_base {
-}
-export {};
-//# sourceMappingURL=AssistantAction.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"AssistantAction.d.ts","sourceRoot":"","sources":["../../../../src/types/AssistantAction.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAa,MAAM,EAAE,MAAM,kBAAkB,CAAC;;;;;;;;;;;;;AAUrD,qBAAa,aAAc,SAAQ,kBAMjC;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,UAAW,SAAQ,eAQ9B;CAAG;;;;;;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAKlC;CAAG;AAEL,eAAO,MAAM,aAAa;;;;EAIxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,qBAAa,eAAgB,SAAQ,oBAKnC;CAAG;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAOhC;CAAG;;;;;;;;;;;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAOlC;CAAG;;;;;;;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAMlC;CAAG"}

package/src/capabilities/ai-service.ts

@@ -1,27 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-
-import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
-
-export default (context: PluginContext) => {
-  const resolvers = context.getCapabilities(Capabilities.AiModelResolver);
-
-  // TODO(dmaretskyi): Extract function to reduce them.
-  const combinedLayer = resolvers.reduce(
-    (acc, resolver) => resolver.pipe(Layer.provide(acc)),
-    AiServiceRouter.AiModelResolver.fromModelMap(Effect.succeed({})), // Empty resolver as fallback.
-  );
-
-  return [
-    // TODO(dmaretskyi): Read config from settings.
-    contributes(
-      Capabilities.AiServiceLayer,
-      AiServiceRouter.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer)),
-    ),
-  ];
-};

package/src/capabilities/app-graph-builder.ts

@@ -1,210 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Atom } from '@effect-atom/atom-react';
-import * as Function from 'effect/Function';
-import * as Option from 'effect/Option';
-
-import {
-  Capabilities,
-  LayoutAction,
-  type PluginContext,
-  type PromiseIntentDispatcher,
-  contributes,
-  createIntent,
-} from '@dxos/app-framework';
-import { Prompt } from '@dxos/blueprints';
-import { Sequence } from '@dxos/conductor';
-import { DXN, Obj } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { ROOT_ID, atomFromSignal, createExtension } from '@dxos/plugin-graph';
-import { getActiveSpace } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Query, type Space, getSpace } from '@dxos/react-client/echo';
-
-import { ASSISTANT_DIALOG, meta } from '../meta';
-import { Assistant, AssistantAction } from '../types';
-
-import { AssistantCapabilities } from './capabilities';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${meta.id}/root`,
-      actions: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => {
-              return Obj.instanceOf(Assistant.Chat, node.data) ? Option.some(node.data) : Option.none();
-            }),
-            Option.map((object) => {
-              const id = Obj.getDXN(object).toString();
-              return [
-                {
-                  id: `${AssistantAction.UpdateChatName._tag}/${id}`,
-                  data: async () => {
-                    const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-                    await dispatch(createIntent(AssistantAction.UpdateChatName, { chat: object }));
-                  },
-                  properties: {
-                    label: ['chat update name label', { ns: meta.id }],
-                    icon: 'ph--magic-wand--regular',
-                    disposition: 'list-item',
-                  },
-                },
-              ];
-            }),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-
-    createExtension({
-      id: `${meta.id}/assistant`,
-      actions: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
-            Option.map(() => [
-              {
-                id: `${LayoutAction.UpdateDialog._tag}/assistant/open`,
-                data: async () => {
-                  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-                  const client = context.getCapability(ClientCapabilities.Client);
-                  const space = getActiveSpace(context) ?? client.spaces.default;
-                  const chat = await getOrCreateChat(dispatch, space);
-                  if (!chat) {
-                    return;
-                  }
-
-                  await dispatch(
-                    createIntent(LayoutAction.UpdateDialog, {
-                      part: 'dialog',
-                      subject: ASSISTANT_DIALOG,
-                      options: {
-                        state: true,
-                        blockAlign: 'end',
-                        props: {
-                          chat,
-                        },
-                      },
-                    }),
-                  );
-                },
-                properties: {
-                  label: ['open assistant label', { ns: meta.id }],
-                  icon: 'ph--sparkle--regular',
-                  disposition: 'pin-end',
-                  position: 'hoist',
-                  keyBinding: {
-                    macos: 'shift+meta+k',
-                    windows: 'shift+ctrl+k',
-                  },
-                },
-              },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-
-    createExtension({
-      id: `${meta.id}/companion-chat`,
-      connector: (node) => {
-        return Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (Obj.isObject(node.data) ? Option.some(node.data) : Option.none())),
-            Option.flatMap((object): Option.Option<{ object: Obj.Any; currentChat: Obj.Any | undefined }> => {
-              const currentChatState = get(
-                atomFromSignal(
-                  () => context.getCapability(AssistantCapabilities.State).currentChat[Obj.getDXN(object).toString()],
-                ),
-              );
-              // If no state, continue to allow chat initialization.
-              if (!currentChatState) {
-                return Option.some({ object, currentChat: undefined });
-              }
-
-              const space = getSpace(object);
-              const currentChatDxn = DXN.tryParse(currentChatState);
-              const currentChatRef = currentChatDxn ? space?.db.makeRef(currentChatDxn) : undefined;
-              const currentChat = get(atomFromSignal(() => currentChatRef?.target));
-              return Obj.isObject(currentChat) ? Option.some({ object, currentChat }) : Option.none();
-            }),
-            Option.map(({ object, currentChat }) => {
-              return [
-                {
-                  id: [Obj.getDXN(object).toString(), 'assistant-chat'].join(ATTENDABLE_PATH_SEPARATOR),
-                  type: PLANK_COMPANION_TYPE,
-                  data: currentChat ?? 'assistant-chat',
-                  properties: {
-                    label: ['assistant chat label', { ns: meta.id }],
-                    icon: 'ph--sparkle--regular',
-                    position: 'hoist',
-                    disposition: 'hidden',
-                  },
-                },
-              ];
-            }),
-            Option.getOrElse(() => []),
-          ),
-        );
-      },
-    }),
-
-    createExtension({
-      id: `${meta.id}/invocations`,
-      connector: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) =>
-              Obj.instanceOf(Sequence, node.data) || Obj.instanceOf(Prompt.Prompt, node.data)
-                ? Option.some(node)
-                : Option.none(),
-            ),
-            Option.map((node) => [
-              {
-                id: [node.id, 'invocations'].join(ATTENDABLE_PATH_SEPARATOR),
-                type: PLANK_COMPANION_TYPE,
-                data: 'invocations',
-                properties: {
-                  label: ['invocations label', { ns: meta.id }],
-                  icon: 'ph--clock-countdown--regular',
-                  disposition: 'hidden',
-                },
-              },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-  ]);
-
-// TODO(burdon): Factor out.
-const getOrCreateChat = async (
-  dispatch: PromiseIntentDispatcher,
-  space: Space,
-): Promise<Assistant.Chat | undefined> => {
-  // TODO(wittjosiah): This should be possible with a single query.
-  const { objects: allChats } = await space.db.query(Query.type(Assistant.Chat)).run();
-  const { objects: relatedChats } = await space.db
-    .query(Query.type(Assistant.Chat).sourceOf(Assistant.CompanionTo).source())
-    .run();
-
-  const chats = allChats.filter((chat) => !relatedChats.includes(chat));
-  if (chats.length > 0) {
-    return chats.at(-1);
-  }
-
-  const { data } = await dispatch(createIntent(AssistantAction.CreateChat, { space }));
-  invariant(Obj.instanceOf(Assistant.Chat, data?.object));
-  await dispatch(createIntent(SpaceAction.AddObject, { target: space, object: data.object }));
-  return data.object;
-};

package/src/capabilities/blueprint-definition.ts

@@ -1,66 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
-import { templates } from '@dxos/assistant';
-import {
-  Agent,
-  AssistantToolkit,
-  Discord,
-  DiscordBlueprint,
-  EntityExtraction,
-  Linear,
-  LinearBlueprint,
-  Research,
-  ResearchBlueprint,
-  SystemToolkit,
-  WebSearchBlueprint,
-} from '@dxos/assistant-toolkit';
-import { Blueprint } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
-
-import { analysis, list, load } from '../functions';
-
-// TODO(burdon): Document plugin structure (blueprint, functions, toolkit.)
-// TODO(burdon): Test framework for developing functions. Error handling.
-// TODO(burdon): Function naming pattern (noun-verb); fully-qualified?
-
-// TODO(wittjosiah): Factor out to a generic app-framework blueprint.
-const deckTools = ['open-item'];
-
-const functions: FunctionDefinition[] = [analysis, list, load];
-const tools = [...AssistantToolkit.tools, ...SystemToolkit.tools, ...deckTools];
-
-export const ASSISTANT_BLUEPRINT_KEY = 'dxos.org/blueprint/assistant';
-
-export const createBlueprint = (): Blueprint.Blueprint =>
-  Blueprint.make({
-    key: ASSISTANT_BLUEPRINT_KEY,
-    name: 'Assistant',
-    tools: Blueprint.toolDefinitions({ functions, tools }),
-    instructions: templates.system,
-  });
-
-const blueprint = createBlueprint();
-
-export default (): Capability<any>[] => [
-  contributes(Capabilities.Functions, functions),
-  contributes(Capabilities.BlueprintDefinition, blueprint),
-
-  // TODO(burdon): Factor out.
-  contributes(Capabilities.Functions, [Research.create, Research.research]),
-  contributes(Capabilities.BlueprintDefinition, ResearchBlueprint),
-
-  // TODO(burdon): Factor out.
-  contributes(Capabilities.Functions, [Agent.prompt, EntityExtraction.extract]),
-  contributes(Capabilities.BlueprintDefinition, WebSearchBlueprint),
-
-  // TODO(burdon): Factor out.
-  contributes(Capabilities.Functions, [Discord.fetch]),
-  contributes(Capabilities.BlueprintDefinition, DiscordBlueprint),
-
-  // TODO(burdon): Factor out.
-  contributes(Capabilities.Functions, [Linear.sync]),
-  contributes(Capabilities.BlueprintDefinition, LinearBlueprint),
-];

package/src/capabilities/capabilities.ts

@@ -1,17 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineCapability } from '@dxos/app-framework';
-import { type DeepReadonly } from '@dxos/util';
-
-import { meta } from '../meta';
-
-export namespace AssistantCapabilities {
-  export type AssistantState = {
-    /** Map of primary object dxn to current chat dxn. */
-    currentChat: Record<string, string | undefined>;
-  };
-  export const State = defineCapability<DeepReadonly<AssistantState>>(`${meta.id}/capability/state`);
-  export const MutableState = defineCapability<AssistantState>(`${meta.id}/capability/state`);
-}

package/src/capabilities/edge-model-resolver.ts

@@ -1,25 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
-import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
-import * as Layer from 'effect/Layer';
-
-import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
-import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
-
-export default (): Capability<any>[] => [
-  contributes(
-    Capabilities.AiModelResolver,
-    AiServiceRouter.AnthropicResolver.pipe(
-      Layer.provide(
-        AnthropicClient.layer({
-          // TODO(dmaretskyi): Read endpoint from config/settings.
-          apiUrl: 'https://ai-service.dxos.workers.dev/provider/anthropic',
-        }),
-      ),
-      Layer.provide(FetchHttpClient.layer),
-    ),
-  ),
-];

package/src/capabilities/intent-resolver.ts

@@ -1,135 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
-import { AiContextBinder, AiConversation } from '@dxos/assistant';
-import { Agent } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt, Template } from '@dxos/blueprints';
-import { type Queue } from '@dxos/client/echo';
-import { Sequence } from '@dxos/conductor';
-import { Filter, Key, Obj, Ref, Type } from '@dxos/echo';
-import { TracingService, serializeFunction } from '@dxos/functions';
-import { AutomationCapabilities } from '@dxos/plugin-automation';
-import { getSpace } from '@dxos/react-client/echo';
-import { Collection } from '@dxos/schema';
-import { type Message } from '@dxos/types';
-
-import { type AiChatServices, updateName } from '../processor';
-import { Assistant, AssistantAction } from '../types';
-
-import { ASSISTANT_BLUEPRINT_KEY, createBlueprint } from './blueprint-definition';
-import { AssistantCapabilities } from './capabilities';
-
-export default (context: PluginContext) => [
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: AssistantAction.OnCreateSpace,
-      resolve: ({ space, rootCollection }) =>
-        Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const chatCollection = Collection.makeManaged({ key: Assistant.Chat.typename });
-          const blueprintCollection = Collection.makeManaged({ key: Blueprint.Blueprint.typename });
-          const promptCollection = Collection.makeManaged({ key: Type.getTypename(Prompt.Prompt) });
-          rootCollection.objects.push(
-            Ref.make(chatCollection),
-            Ref.make(blueprintCollection),
-            Ref.make(promptCollection),
-          );
-
-          // TODO(wittjosiah): Remove once function registry is avaiable.
-          space.db.add(serializeFunction(Agent.prompt));
-
-          // Create default chat.
-          const { object: chat } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
-          space.db.add(chat);
-        }),
-    }),
-    createResolver({
-      intent: AssistantAction.CreateChat,
-      resolve: async ({ space, name }) => {
-        const queue = space.queues.create();
-        const chat = Assistant.makeChat({ name, queue });
-
-        // TODO(wittjosiah): This should be a space-level setting.
-        // TODO(burdon): Clone when activated. Copy-on-write for template.
-        const { objects: blueprints } = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
-        let defaultBlueprint = blueprints.find((blueprint) => blueprint.key === ASSISTANT_BLUEPRINT_KEY);
-        if (!defaultBlueprint) {
-          defaultBlueprint = space.db.add(createBlueprint());
-        }
-
-        const binder = new AiContextBinder(queue);
-        await binder.use((binder) => binder.bind({ blueprints: [Ref.make(defaultBlueprint)] }));
-
-        return {
-          data: { object: chat },
-        };
-      },
-    }),
-    createResolver({
-      intent: AssistantAction.UpdateChatName,
-      resolve: async ({ chat }) => {
-        const space = getSpace(chat);
-        const queue = chat.queue.target as Queue<Message.Message>;
-        if (!space || !queue) {
-          return;
-        }
-
-        const runtimeResolver = context.getCapability(AutomationCapabilities.ComputeRuntime);
-        const runtime = await runtimeResolver
-          .getRuntime(space.id)
-          .runPromise(Effect.runtime<AiChatServices>().pipe(Effect.provide(TracingService.layerNoop)));
-
-        await new AiConversation(queue).use(async (conversation) => updateName(runtime, conversation, chat));
-      },
-    }),
-    createResolver({
-      intent: AssistantAction.CreateBlueprint,
-      resolve: ({ key, name, description }) => ({
-        data: {
-          object: Blueprint.make({
-            key,
-            name,
-            description,
-            instructions: Template.make(),
-          }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: AssistantAction.CreatePrompt,
-      resolve: ({ name }) => ({
-        data: {
-          object: Prompt.make({ name }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: AssistantAction.CreateSequence,
-      resolve: ({ name }) => ({
-        data: {
-          object: Obj.make(Sequence, {
-            name,
-            steps: [
-              {
-                id: Key.ObjectId.random(),
-                instructions: 'You are a helpful assistant.',
-              },
-            ],
-          }),
-        },
-      }),
-    }),
-    createResolver({
-      intent: AssistantAction.SetCurrentChat,
-      resolve: ({ companionTo, chat }) =>
-        Effect.gen(function* () {
-          const state = context.getCapability(AssistantCapabilities.MutableState);
-          state.currentChat[Obj.getDXN(companionTo).toString()] = chat && Obj.getDXN(chat).toString();
-        }),
-    }),
-  ]),
-];

package/src/capabilities/local-model-resolver.ts

@@ -1,30 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as OpenAiClient from '@effect/ai-openai/OpenAiClient';
-import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
-import * as Layer from 'effect/Layer';
-
-import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
-import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
-
-/**
- * To start LM Studio server:
- * ```bash
- * ~/.lmstudio/bin/lms server start --cors
- * ```
- */
-export default (): Capability<any>[] => [
-  contributes(
-    Capabilities.AiModelResolver,
-    AiServiceRouter.LMStudioResolver.pipe(
-      Layer.provide(
-        OpenAiClient.layer({
-          apiUrl: AiServiceRouter.DEFAULT_LMSTUDIO_ENDPOINT,
-        }),
-      ),
-      Layer.provide(FetchHttpClient.layer),
-    ),
-  ),
-];