@dxos/plugin-assistant 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/src/hooks/useChatToolbarActions.ts

@@ -6,19 +6,20 @@ import { Atom } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
 import { useMemo } from 'react';
 
-import { useOperationInvoker } from '@dxos/app-framework/react';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { Chat } from '@dxos/assistant-toolkit';
 import { Filter, Obj, Query } from '@dxos/echo';
 import { runAndForwardErrors } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import { useQuery } from '@dxos/react-client/echo';
 import { MenuBuilder, useMenuActions } from '@dxos/react-ui-menu';
 
-import { useChatContext } from '../components';
-import { meta } from '../meta';
-import { Assistant, AssistantOperation } from '../types';
+import { useChatContext } from '#components';
+import { meta } from '#meta';
+import { AssistantOperation } from '#operations';
 
 export type ChatToolbarActionsProps = {
-  chat?: Assistant.Chat;
+  chat?: Chat.Chat;
   companionTo?: Obj.Unknown;
 };
 
@@ -26,7 +27,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
   const { invoke } = useOperationInvoker();
   const { db } = useChatContext('useChatToolbarActions');
   const query = companionTo
-    ? Query.select(Filter.id(companionTo.id)).targetOf(Assistant.CompanionTo).source()
+    ? Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source()
     : Query.select(Filter.nothing());
 
   // TODO(wittjosiah): Query in react vs query in atom?
