@dxos/plugin-assistant 0.9.0 → 0.9.1-main.c7dcc2e112

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

@@ -1,6 +1,8 @@
 import {
+  AiChatProcessor,
+  AiServicePresets,
   useChatContext
-} from "../chunk-VTK5R4H3.mjs";
+} from "../chunk-54W7N6M6.mjs";
 import "../chunk-J5LGTIGS.mjs";
 
 // src/hooks/useBlueprintRegistry.ts
@@ -161,7 +163,7 @@ 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";
@@ -171,395 +173,11 @@ 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 { 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 { 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 [session, setSession] = useState2();
@@ -571,8 +189,8 @@ var useChatProcessor = ({ space, chat, preset, runtime: runtime3, registry, sett
     if (!feedTarget) {
       return;
     }
-    const feedServiceLayer = createFeedServiceLayer(space.queues);
-    const runtime4 = await EffectEx2.runAndForwardErrors(Effect2.runtime().pipe(Effect2.provide(feedServiceLayer)));
+    const feedServiceLayer = createFeedServiceLayer(space.db);
+    const runtime4 = await EffectEx.runAndForwardErrors(Effect.runtime().pipe(Effect.provide(feedServiceLayer)));
     const session2 = new AiSession.Session({
       feed: feedTarget,
       runtime: runtime4,
@@ -596,12 +214,12 @@ 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, Feed.FeedService, 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: 59, S: void 0 });
     return new AiChatProcessor(session, runtime3, feed, spaceLayer, {
       chat: chat ? Ref2.make(chat) : void 0,
       observableRegistry,
@@ -623,26 +241,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 { Filter as Filter2, Obj as Obj2, Query, Type } from "@dxos/echo";
+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 +270,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",
@@ -720,21 +338,21 @@ var useChatToolbarActions = ({ chat, companionTo }) => {
         variant: "dropdownMenu"
       }, (builder2) => {
         chats.toSorted((a, b) => a.id.localeCompare(b.id)).forEach((chat2) => {
-          get(Obj3.atomProperty(chat2, "name"));
+          get(Obj2.atomProperty(chat2, "name"));
           builder2.action(chat2.id, {
-            label: Obj3.getLabel(chat2) ?? [
+            label: Obj2.getLabel(chat2) ?? [
               "object-name.placeholder",
               {
                 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 +367,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 { AiContext } from "@dxos/assistant";
 import { createFeedServiceLayer as createFeedServiceLayer2 } from "@dxos/echo-client";
-import { EffectEx as EffectEx4 } from "@dxos/effect";
+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 +381,9 @@ 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 feedServiceLayer = createFeedServiceLayer2(space.db);
+    const runtime3 = await EffectEx3.runAndForwardErrors(Effect3.runtime().pipe(Effect3.provide(feedServiceLayer)));
+    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) => {
@@ -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(() => {
@@ -945,7 +563,7 @@ var usePresets = (online) => {
 
 // src/hooks/useReferencesProvider.ts
 import { useMemo as useMemo5 } from "react";
-import { Filter as Filter3, Obj as Obj4 } from "@dxos/echo";
+import { Filter as Filter3, Obj as Obj3 } from "@dxos/echo";
 var useReferencesProvider = (space) => {
   return useMemo5(() => {
     if (!space) {
@@ -954,16 +572,16 @@ var useReferencesProvider = (space) => {
     return {
       getReferences: async ({ query }) => {
         const objects = await space.db.query(Filter3.everything()).run();
-        return objects.filter(Obj4.isObject).filter((object) => stringMatch(query, Obj4.getLabel(object) ?? "")).map((object) => ({
-          uri: Obj4.getURI(object),
-          label: Obj4.getLabel(object) ?? ""
+        return objects.filter(Obj3.isObject).filter((object) => stringMatch(query, Obj3.getLabel(object) ?? "")).map((object) => ({
+          uri: Obj3.getURI(object),
+          label: Obj3.getLabel(object) ?? ""
         }));
       },
       resolveReference: async ({ uri }) => {
         const object = await space.db.query(Filter3.id(uri)).first();
         return {
           uri,
-          label: Obj4.getLabel(object) ?? ""
+          label: Obj3.getLabel(object) ?? ""
         };
       }
     };
@@ -972,7 +590,182 @@ 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 useAtomValue2 } 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 useAtomValue2(atom);
+};
+
+// src/hooks/useProcessEphemeralStatus.ts
+import { Atom as Atom3 } from "@effect-atom/atom";
+import { useAtomValue as useAtomValue3 } 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 useMemo7, useRef as useRef2, useState as useState8 } from "react";
+import { Capabilities as Capabilities3 } from "@dxos/app-framework";
+import { useOptionalCapability } 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 = useOptionalCapability(Capabilities3.ProcessManagerRuntime);
+  const monitor = useOptionalCapability(Capabilities3.ProcessMonitor);
+  const processes = useAtomValue3(monitor?.processTreeAtom ?? atomEmpty2);
+  const [status, setStatus] = useState8();
+  const fibersRef = useRef2([]);
+  const subscribePidsKey = useMemo7(() => {
+    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 {
+  getTraceMessagesAtom,
+  isTerminalActivityLine,
   useActiveBlueprints,
   useBlueprintHandlers,
   useBlueprints,
@@ -987,6 +780,8 @@ export {
   useFlush,
   useOnline,
   usePresets,
-  useReferencesProvider
+  useProcessEphemeralStatus,
+  useReferencesProvider,
+  useTraceMessages
 };
 //# sourceMappingURL=index.mjs.map