@dxos/plugin-assistant 0.9.0 → 0.9.1-staging.ee54ba693a

package/dist/lib/neutral/hooks/index.mjs

@@ -1,42 +1,48 @@
 import {
   useChatContext
 } from "../chunk-VTK5R4H3.mjs";
+import {
+  AiChatProcessor,
+  defaultsKeyForProvider,
+  presetsForProvider,
+  resolveProvider
+} from "../chunk-BXI2R4OO.mjs";
 import "../chunk-J5LGTIGS.mjs";
 
-// src/hooks/useBlueprintRegistry.ts
+// src/hooks/useSkillRegistry.ts
 import { useCallback, useEffect, useMemo, useState } from "react";
-import { Blueprint } from "@dxos/compute";
+import { Skill } from "@dxos/compute";
 import { Filter, Obj, Ref } from "@dxos/echo";
 import { useQuery } from "@dxos/react-client/echo";
 import { distinctBy } from "@dxos/util";
-var useBlueprints = ({ registry, db }) => {
-  const [registryBlueprints, setRegistryBlueprints] = useState(() => registry?.query(Filter.type(Blueprint.Blueprint)).runSync() ?? []);
+var useSkills = ({ registry, db }) => {
+  const [registrySkills, setRegistrySkills] = useState(() => registry?.query(Filter.type(Skill.Skill)).runSync() ?? []);
   useEffect(() => {
     if (!registry) {
-      setRegistryBlueprints([]);
+      setRegistrySkills([]);
       return;
     }
-    setRegistryBlueprints(registry.query(Filter.type(Blueprint.Blueprint)).runSync());
+    setRegistrySkills(registry.query(Filter.type(Skill.Skill)).runSync());
     return registry.changed.on(() => {
-      setRegistryBlueprints(registry.query(Filter.type(Blueprint.Blueprint)).runSync());
+      setRegistrySkills(registry.query(Filter.type(Skill.Skill)).runSync());
     });
   }, [
     registry
   ]);
-  const spaceBlueprints = useQuery(db, Filter.type(Blueprint.Blueprint));
+  const spaceSkills = useQuery(db, Filter.type(Skill.Skill));
   return useMemo(() => {
-    const blueprints = distinctBy([
-      ...registryBlueprints,
-      ...spaceBlueprints
+    const skills = distinctBy([
+      ...registrySkills,
+      ...spaceSkills
     ], (b) => Obj.getMeta(b).key);
-    blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
-    return blueprints;
+    skills.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+    return skills;
   }, [
-    registryBlueprints,
-    spaceBlueprints
+    registrySkills,
+    spaceSkills
   ]);
 };
-var useActiveBlueprints = ({ context }) => {
+var useActiveSkills = ({ context }) => {
   const [active, setActive] = useState(/* @__PURE__ */ new Map());
   useEffect(() => {
     if (!context) {
@@ -44,58 +50,58 @@ var useActiveBlueprints = ({ context }) => {
       return;
     }
     const updateActive = () => {
-      const blueprints = context.getBlueprints();
-      setActive(new Map(blueprints.map((blueprint) => [
-        Obj.getMeta(blueprint).key,
-        blueprint
+      const skills = context.getSkills();
+      setActive(new Map(skills.map((skill) => [
+        Obj.getMeta(skill).key,
+        skill
       ]).filter((entry) => entry[0] !== void 0)));
     };
     updateActive();
-    return context.subscribeBlueprints(updateActive);
+    return context.subscribeSkills(updateActive);
   }, [
     context
   ]);
   return active;
 };
-var useBlueprintHandlers = ({ db, context, registry }) => {
-  const onUpdateBlueprint = useCallback(async (key, checked) => {
+var useSkillHandlers = ({ db, context, registry }) => {
+  const onUpdateSkill = useCallback(async (key, checked) => {
     if (!context) {
       return;
     }
     if (checked) {
-      const registryBlueprint = registry?.query(Filter.type(Blueprint.Blueprint)).runSync().find((b) => Obj.getMeta(b).key === key);
-      if (registryBlueprint) {
+      const registrySkill = registry?.query(Filter.type(Skill.Skill)).runSync().find((b) => Obj.getMeta(b).key === key);
+      if (registrySkill) {
         await context.bind({
-          blueprints: [
-            Ref.fromURI(Blueprint.registryURI(key))
+          skills: [
+            Ref.fromURI(Skill.registryURI(key))
           ]
         });
       } else {
-        const objects = await db.query(Filter.type(Blueprint.Blueprint)).run();
-        const storedBlueprint = objects.find((blueprint) => Obj.getMeta(blueprint).key === key);
-        if (storedBlueprint) {
+        const objects = await db.query(Filter.type(Skill.Skill)).run();
+        const storedSkill = objects.find((skill) => Obj.getMeta(skill).key === key);
+        if (storedSkill) {
           await context.bind({
-            blueprints: [
-              Ref.make(storedBlueprint)
+            skills: [
+              Ref.make(storedSkill)
             ]
           });
         }
       }
     } else {
-      const registryBlueprint = registry?.query(Filter.type(Blueprint.Blueprint)).runSync().find((b) => Obj.getMeta(b).key === key);
-      if (registryBlueprint) {
+      const registrySkill = registry?.query(Filter.type(Skill.Skill)).runSync().find((b) => Obj.getMeta(b).key === key);
+      if (registrySkill) {
         await context.unbind({
-          blueprints: [
-            Ref.fromURI(Blueprint.registryURI(key))
+          skills: [
+            Ref.fromURI(Skill.registryURI(key))
           ]
         });
       } else {
-        const objects = await db.query(Filter.type(Blueprint.Blueprint)).run();
-        const storedBlueprint = objects.find((blueprint) => Obj.getMeta(blueprint).key === key);
-        if (storedBlueprint) {
+        const objects = await db.query(Filter.type(Skill.Skill)).run();
+        const storedSkill = objects.find((skill) => Obj.getMeta(skill).key === key);
+        if (storedSkill) {
           await context.unbind({
-            blueprints: [
-              Ref.make(storedBlueprint)
+            skills: [
+              Ref.make(storedSkill)
             ]
           });
         }
@@ -107,7 +113,7 @@ var useBlueprintHandlers = ({ db, context, registry }) => {
     registry
   ]);
   return {
-    onUpdateBlueprint
+    onUpdateSkill
   };
 };
 
@@ -161,420 +167,32 @@ var useChatKeymapExtensions = ({ event }) => {
 
 // src/hooks/useChatProcessor.ts
 import { RegistryContext } from "@effect-atom/atom-react";
-import * as Effect2 from "effect/Effect";
+import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { useContext, useMemo as useMemo3, useState as useState2 } from "react";
 import { AiService, OpaqueToolkit } from "@dxos/ai";
 import { Capabilities } from "@dxos/app-framework";
 import { useCapability } from "@dxos/app-framework/ui";
 import { AiSession } from "@dxos/assistant";
-import { Credential, ServiceResolver } from "@dxos/compute";
-import { Database, Feed, Ref as Ref2, Registry } from "@dxos/echo";
-import { createFeedServiceLayer } from "@dxos/echo-client";
-import { EffectEx as EffectEx2 } from "@dxos/effect";
-import { AgentService as AgentService2 } from "@dxos/functions-runtime";
-import { log as log2 } from "@dxos/log";
-import { useAsyncEffect } from "@dxos/react-ui";
-
-// src/processor/presets.ts
-import * as Schema from "effect/Schema";
-var ModelProviders = [
-  "dxos-local",
-  "dxos-remote",
-  "lm-studio",
-  "ollama"
-];
-var ModelProvider = Schema.Literal(...ModelProviders);
-var createModelLabel = (model) => {
-  const parts = model.split(".");
-  return parts[parts.length - 1];
-};
-var AiServicePresets = [
-  // Sonnet is first so it is the default selection.
-  {
-    provider: "dxos-remote",
-    model: "ai.claude.model.claude-sonnet-4-6",
-    label: "Claude Sonnet"
-  },
-  {
-    provider: "dxos-remote",
-    model: "ai.claude.model.claude-opus-4-8",
-    label: "Claude Opus"
-  },
-  {
-    provider: "dxos-remote",
-    model: "ai.claude.model.claude-haiku-4-5",
-    label: "Claude Haiku"
-  },
-  {
-    provider: "ollama",
-    model: "ai.ollama.model.gpt-oss:20b"
-  },
-  {
-    provider: "ollama",
-    model: "ai.ollama.model.gemma4:latest"
-  },
-  {
-    provider: "lm-studio",
-    model: "ai.google.model.gemma-3-27b"
-  },
-  {
-    provider: "lm-studio",
-    model: "ai.meta.model.llama-3.2-3b-instruct"
-  },
-  {
-    model: "ai.ollama.model.deepseek-r1:latest",
-    provider: "dxos-local"
-  }
-].map(({ model, provider, label }, i) => ({
-  id: `preset-${i}`,
-  provider,
-  model,
-  label: label ?? createModelLabel(model)
-}));
-
-// src/processor/processor.ts
-import { Atom, Registry as AtomRegistry } from "@effect-atom/atom-react";
-import * as AiError from "@effect/ai/AiError";
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Fiber from "effect/Fiber";
-import * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
-import { DEFAULT_EDGE_MODEL } from "@dxos/ai";
-import { AiContext, createSystemPrompt, formatSystemPrompt, McpServerError, PartialBlock, ToolExecutionServices } from "@dxos/assistant";
-import { Operation, Trace } from "@dxos/compute";
-import { Obj as Obj2 } from "@dxos/echo";
+import { AgentService, Credential, ServiceResolver } from "@dxos/compute";
+import { Database, Obj as Obj2, Ref as Ref2, Registry } from "@dxos/echo";
 import { EffectEx } from "@dxos/effect";
-import { AgentService } from "@dxos/functions-runtime";
 import { log } from "@dxos/log";
-import { Message } from "@dxos/types";
-import { AssistantOperation } from "#types";
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/processor/processor.ts";
-var defaultOptions = {
-  model: DEFAULT_EDGE_MODEL
-};
-var parseError = (err) => {
-  let message;
-  if (AiError.isAiError(err)) {
-    message = err.description?.trim() || err.message;
-  } else if (typeof err === "string") {
-    const [, model] = err.match(/model\s+'([^']+)'\s+not\s+found/i) || [];
-    if (model) {
-      message = `The model is not available: ${model}`;
-    }
-  }
-  if (!message) {
-    message = "An unexpected error occurred.";
-  }
-  return new Error(message, {
-    cause: err
-  });
-};
-var AiChatProcessor = class {
-  _conversation;
-  _runtime;
-  _feed;
-  _spaceLayer;
-  _options;
-  #registry;
-  /** Pending messages (finalized, non-streaming). */
-  #pending = Atom.make([]);
-  /** Currently streaming messages (from ephemeral trace events). */
-  #streaming = Atom.make([]);
-  /** Set of message IDs that have been finalized (non-pending delivered via ephemeral). */
-  #finalizedIds = /* @__PURE__ */ new Set();
-  /** Currently active request fiber. */
-  #requestFiber;
-  /** Last request (for retries). */
-  #lastRequest;
-  /** Streaming state. */
-  streaming = Atom.make((get) => get(this.#streaming).length > 0);
-  /** Active state. */
-  active = Atom.make(false);
-  /** Array of Messages (incl. the current message being streamed). */
-  messages = Atom.make((get) => [
-    ...get(this.#pending),
-    ...get(this.#streaming)
-  ]);
-  /** Last error. */
-  error = Atom.make(Option.none());
-  /**
-  * MCP server connection errors observed during the most recent request.
-  * Misconfigured/unreachable servers are dropped from the toolkit so the chat
-  * keeps working; the entries here let the UI display which servers failed.
-  */
-  mcpErrors = Atom.make([]);
-  constructor(_conversation, _runtime, _feed, _spaceLayer, _options = defaultOptions) {
-    this._conversation = _conversation;
-    this._runtime = _runtime;
-    this._feed = _feed;
-    this._spaceLayer = _spaceLayer;
-    this._options = _options;
-    this.#registry = this._options.observableRegistry ?? AtomRegistry.make();
-    if (this._options.model && !this._options.system) {
-      const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
-      this._options.system = createSystemPrompt(capabilities);
-    }
-  }
-  get context() {
-    return this._conversation.context;
-  }
-  get conversation() {
-    return this._conversation;
-  }
-  get registry() {
-    return this._options.registry;
-  }
-  get system() {
-    return this._options.system ?? "";
-  }
-  async getTools() {
-    return this._runtime.runPromise(Effect.provide(this._conversation.getTools(), ToolExecutionServices).pipe(Effect.provide(this._spaceLayer)));
-  }
-  async getSystemPrompt() {
-    return this._runtime.runPromise(Effect.gen(this, function* () {
-      const blueprints = this.context.getBlueprints();
-      const objects = this.context.getObjects();
-      return yield* formatSystemPrompt({
-        system: this._options.system,
-        blueprints,
-        objects
-      });
-    }).pipe(Effect.provideService(AiContext.Service, {
-      binder: this.context
-    }), Effect.provide(this._spaceLayer), Effect.orDie));
-  }
-  /**
-  * Initiates a new request via AgentService.
-  */
-  async request(requestProp) {
-    if (this.#requestFiber) {
-      await this.cancel();
-    }
-    try {
-      this.#lastRequest = requestProp;
-      this.#registry.set(this.error, Option.none());
-      this.#registry.set(this.mcpErrors, []);
-      this.#registry.set(this.active, true);
-      const effect = Effect.gen(this, function* () {
-        log.info("init agent session", {
-          feed: Obj2.getURI(this._feed),
-          model: this._options.model
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 136, S: this });
-        const session = yield* AgentService.getSession(this._feed, {
-          model: this._options.model
-        });
-        const ephemeralStream = session.subscribeEphemeral();
-        yield* ephemeralStream.pipe(Stream.runForEach((message) => Effect.sync(() => {
-          for (const event of message.events) {
-            if (Trace.isOfType(PartialBlock, event)) {
-              this.#handleEphemeralMessage(event.data);
-            } else if (Trace.isOfType(McpServerError, event)) {
-              this.#handleMcpError(event.data);
-            }
-          }
-        })), Effect.fork);
-        log("chat processor submitting prompt", {
-          length: requestProp.message.length
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 153, S: this });
-        yield* session.submitPrompt(requestProp.message);
-        log("chat processor submitPrompt returned, waiting for agent", {}, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 157, S: this });
-        if (!this._options.chat?.target?.name) {
-          yield* this.#updateChatName(requestProp.message);
-        }
-        yield* session.waitForCompletion();
-        log.info("session complete", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 164, S: this });
-        this.#flushStreaming();
-      });
-      this.#requestFiber = this._runtime.runFork(effect.pipe(Effect.provide(this._spaceLayer)));
-      const exit = await this._runtime.runPromise(Fiber.await(this.#requestFiber));
-      if (Exit.isFailure(exit)) {
-        if (Cause.isInterruptedOnly(exit.cause)) {
-          return;
-        }
-        throw EffectEx.causeToError(exit.cause);
-      }
-      this.#registry.set(this.error, Option.none());
-      this.#lastRequest = void 0;
-      this.#requestFiber = void 0;
-    } catch (err) {
-      log.error("request failed", {
-        error: err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 183, S: this });
-      this.#registry.set(this.error, Option.some(parseError(err)));
-    } finally {
-      log.info("setting active to false", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 188, S: this });
-      this.#registry.set(this.active, false);
-      this.#requestFiber = void 0;
-    }
-  }
-  /**
-  * Cancels the current request.
-  */
-  async cancel() {
-    await EffectEx.runAndForwardErrors(Effect.gen(this, function* () {
-      log.info("cancelling request", {
-        fiber: this.#requestFiber
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 197, S: this });
-      if (this.#requestFiber) {
-        yield* Fiber.interrupt(this.#requestFiber);
-      }
-      const session = yield* AgentService.getSession(this._feed);
-      yield* session.terminate();
-    }).pipe(Effect.provide(this._spaceLayer)));
-    this.#requestFiber = void 0;
-    this.#registry.set(this.active, false);
-  }
-  /**
-  * Retry last failed request.
-  */
-  async retry() {
-    if (this.#lastRequest) {
-      return this.request(this.#lastRequest);
-    }
-  }
-  /**
-  * Clears the recorded MCP server errors (e.g. after the user dismisses the warning banner).
-  */
-  dismissMcpErrors() {
-    this.#registry.set(this.mcpErrors, []);
-  }
-  /**
-  * Update the current chat's name.
-  */
-  async updateName(chat) {
-    const spaceId = Obj2.getDatabase(chat)?.spaceId;
-    if (!spaceId) {
-      return;
-    }
-    EffectEx.unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(AssistantOperation.UpdateChatName, {
-      chat
-    }, {
-      spaceId
-    }).pipe(Effect.provide(this._spaceLayer))));
-  }
-  /**
-  * Handles an ephemeral message from the agent process.
-  * Both pending and completed blocks arrive here. Completed blocks are deduped
-  * against messages already written to the feed queue to handle the race between
-  * ephemeral delivery and feed replication.
-  */
-  #handleEphemeralMessage(event) {
-    const isPending = event.block.pending;
-    const message = Obj2.make(Message.Message, {
-      id: event.messageId,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      sender: {
-        role: event.role
-      },
-      blocks: [
-        event.block
-      ]
-    });
-    if (isPending) {
-      if (this.#finalizedIds.has(event.messageId)) {
-        return;
-      }
-      this.#registry.update(this.#streaming, (streaming) => {
-        const idx = streaming.findIndex((existing) => existing.id === event.messageId);
-        if (idx >= 0) {
-          const updated = [
-            ...streaming
-          ];
-          updated[idx] = message;
-          return updated;
-        }
-        return [
-          ...streaming,
-          message
-        ];
-      });
-    } else {
-      this.#finalizedIds.add(event.messageId);
-      this.#registry.update(this.#streaming, (streaming) => streaming.filter((existing) => existing.id !== message.id));
-      this.#registry.update(this.#pending, (pending) => {
-        if (pending.some((existing) => existing.id === message.id)) {
-          return pending;
-        }
-        return [
-          ...pending,
-          message
-        ];
-      });
-    }
-  }
-  /**
-  * Records a per-server MCP failure, deduped by url+protocol so repeat misconfigurations
-  * across turns do not spam the UI.
-  */
-  #handleMcpError(event) {
-    log.warn("MCP server error", event, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 287, S: this });
-    this.#registry.update(this.mcpErrors, (errors) => {
-      if (errors.some((existing) => existing.url === event.url && existing.protocol === event.protocol)) {
-        return errors;
-      }
-      return [
-        ...errors,
-        event
-      ];
-    });
-  }
-  /**
-  * Move remaining streaming messages to pending (called when agent completes).
-  */
-  #flushStreaming() {
-    const remaining = this.#registry.get(this.#streaming);
-    if (remaining.length > 0) {
-      this.#registry.update(this.#pending, (pending) => [
-        ...pending,
-        ...remaining
-      ]);
-      this.#registry.set(this.#streaming, []);
-    }
-    this.#finalizedIds.clear();
-  }
-  /**
-  * Schedule a chat name update as a detached (fire-and-forget) operation.
-  * Called automatically on the first message; can also be invoked manually via the toolbar.
-  */
-  #updateChatName(prompt) {
-    const chat = this._options.chat?.target;
-    if (!chat) {
-      return Effect.void;
-    }
-    const spaceId = Obj2.getDatabase(chat)?.spaceId;
-    if (!spaceId) {
-      return Effect.void;
-    }
-    log.info("scheduling chat name update", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 323, S: this });
-    return Operation.schedule(AssistantOperation.UpdateChatName, {
-      chat,
-      prompt
-    }, {
-      spaceId
-    });
-  }
-};
-
-// src/hooks/useChatProcessor.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
+import { useObject } from "@dxos/react-client/echo";
+import { useAsyncEffect } from "@dxos/react-ui";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatProcessor.ts";
 var useChatProcessor = ({ space, chat, preset, runtime: runtime3, registry, settings }) => {
   const observableRegistry = useContext(RegistryContext);
+  const [feedSnapshot] = useObject(chat?.feed);
+  const feed = Obj2.getReactiveOrUndefined(feedSnapshot);
   const [session, setSession] = useState2();
   useAsyncEffect(async () => {
-    if (!space || !chat) {
-      return;
-    }
-    const feedTarget = chat.feed.target;
-    if (!feedTarget) {
+    if (!space || !chat || !feed) {
       return;
     }
-    const feedServiceLayer = createFeedServiceLayer(space.queues);
-    const runtime4 = await EffectEx2.runAndForwardErrors(Effect2.runtime().pipe(Effect2.provide(feedServiceLayer)));
+    const runtime4 = await EffectEx.runAndForwardErrors(Effect.runtime().pipe(Effect.provide(Database.layer(space.db))));
     const session2 = new AiSession.Session({
-      feed: feedTarget,
+      feed,
       runtime: runtime4,
       registry: observableRegistry
     });
@@ -586,9 +204,9 @@ var useChatProcessor = ({ space, chat, preset, runtime: runtime3, registry, sett
     };
   }, [
     space,
-    chat?.feed.target
+    chat,
+    feed
   ]);
-  const feed = chat?.feed.target;
   const serviceResolver = useCapability(Capabilities.ServiceResolver);
   const processor = useMemo3(() => {
     if (!runtime3 || !session || !chat || !feed || !space) {
@@ -596,17 +214,18 @@ var useChatProcessor = ({ space, chat, preset, runtime: runtime3, registry, sett
     }
     const spaceLayer = ServiceResolver.provide({
       space: space.id
-    }, Database.Service, Feed.FeedService, Credential.CredentialsService, AiService.AiService, AgentService2.AgentService, Registry.Service, OpaqueToolkit.OpaqueToolkitProvider).pipe(Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, serviceResolver)));
-    log2("creating processor", {
+    }, Database.Service, Credential.CredentialsService, AiService.AiService, AgentService.AgentService, Registry.Service, OpaqueToolkit.OpaqueToolkitProvider).pipe(Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, serviceResolver)));
+    log("creating processor", {
       preset,
       model: preset?.model,
       settings
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 59, S: void 0 });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 56, S: void 0 });
     return new AiChatProcessor(session, runtime3, feed, spaceLayer, {
       chat: chat ? Ref2.make(chat) : void 0,
       observableRegistry,
       registry,
-      model: preset?.model
+      model: preset?.model,
+      provider: preset?.provider
     });
   }, [
     runtime3,
@@ -623,26 +242,26 @@ var useChatProcessor = ({ space, chat, preset, runtime: runtime3, registry, sett
 // src/hooks/useChatServices.ts
 import { Capabilities as Capabilities2 } from "@dxos/app-framework";
 import { useCapability as useCapability2 } from "@dxos/app-framework/ui";
-import { getPersonalSpace } from "@dxos/app-toolkit";
+import { AppSpace } from "@dxos/app-toolkit";
 import { useClient } from "@dxos/react-client";
 var useChatServices = ({ id }) => {
   const client = useClient();
-  id ??= getPersonalSpace(client)?.id;
+  id ??= AppSpace.getPersonalSpace(client)?.id;
   const runtime3 = useCapability2(Capabilities2.ProcessManagerRuntime);
   return id ? runtime3 : void 0;
 };
 
 // src/hooks/useChatToolbarActions.ts
-import * as Effect3 from "effect/Effect";
+import * as Effect2 from "effect/Effect";
 import { useOperationInvoker } from "@dxos/app-framework/ui";
 import { Chat } from "@dxos/assistant-toolkit";
 import { Filter as Filter2, Obj as Obj3, Query, Type } from "@dxos/echo";
-import { EffectEx as EffectEx3 } from "@dxos/effect";
+import { EffectEx as EffectEx2 } from "@dxos/effect";
 import { invariant } from "@dxos/invariant";
 import { MenuBuilder, useMenuBuilder } from "@dxos/react-ui-menu";
 import { meta } from "#meta";
-import { AssistantOperation as AssistantOperation2 } from "#types";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatToolbarActions.ts";
+import { AssistantOperation } from "#types";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/hooks/useChatToolbarActions.ts";
 var useChatToolbarActions = ({ chat, companionTo }) => {
   const { invoke } = useOperationInvoker();
   const { db } = useChatContext("useChatToolbarActions");
@@ -652,67 +271,67 @@ var useChatToolbarActions = ({ chat, companionTo }) => {
       label: [
         "chat-toolbar.title",
         {
-          ns: meta.id
+          ns: meta.profile.key
         }
       ]
     }).action("new", {
       label: [
         "new-thread.button",
         {
-          ns: meta.id
+          ns: meta.profile.key
         }
       ],
       icon: "ph--plus--regular",
       type: "new",
       disabled: !companionTo
     }, () => {
-      invariant(companionTo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 38, S: void 0, A: ["companionTo", ""] });
-      return invoke(AssistantOperation2.SetCurrentChat, {
+      invariant(companionTo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 38, S: void 0, A: ["companionTo", ""] });
+      return invoke(AssistantOperation.SetCurrentChat, {
         companionTo,
         chat: void 0
-      }).pipe(EffectEx3.runAndForwardErrors);
+      }).pipe(EffectEx2.runAndForwardErrors);
     }).action("rename", {
       label: [
         "rename-thread.button",
         {
-          ns: meta.id
+          ns: meta.profile.key
         }
       ],
       icon: "ph--magic-wand--regular",
       type: "rename",
       disabled: !chat
-    }, () => Effect3.gen(function* () {
-      invariant(chat, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 54, S: this, A: ["chat", ""] });
-      yield* invoke(AssistantOperation2.UpdateChatName, {
+    }, () => Effect2.gen(function* () {
+      invariant(chat, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 54, S: this, A: ["chat", ""] });
+      yield* invoke(AssistantOperation.UpdateChatName, {
         chat
       }, {
         spaceId: db?.spaceId
       });
-    }).pipe(EffectEx3.runAndForwardErrors)).action("branch", {
+    }).pipe(EffectEx2.runAndForwardErrors)).action("branch", {
       label: [
         "branch-thread.menu",
         {
-          ns: meta.id
+          ns: meta.profile.key
         }
       ],
       icon: "ph--git-branch--regular",
       type: "branch",
       disabled: !chat || !db
-    }, () => Effect3.gen(function* () {
-      invariant(chat, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 71, S: this, A: ["chat", ""] });
-      yield* invoke(AssistantOperation2.ForkChat, {
+    }, () => Effect2.gen(function* () {
+      invariant(chat, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 71, S: this, A: ["chat", ""] });
+      yield* invoke(AssistantOperation.ForkChat, {
         chat,
         companionTo
       }, {
         spaceId: db?.spaceId
       });
-    }).pipe(EffectEx3.runAndForwardErrors));
+    }).pipe(EffectEx2.runAndForwardErrors));
     if (chats.length > 0) {
       builder.group("chats", {
         label: [
           "chat-history.label",
           {
-            ns: meta.id
+            ns: meta.profile.key
           }
         ],
         icon: "ph--clock-counter-clockwise--regular",
@@ -728,13 +347,13 @@ var useChatToolbarActions = ({ chat, companionTo }) => {
                 ns: Type.getTypename(Chat.Chat)
               }
             ]
-          }, () => Effect3.gen(function* () {
-            invariant(companionTo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 102, S: this, A: ["companionTo", ""] });
-            yield* invoke(AssistantOperation2.SetCurrentChat, {
+          }, () => Effect2.gen(function* () {
+            invariant(companionTo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 102, S: this, A: ["companionTo", ""] });
+            yield* invoke(AssistantOperation.SetCurrentChat, {
               companionTo,
               chat: chat2
             });
-          }).pipe(EffectEx3.runAndForwardErrors));
+          }).pipe(EffectEx2.runAndForwardErrors));
         });
       });
     }
@@ -749,11 +368,11 @@ var useChatToolbarActions = ({ chat, companionTo }) => {
 
 // src/hooks/useContextBinder.ts
 import { RegistryContext as RegistryContext2 } from "@effect-atom/atom-react";
-import * as Effect4 from "effect/Effect";
+import * as Effect3 from "effect/Effect";
 import { useContext as useContext2, useState as useState3 } from "react";
-import { AiContext as AiContext2 } from "@dxos/assistant";
-import { createFeedServiceLayer as createFeedServiceLayer2 } from "@dxos/echo-client";
-import { EffectEx as EffectEx4 } from "@dxos/effect";
+import { AiContext } from "@dxos/assistant";
+import { Database as Database2 } from "@dxos/echo";
+import { EffectEx as EffectEx3 } from "@dxos/effect";
 import { useAsyncEffect as useAsyncEffect2 } from "@dxos/react-ui";
 var useContextBinder = (space, feed) => {
   const registry = useContext2(RegistryContext2);
@@ -763,9 +382,8 @@ var useContextBinder = (space, feed) => {
     if (!space || !feed) {
       return;
     }
-    const feedServiceLayer = createFeedServiceLayer2(space.queues);
-    const runtime3 = await EffectEx4.runAndForwardErrors(Effect4.runtime().pipe(Effect4.provide(feedServiceLayer)));
-    const binder2 = new AiContext2.Binder({
+    const runtime3 = await EffectEx3.runAndForwardErrors(Effect3.runtime().pipe(Effect3.provide(Database2.layer(space.db))));
+    const binder2 = new AiContext.Binder({
       feed,
       runtime: runtime3,
       registry
@@ -783,9 +401,9 @@ var useContextBinder = (space, feed) => {
 };
 
 // src/hooks/useContextObjects.ts
-import { Atom as Atom2, useAtomValue } from "@effect-atom/atom-react";
+import { Atom, useAtomValue } from "@effect-atom/atom-react";
 import { useCallback as useCallback2 } from "react";
-var emptyObjectsAtom = Atom2.make([]);
+var emptyObjectsAtom = Atom.make([]);
 var useContextObjects = ({ db, context }) => {
   const objects = useAtomValue(context?.objects ?? emptyObjectsAtom);
   const handleUpdateObject = useCallback2(async (dxn, checked) => {
@@ -823,12 +441,12 @@ import { trim } from "@dxos/util";
 var useDebug = ({ processor }) => {
   return useCallback3(async () => {
     const objects = processor.context.getObjects();
-    const blueprints = processor.context.getBlueprints();
+    const skills = processor.context.getSkills();
     const system = await processor.getSystemPrompt();
     const tools = await processor.getTools() ?? {};
     console.group("Chat", {
       objects,
-      blueprints
+      skills
     });
     try {
       console.log(trim`
@@ -848,12 +466,12 @@ var useDebug = ({ processor }) => {
 };
 
 // src/hooks/useFilteredTypes.ts
-import * as Option2 from "effect/Option";
+import * as Option from "effect/Option";
 import { useEffect as useEffect2, useState as useState4 } from "react";
 import { Type as Type2 } from "@dxos/echo";
 import { HiddenAnnotation, getTypeAnnotation } from "@dxos/echo/Annotation";
 import { Kind as EntityKind } from "@dxos/echo/Entity";
-var getFilteredTypes = (db) => Array.from(new Set(db.graph.registry.list().filter(Type2.isType).filter((schema) => getTypeAnnotation(Type2.getSchema(schema))?.kind !== EntityKind.Relation).filter((schema) => !HiddenAnnotation.get(Type2.getSchema(schema)).pipe(Option2.getOrElse(() => false)))));
+var getFilteredTypes = (db) => Array.from(new Set(db.graph.registry.list().filter(Type2.isType).filter((schema) => getTypeAnnotation(Type2.getSchema(schema))?.kind !== EntityKind.Relation).filter((schema) => !HiddenAnnotation.get(Type2.getSchema(schema)).pipe(Option.getOrElse(() => false)))));
 var useFilteredTypes = (db) => {
   const [types, setTypes] = useState4([]);
   useEffect2(() => {
@@ -900,22 +518,45 @@ var useFlush = (space) => {
   };
 };
 
-// src/hooks/useOnline.ts
-import { useState as useState6 } from "react";
-var useOnline = () => {
-  const [online, setOnline] = useState6(true);
-  return [
-    online,
-    setOnline
-  ];
-};
-
 // src/hooks/usePresets.ts
-import { useCallback as useCallback5, useEffect as useEffect3, useMemo as useMemo4, useState as useState7 } from "react";
-var usePresets = (online) => {
-  const [preset, setPreset] = useState7();
-  const presets = useMemo4(() => AiServicePresets.filter((preset2) => online === (preset2.provider === "dxos-remote")), [
-    online
+import { useAtomValue as useAtomValue2 } from "@effect-atom/atom-react";
+import { useCallback as useCallback5, useEffect as useEffect3, useMemo as useMemo4, useState as useState6 } from "react";
+import { Provider } from "@dxos/ai";
+import { useOptionalCapability } from "@dxos/app-framework/ui";
+import { EffectEx as EffectEx4 } from "@dxos/effect";
+import { AssistantCapabilities, Ollama } from "#types";
+var usePresets = (settings) => {
+  const [preset, setPreset] = useState6();
+  const ollamaManager = useOptionalCapability(AssistantCapabilities.OllamaManager);
+  const provider = resolveProvider(settings.modelProvider, !!ollamaManager);
+  const defaultModel = settings.modelDefaults?.[defaultsKeyForProvider(provider)];
+  const localModels = useAtomValue2(ollamaManager?.state ?? Ollama.emptyState);
+  useEffect3(() => {
+    if (provider === Provider.builtIn.id && ollamaManager && localModels.kind === "idle") {
+      void EffectEx4.runPromise(ollamaManager.refresh);
+    }
+  }, [
+    provider,
+    ollamaManager,
+    localModels.kind
+  ]);
+  const lmStudioProbeUrl = provider === Provider.lmStudio.id && ollamaManager ? `${Provider.lmStudio.endpoint}/v1/models` : void 0;
+  const lmStudioReachable = useEndpointReachable(lmStudioProbeUrl);
+  const presets = useMemo4(() => {
+    const base = presetsForProvider(provider);
+    if (provider === Provider.lmStudio.id && ollamaManager) {
+      return lmStudioReachable ? base : [];
+    }
+    if (provider === Provider.builtIn.id && ollamaManager) {
+      const installed = new Set(localModels.models.map((model) => model.name));
+      return base.filter((preset2) => installed.has(preset2.backend));
+    }
+    return base;
+  }, [
+    provider,
+    ollamaManager,
+    lmStudioReachable,
+    localModels
   ]);
   const presetOptions = useMemo4(() => presets.map(({ id, model, label }) => ({
     id,
@@ -924,9 +565,11 @@ var usePresets = (online) => {
     presets
   ]);
   useEffect3(() => {
-    setPreset(presets[0]);
+    const configured = defaultModel ? presets.find((preset2) => preset2.model === defaultModel) : void 0;
+    setPreset(configured ?? presets[0]);
   }, [
-    presets
+    presets,
+    defaultModel
   ]);
   const handlePresetChange = useCallback5((id) => {
     const preset2 = presets.find((preset3) => preset3.id === id);
@@ -942,6 +585,29 @@ var usePresets = (online) => {
     onPresetChange: handlePresetChange
   };
 };
+var useEndpointReachable = (url) => {
+  const [reachable, setReachable] = useState6(false);
+  useEffect3(() => {
+    if (!url) {
+      setReachable(false);
+      return;
+    }
+    let active = true;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+    fetch(url, {
+      signal: controller.signal
+    }).then((response) => active && setReachable(response.ok)).catch(() => active && setReachable(false)).finally(() => clearTimeout(timer));
+    return () => {
+      active = false;
+      controller.abort();
+      clearTimeout(timer);
+    };
+  }, [
+    url
+  ]);
+  return reachable;
+};
 
 // src/hooks/useReferencesProvider.ts
 import { useMemo as useMemo5 } from "react";
@@ -972,10 +638,225 @@ var useReferencesProvider = (space) => {
   ]);
 };
 var stringMatch = (query, label) => label.toLowerCase().startsWith(query.toLowerCase());
+
+// src/hooks/useTraceMessages.ts
+import { Atom as Atom2 } from "@effect-atom/atom";
+import { useAtomValue as useAtomValue3 } from "@effect-atom/atom-react";
+import { pipe } from "effect/Function";
+import { useMemo as useMemo6 } from "react";
+import { Trace } from "@dxos/compute";
+import { Filter as Filter4, Query as Query2 } from "@dxos/echo";
+import { FeedTraceSink } from "@dxos/functions-runtime";
+var atomEmpty = Atom2.make(() => []);
+var getTraceMessagesAtom = (space) => pipe(space.db.query(FeedTraceSink.query).atom, Atom2.map((feeds) => (
+  // TODO(dmaretskyi): Single query with limit(1) and feed traversal when query supports it.
+  space.db.query(feeds.length > 0 ? Query2.type(Trace.Message).from(feeds[0]) : Query2.select(Filter4.nothing())).atom
+)), (atom) => Atom2.make((get) => get(get(atom))));
+var useTraceMessages = (space) => {
+  const atom = useMemo6(() => space ? getTraceMessagesAtom(space) : atomEmpty, [
+    space
+  ]);
+  return useAtomValue3(atom);
+};
+
+// src/hooks/useHomeSuggestions.ts
+import { useMemo as useMemo7, useState as useState7 } from "react";
+import { useOperationInvoker as useOperationInvoker2 } from "@dxos/app-framework/ui";
+import { useAsyncEffect as useAsyncEffect3, useTranslation } from "@dxos/react-ui";
+import { meta as meta2 } from "#meta";
+import { AssistantOperation as AssistantOperation2 } from "#types";
+var FALLBACK_SUGGESTION_KEYS = [
+  "space-home.suggestion-magazine.label",
+  "space-home.suggestion-spreadsheet.label",
+  "space-home.suggestion-kanban.label"
+];
+var useHomeSuggestions = (space) => {
+  const { t } = useTranslation(meta2.profile.key);
+  const { invokePromise } = useOperationInvoker2();
+  const fallbacks = useMemo7(() => FALLBACK_SUGGESTION_KEYS.map((key) => t(key, {
+    year: (/* @__PURE__ */ new Date()).getFullYear()
+  })), [
+    t
+  ]);
+  const [suggestions, setSuggestions] = useState7(void 0);
+  useAsyncEffect3(async (controller) => {
+    setSuggestions(void 0);
+    if (!space) {
+      return;
+    }
+    const result = await invokePromise(AssistantOperation2.GenerateHomeSuggestions, {
+      db: space.db
+    }, {
+      spaceId: space.db.spaceId
+    });
+    if (controller.signal.aborted) {
+      return;
+    }
+    const prompts = result.data?.prompts;
+    setSuggestions(prompts && prompts.length > 0 ? prompts : fallbacks);
+  }, [
+    space,
+    invokePromise
+  ]);
+  return suggestions;
+};
+
+// src/hooks/useProcessEphemeralStatus.ts
+import { Atom as Atom3 } from "@effect-atom/atom";
+import { useAtomValue as useAtomValue4 } from "@effect-atom/atom-react";
+import * as Effect4 from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Stream from "effect/Stream";
+import { useEffect as useEffect4, useMemo as useMemo8, useRef as useRef2, useState as useState8 } from "react";
+import { Capabilities as Capabilities3 } from "@dxos/app-framework";
+import { useOptionalCapability as useOptionalCapability2 } from "@dxos/app-framework/ui";
+import { Process, ServiceResolver as ServiceResolver2 } from "@dxos/compute";
+import { ProcessManager } from "@dxos/compute-runtime";
+import { resolveEphemeralStatusUpdate } from "#execution-graph";
+var atomEmpty2 = Atom3.make(() => []);
+var ACTIVE_PROCESS_STATES = /* @__PURE__ */ new Set([
+  Process.State.RUNNING,
+  Process.State.HYBERNATING
+]);
+var isTerminalActivityLine = (line) => line.endsWith(" - Success") || line.endsWith(" - Error") || line === "Agent completed request";
+var collectDescendantPids = (processes, rootPid) => {
+  const pids = /* @__PURE__ */ new Set([
+    rootPid
+  ]);
+  let expanded = true;
+  while (expanded) {
+    expanded = false;
+    for (const process of processes) {
+      const pid = String(process.pid);
+      const parentPid = process.parentPid ? String(process.parentPid) : void 0;
+      if (parentPid && pids.has(parentPid) && !pids.has(pid)) {
+        pids.add(pid);
+        expanded = true;
+      }
+    }
+  }
+  return pids;
+};
+var resolveSubscribePids = (agentPid, processes) => {
+  const rootPid = String(agentPid);
+  const descendants = collectDescendantPids(processes, rootPid);
+  const activePids = processes.filter((process) => descendants.has(String(process.pid)) && ACTIVE_PROCESS_STATES.has(process.state)).map((process) => process.pid);
+  if (activePids.length > 0) {
+    return activePids;
+  }
+  return [
+    agentPid
+  ];
+};
+var attachActiveHandle = (processManager, pid) => Effect4.gen(function* () {
+  const maxAttempts = 15;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const handle = yield* processManager.attach(pid).pipe(Effect4.catchAll(() => Effect4.succeed(void 0)));
+    if (handle && ACTIVE_PROCESS_STATES.has(handle.status.state)) {
+      return handle;
+    }
+    if (handle) {
+      return void 0;
+    }
+    yield* Effect4.sleep(100);
+  }
+  return void 0;
+});
+var useProcessEphemeralStatus = (agentPid, space) => {
+  const runtime3 = useOptionalCapability2(Capabilities3.ProcessManagerRuntime);
+  const monitor = useOptionalCapability2(Capabilities3.ProcessMonitor);
+  const processes = useAtomValue4(monitor?.processTreeAtom ?? atomEmpty2);
+  const [status, setStatus] = useState8();
+  const fibersRef = useRef2([]);
+  const subscribePidsKey = useMemo8(() => {
+    if (!agentPid) {
+      return "";
+    }
+    return resolveSubscribePids(agentPid, processes).map((pid) => String(pid)).sort().join("|");
+  }, [
+    agentPid,
+    processes
+  ]);
+  useEffect4(() => {
+    if (!agentPid || !space?.id || !runtime3 || !subscribePidsKey) {
+      setStatus(void 0);
+      return;
+    }
+    const pids = subscribePidsKey.split("|").map((pid) => Process.ID.make(pid));
+    let disposed = false;
+    let replaying = true;
+    let replayStatus;
+    const endReplay = () => {
+      replaying = false;
+      if (!disposed) {
+        setStatus(replayStatus);
+      }
+    };
+    queueMicrotask(endReplay);
+    fibersRef.current = [];
+    const handleEphemeralMessage = (message) => {
+      const update = resolveEphemeralStatusUpdate(message);
+      if (update === "unchanged") {
+        return;
+      }
+      if (replaying) {
+        replayStatus = update.line;
+        return;
+      }
+      setStatus(update.line);
+    };
+    const layer = ServiceResolver2.provide({
+      space: space.id
+    }, ProcessManager.ProcessManagerService);
+    const subscribe = (pid) => Effect4.gen(function* () {
+      if (disposed) {
+        return;
+      }
+      const processManager = yield* ProcessManager.ProcessManagerService;
+      const handle = yield* attachActiveHandle(processManager, pid);
+      if (!handle || disposed) {
+        return;
+      }
+      const fiber = yield* handle.subscribeEphemeral().pipe(Stream.runForEach((message) => Effect4.sync(() => {
+        if (disposed) {
+          return;
+        }
+        handleEphemeralMessage(message);
+      })), Effect4.forkDaemon);
+      if (disposed) {
+        yield* Fiber.interrupt(fiber);
+        return;
+      }
+      fibersRef.current.push(fiber);
+    });
+    void runtime3.runPromise(Effect4.forEach(pids, subscribe, {
+      concurrency: "unbounded",
+      discard: true
+    }).pipe(Effect4.provide(layer))).catch(() => {
+      if (!disposed) {
+        setStatus(void 0);
+      }
+    });
+    return () => {
+      disposed = true;
+      const fibers = fibersRef.current;
+      fibersRef.current = [];
+      for (const fiber of fibers) {
+        void runtime3.runPromise(Fiber.interrupt(fiber).pipe(Effect4.provide(layer)));
+      }
+    };
+  }, [
+    agentPid,
+    runtime3,
+    space?.id,
+    subscribePidsKey
+  ]);
+  return status;
+};
 export {
-  useActiveBlueprints,
-  useBlueprintHandlers,
-  useBlueprints,
+  getTraceMessagesAtom,
+  isTerminalActivityLine,
+  useActiveSkills,
   useChatKeymapExtensions,
   useChatProcessor,
   useChatServices,
@@ -985,8 +866,12 @@ export {
   useDebug,
   useFilteredTypes,
   useFlush,
-  useOnline,
+  useHomeSuggestions,
   usePresets,
-  useReferencesProvider
+  useProcessEphemeralStatus,
+  useReferencesProvider,
+  useSkillHandlers,
+  useSkills,
+  useTraceMessages
 };
 //# sourceMappingURL=index.mjs.map