@@ -38,12 +39,12 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
       return Atom.make(() => {
         const builder = MenuBuilder.make()
           .root({
-            label: ['chat toolbar title', { ns: meta.id }],
+            label: ['chat-toolbar.title', { ns: meta.id }],
           })
           .action(
             'new',
             {
-              label: ['new thread button', { ns: meta.id }],
+              label: ['new-thread.button', { ns: meta.id }],
               icon: 'ph--plus--regular',
               type: 'new',
               disabled: !companionTo,
@@ -59,7 +60,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
           .action(
             'rename',
             {
-              label: ['rename thread button', { ns: meta.id }],
+              label: ['rename-thread.button', { ns: meta.id }],
               icon: 'ph--magic-wand--regular',
               type: 'rename',
               disabled: !chat,
@@ -73,7 +74,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
           .action(
             'branch',
             {
-              label: ['button branch thread', { ns: meta.id }],
+              label: ['branch-thread.menu', { ns: meta.id }],
               icon: 'ph--git-branch--regular',
               type: 'branch',
               disabled: true,
@@ -85,7 +86,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
           builder.group(
             'chats',
             {
-              label: ['chat history label', { ns: meta.id }],
+              label: ['chat-history.label', { ns: meta.id }],
               icon: 'ph--clock-counter-clockwise--regular',
               selectCardinality: 'single',
               variant: 'dropdownMenu',
@@ -98,7 +99,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
                   builder.action(
                     chat.id,
                     {
-                      label: Obj.getLabel(chat) ?? ['object name placeholder', { ns: Assistant.Chat.typename }],
+                      label: Obj.getLabel(chat) ?? ['object-name.placeholder', { ns: Chat.Chat.typename }],
                     },
                     () =>
                       Effect.gen(function* () {

package/src/hooks/useContextObjects.ts

@@ -2,10 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
 import { useCallback } from 'react';
 
 import { type AiContextBinder } from '@dxos/assistant';
-import { type DXN, type Database, type Obj, Ref } from '@dxos/echo';
+import { type DXN, type Database, type Obj } from '@dxos/echo';
 
 export type UseContextObjectsProps = {
   db?: Database.Database;
@@ -17,18 +18,21 @@ export type UseContextObjects = {
   onUpdateObject: (dxn: DXN, checked: boolean) => Promise<void>;
 };
 
+const emptyObjectsAtom = Atom.make<Obj.Unknown[]>([]);
+
 /**
  * Create reactive map of active object references (by DXN string).
  */
 export const useContextObjects = ({ db, context }: UseContextObjectsProps): UseContextObjects => {
+  const objects = useAtomValue(context?.objects ?? emptyObjectsAtom);
+
   const handleUpdateObject = useCallback<UseContextObjects['onUpdateObject']>(
     async (dxn: DXN, checked: boolean) => {
       if (!db || !context) {
         return;
       }
 
-      // Load the object by DXN from the current space.
-      const ref = Ref.fromDXN(dxn);
+      const ref = db.makeRef<Obj.Unknown>(dxn);
       await ref.load();
       if (checked) {
         await context.bind({ objects: [ref] });
@@ -40,7 +44,7 @@ export const useContextObjects = ({ db, context }: UseContextObjectsProps): UseC
   );
 
   return {
-    objects: context?.getObjects() ?? [],
+    objects,
     onUpdateObject: handleUpdateObject,
   };
 };

package/src/hooks/useFilteredTypes.ts

@@ -10,8 +10,8 @@ import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from '@dxos/echo/
 
 // TODO(burdon): Pass in filter.
 // TODO(wittjosiah): Factor out.
-export const useFilteredTypes = (db?: Database.Database): Type.Entity.Any[] => {
-  const [types, setTypes] = useState<Type.Entity.Any[]>([]);
+export const useFilteredTypes = (db?: Database.Database): Type.AnyEntity[] => {
+  const [types, setTypes] = useState<Type.AnyEntity[]>([]);
   useEffect(() => {
     if (!db) {
       return;
@@ -23,7 +23,7 @@ export const useFilteredTypes = (db?: Database.Database): Type.Entity.Any[] => {
           new Set(
             query.results
               .filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation)
-              .filter((schema) => SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))),
+              .filter((schema) => !SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))),
           ),
         );
 

package/src/hooks/usePresets.ts

@@ -4,7 +4,7 @@
 
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import { type ChatPromptProps } from '../components';
+import { type ChatPromptProps } from '#components';
 import { type AiServicePreset, AiServicePresets } from '../processor';
 
 export type UsePresets = {

package/src/hooks/useReferencesProvider.ts

@@ -4,8 +4,6 @@
 
 import { useMemo } from 'react';
 
-import { Common } from '@dxos/app-framework';
-import { useCapabilities } from '@dxos/app-framework/react';
 import { type Space } from '@dxos/client/echo';
 import { Filter, Obj } from '@dxos/echo';
 import { type ReferencesProvider } from '@dxos/react-ui-chat';
@@ -14,8 +12,6 @@ import { type ReferencesProvider } from '@dxos/react-ui-chat';
  * Resolve references to objects in the space.
  */
 export const useReferencesProvider = (space?: Space): ReferencesProvider | undefined => {
-  const blueprints = useCapabilities(Common.Capability.BlueprintDefinition);
-
   return useMemo<ReferencesProvider | undefined>((): ReferencesProvider | undefined => {
     if (!space) {
       return undefined;
@@ -52,7 +48,7 @@ export const useReferencesProvider = (space?: Space): ReferencesProvider | undef
         return { uri, label: Obj.getLabel(object) ?? '' };
       },
     } satisfies ReferencesProvider;
-  }, [space, blueprints]);
+  }, [space]);
 };
 
 const stringMatch = (query: string, label: string) => label.toLowerCase().startsWith(query.toLowerCase());

package/src/index.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './capabilities';
+export * from './blueprints';
 export * from './components';
 export * from './hooks';
 export * from './meta';

package/src/meta.ts

@@ -6,7 +6,7 @@ import { type Plugin } from '@dxos/app-framework';
 import { trim } from '@dxos/util';
 
 export const meta: Plugin.Meta = {
-  id: 'dxos.org/plugin/assistant',
+  id: 'org.dxos.plugin.assistant',
   name: 'Assistant',
   description: trim`
     Intelligent AI assistant that can analyze and interact with objects across your spaces.
@@ -18,4 +18,7 @@ export const meta: Plugin.Meta = {
   tags: ['labs'],
 };
 
-export const ASSISTANT_DIALOG = `${meta.id}/assistant/dialog`;
+export const ASSISTANT_DIALOG = `${meta.id}.assistant.dialog`;
+
+/** Companion variant identifier for the assistant chat panel. */
+export const ASSISTANT_COMPANION_VARIANT = 'assistant-chat';

package/src/operations/create-chat.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AiContextBinder } from '@dxos/assistant';
+import { Chat, DatabaseBlueprint, ProjectWizardBlueprint } from '@dxos/assistant-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { Feed, Filter, Obj, Ref } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+
+import { AssistantBlueprint } from '#blueprints';
+import { CreateChat } from './definitions';
+
+const handler: Operation.WithHandler<typeof CreateChat> = CreateChat.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ db, name, addToSpace = true }) {
+      const registry = yield* Capability.get(Capabilities.AtomRegistry);
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      const space = client.spaces.get(db.spaceId);
+      invariant(space, 'Space not found');
+      const feed = space.db.add(Feed.make());
+      const queueDxn = Feed.getQueueDxn(feed);
+      invariant(queueDxn, 'Feed queue DXN not found.');
+      const queue = space.queues.get(queueDxn);
+      const chat = Chat.make({ name, feed: Ref.make(feed) });
+      Obj.setParent(feed, chat);
+      if (addToSpace) {
+        space.db.add(chat);
+      }
+
+      // TODO(wittjosiah): This should be a space-level setting.
+      // TODO(burdon): Clone when activated. Copy-on-write for template.
+      const blueprints = yield* Effect.promise(() => db.query(Filter.type(Blueprint.Blueprint)).run());
+      let defaultAssistantBlueprint = blueprints.find((blueprint) => blueprint.key === AssistantBlueprint.key);
+      if (!defaultAssistantBlueprint) {
+        defaultAssistantBlueprint = db.add(AssistantBlueprint.make());
+      }
+      let defaultDatabaseBlueprint = blueprints.find((blueprint) => blueprint.key === DatabaseBlueprint.key);
+      if (!defaultDatabaseBlueprint) {
+        defaultDatabaseBlueprint = db.add(DatabaseBlueprint.make());
+      }
+      let defaultProjectWizardBlueprint = blueprints.find((blueprint) => blueprint.key === ProjectWizardBlueprint.key);
+      if (!defaultProjectWizardBlueprint) {
+        defaultProjectWizardBlueprint = db.add(ProjectWizardBlueprint.make());
+      }
+      // Dynamic import to avoid circular dependency with the barrel that also exports BlueprintManagerHandlers.
+      const { BlueprintManagerBlueprint } = yield* Effect.promise(() => import('@dxos/assistant-toolkit'));
+      let defaultBlueprintManagerBlueprint = blueprints.find(
+        (blueprint) => blueprint.key === BlueprintManagerBlueprint.key,
+      );
+      if (!defaultBlueprintManagerBlueprint) {
+        defaultBlueprintManagerBlueprint = db.add(BlueprintManagerBlueprint.make());
+      }
+
+      const binder = new AiContextBinder({ queue, registry });
+      yield* Effect.promise(() =>
+        binder.use((b: AiContextBinder) =>
+          b.bind({
+            blueprints: [
+              Ref.make(defaultAssistantBlueprint!),
+              Ref.make(defaultDatabaseBlueprint!),
+              Ref.make(defaultProjectWizardBlueprint!),
+              Ref.make(defaultBlueprintManagerBlueprint!),
+            ],
+          }),
+        ),
+      );
+
+      return { object: chat };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/definitions.ts

@@ -0,0 +1,126 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Prompt } from '@dxos/blueprints';
+import { SpaceSchema } from '@dxos/client/echo';
+import { Collection, Database, DXN, Obj, Ref } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { meta } from '#meta';
+
+const ASSISTANT_OPERATION = `${meta.id}.operation`;
+
+export const OnCreateSpace = Operation.make({
+  meta: { key: `${ASSISTANT_OPERATION}.on-create-space`, name: 'On Create Space' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    space: SpaceSchema,
+    rootCollection: Collection.Collection,
+  }),
+  output: Schema.Void,
+});
+
+export const CreateChat = Operation.make({
+  meta: { key: `${ASSISTANT_OPERATION}.create-chat`, name: 'Create Chat' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    db: Database.Database,
+    name: Schema.optional(Schema.String),
+    /** If false, chat is created in-memory only and not added to space. Defaults to true. */
+    addToSpace: Schema.optional(Schema.Boolean),
+  }),
+  output: Schema.Struct({
+    object: Chat.Chat,
+  }),
+});
+
+export const UpdateChatName = Operation.make({
+  meta: { key: `${ASSISTANT_OPERATION}.update-chat-name`, name: 'Update Chat Name' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    chat: Chat.Chat,
+  }),
+  output: Schema.Void,
+});
+
+export const SetCurrentChat = Operation.make({
+  meta: { key: `${ASSISTANT_OPERATION}.set-current-chat`, name: 'Set Current Chat' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    companionTo: Obj.Unknown,
+    chat: Chat.Chat.pipe(Schema.optional),
+  }),
+  output: Schema.Void,
+});
+
+export const RunPromptInNewChat = Operation.make({
+  meta: { key: `${ASSISTANT_OPERATION}.run-prompt-in-new-chat`, name: 'Run Prompt In New Chat' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    db: Database.Database,
+    /** Context objects to bind to the new chat. */
+    objects: Schema.optional(Schema.Array(Obj.Unknown)),
+    /** Blueprint keys to look up and bind to the new chat. */
+    blueprints: Schema.optional(Schema.Array(Schema.String)),
+    /** Raw instructions or an existing Prompt object reference (e.g. from the prompts surface). */
+    prompt: Schema.Union(Schema.String, Ref.Ref(Prompt.Prompt)),
+    /**
+     * When true, skips opening the chat: runs the Agent prompt operation against the new chat via the compute runtime (traced).
+     */
+    background: Schema.optional(Schema.Boolean),
+  }),
+  output: Schema.Struct({
+    object: Chat.Chat,
+  }),
+});
+
+const NavigationTargetSchema = Schema.Struct({
+  path: Schema.String.annotations({ description: 'Navigation path to use with the Open operation.' }),
+  label: Schema.String.annotations({ description: 'Human-readable label.' }),
+  type: Schema.String.annotations({ description: 'Object type.' }),
+});
+
+export const ResolveNavigationTargets = Operation.make({
+  meta: {
+    key: `${ASSISTANT_OPERATION}.resolve-navigation-targets`,
+    name: 'Resolve navigation targets',
+    description:
+      'Resolve navigation targets within the application. The returned paths can be used with the Open operation. Without a query, returns pages that can be navigated to.',
+  },
+  input: Schema.Struct({
+    query: Schema.optional(
+      Schema.Struct({
+        dxn: DXN.Schema.pipe(Schema.optional),
+      }),
+    ),
+  }),
+  output: Schema.Struct({
+    targets: Schema.Array(NavigationTargetSchema),
+  }),
+  services: [Capability.Service],
+});
+
+export const EnsureCompanionChat = Operation.make({
+  meta: { key: `${ASSISTANT_OPERATION}.ensure-companion-chat`, name: 'Ensure Companion Chat' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    db: Database.Database,
+    companionTo: Obj.Unknown,
+  }),
+  output: Schema.Struct({
+    chat: Chat.Chat,
+    /** Whether the returned chat was already persisted in the space. */
+    persisted: Schema.Boolean,
+  }),
+});
+
+export const BlueprintForm = Schema.Struct({
+  key: Schema.String,
+  name: Schema.String,
+  description: Schema.optional(Schema.String),
+});

package/src/operations/ensure-companion-chat.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Filter, Obj, Query } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { AssistantCapabilities } from '../types';
+import { CreateChat, EnsureCompanionChat, SetCurrentChat } from './definitions';
+
+const handler: Operation.WithHandler<typeof EnsureCompanionChat> = EnsureCompanionChat.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ db, companionTo }) {
+      const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
+      const companionDxn = Obj.getDXN(companionTo).toString();
+
+      // 1. Look for an existing persisted companion chat in the space.
+      const existingChats = yield* Effect.promise(() =>
+        db.query(Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source()).run(),
+      );
+      if (existingChats.length > 0) {
+        const chat = existingChats.at(-1) as Chat.Chat;
+        yield* Capabilities.updateAtomValue(AssistantCapabilities.CompanionChatCache, (current) => {
+          const { [companionDxn]: _, ...rest } = current;
+          return rest;
+        });
+        yield* Effect.promise(() => operationInvoker.invokePromise(SetCurrentChat, { companionTo, chat }));
+        return { chat, persisted: true };
+      }
+
+      // 2. Return cached transient chat for this companion if present.
+      const cache = yield* Capabilities.getAtomValue(AssistantCapabilities.CompanionChatCache);
+      const cached = cache[companionDxn] as Chat.Chat | undefined;
+      if (cached) {
+        return { chat: cached, persisted: false };
+      }
+
+      // 3. Create a new transient chat, cache it, and return it without persisting.
+      const { data } = yield* Effect.promise(() =>
+        operationInvoker.invokePromise(CreateChat, { db, addToSpace: false }),
+      );
+      if (!data?.object) {
+        return yield* Effect.fail(new Error('CreateChat did not return a chat object'));
+      }
+      const chat = data.object;
+      yield* Capabilities.updateAtomValue(AssistantCapabilities.CompanionChatCache, (current) => ({
+        ...current,
+        [companionDxn]: chat,
+      }));
+      return { chat, persisted: false };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * as AssistantOperation from './definitions';
+
+export const AssistantOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./create-chat'),
+  () => import('./ensure-companion-chat'),
+  () => import('./on-create-space'),
+  () => import('./resolve-navigation-targets'),
+  () => import('./run-prompt-in-new-chat'),
+  () => import('./set-current-chat'),
+  () => import('./update-chat-name'),
+);

package/src/operations/on-create-space.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Operation } from '@dxos/operation';
+
+import { CreateChat, OnCreateSpace } from './definitions';
+
+const handler: Operation.WithHandler<typeof OnCreateSpace> = OnCreateSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ space }) {
+      // TODO(wittjosiah): Remove once function registry is avaiable.
+      space.db.add(Operation.serialize(AgentPrompt));
+
+      const { object: chat } = yield* Operation.invoke(CreateChat, { db: space.db });
+      space.db.add(chat);
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/resolve-navigation-targets.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/operation';
+
+import { ResolveNavigationTargets } from './definitions';
+
+export default ResolveNavigationTargets.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ query }) {
+      const capabilities = yield* Capability.Service;
+
+      // Delegate to contributed resolvers.
+      const resolvers = capabilities.getAll(AppCapabilities.NavigationTargetResolver);
+      const results = yield* Effect.forEach(resolvers, (resolver) =>
+        resolver(query as AppCapabilities.NavigationQuery).pipe(Effect.catchAll(() => Effect.succeed([]))),
+      );
+      return { targets: results.flat() };
+    }),
+  ),
+);

package/src/operations/run-prompt-in-new-chat.ts

@@ -0,0 +1,114 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { getObjectPathFromObject, LayoutOperation } from '@dxos/app-toolkit';
+import { AiContextBinder } from '@dxos/assistant';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Blueprint, Prompt, Template } from '@dxos/blueprints';
+import { Database, Feed, Filter, Obj, Ref } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
+import { invokeFunctionWithTracing } from '@dxos/plugin-automation/hooks';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { Text } from '@dxos/schema';
+
+import { AssistantCapabilities } from '../types';
+import { CreateChat, RunPromptInNewChat } from './definitions';
+
+const handler: Operation.WithHandler<typeof RunPromptInNewChat> = RunPromptInNewChat.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(
+      function* ({ db, prompt, objects, blueprints, background }) {
+        const registry = yield* Capability.get(Capabilities.AtomRegistry);
+        const { object: chat } = yield* Operation.invoke(CreateChat, { db });
+
+        if ((objects && objects.length > 0) || (blueprints && blueprints.length > 0)) {
+          const feedTarget = chat.feed.target;
+          invariant(feedTarget, 'Chat feed not found.');
+          const queueDxn = Feed.getQueueDxn(feedTarget);
+          invariant(queueDxn, 'Feed queue DXN not found.');
+          const client = yield* Capability.get(ClientCapabilities.Client);
+          const space = client.spaces.get(db.spaceId);
+          invariant(space, 'Space not found.');
+          const queue = space.queues.get(queueDxn);
+          const binder = new AiContextBinder({ queue, registry });
+          yield* Effect.promise(() =>
+            binder.use(async (b: AiContextBinder) => {
+              const bindingProps: Parameters<AiContextBinder['bind']>[0] = {};
+
+              if (objects && objects.length > 0) {
+                bindingProps.objects = objects.map((obj) => Ref.make(obj));
+              }
+
+              if (blueprints && blueprints.length > 0) {
+                const allBlueprints = await db.query(Filter.type(Blueprint.Blueprint)).run();
+                const matchedBlueprints = allBlueprints.filter(
+                  (blueprint) => blueprint.key && blueprints.includes(blueprint.key),
+                );
+                if (matchedBlueprints.length > 0) {
+                  bindingProps.blueprints = matchedBlueprints.map((blueprint) => Ref.make(blueprint));
+                }
+              }
+
+              await b.bind(bindingProps);
+            }),
+          );
+        }
+
+        if (background) {
+          const promptRef =
+            typeof prompt === 'string'
+              ? Ref.make(
+                  Prompt.make({
+                    instructions: prompt,
+                    blueprints: [],
+                    context: [],
+                  }),
+                )
+              : prompt;
+          yield* Database.flush();
+          const computeRuntime = yield* Capability.get(AutomationCapabilities.ComputeRuntime);
+          const runtime = yield* computeRuntime.getRuntime(db.spaceId).runtimeEffect;
+          yield* invokeFunctionWithTracing(AgentPrompt, {
+            prompt: promptRef,
+            input: {},
+            chat: Ref.make(chat),
+          }).pipe(
+            Effect.provide(runtime),
+            Effect.catchAll((error) => {
+              log.catch(error);
+              return Effect.void;
+            }),
+          );
+          return { object: chat };
+        }
+
+        const chatPath = getObjectPathFromObject(chat);
+        const pendingPromptText =
+          typeof prompt === 'string'
+            ? prompt
+            : yield* Effect.gen(function* () {
+                const promptObj = yield* Effect.promise(() => prompt.load());
+                const source = yield* Effect.promise(() => promptObj.instructions.source.load());
+                invariant(Obj.instanceOf(Text.Text, source), 'Prompt template source must be Text.');
+                return Template.process(source.content ?? '');
+              });
+        yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
+          ...current,
+          pendingPrompts: { ...current.pendingPrompts, [chatPath]: pendingPromptText },
+        }));
+        yield* Operation.invoke(LayoutOperation.Open, { subject: [chatPath] });
+        return { object: chat };
+      },
+      (effect, { db }) => effect.pipe(Effect.provide(Database.layer(db))),
+    ),
+  ),
+);
+
+export default handler;