@dxos/plugin-assistant 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/plugin-assistant",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Assistant plugin",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -175,6 +175,11 @@
       "types": "./dist/types/src/TracePanel.d.ts",
       "import": "./dist/lib/ns/TracePanel.mjs"
     },
+    "./TurnReviewSkill": {
+      "source": "./src/skills/turn-review/TurnReviewSkill.ts",
+      "types": "./dist/types/src/skills/turn-review/TurnReviewSkill.d.ts",
+      "import": "./dist/lib/TurnReviewSkill.mjs"
+    },
     "./translations": {
       "source": "./src/translations.ts",
       "types": "./dist/types/src/translations.d.ts",
@@ -232,67 +237,69 @@
     "@effect/ai-openai": "4.0.0",
     "@effect/atom-react": "4.0.0",
     "effect": "4.0.0",
-    "@dxos/agent-runtime": "0.13.0",
-    "@dxos/app-graph": "0.13.0",
-    "@dxos/ai": "0.13.0",
-    "@dxos/app-framework": "0.13.0",
-    "@dxos/app-toolkit": "0.13.0",
-    "@dxos/assistant": "0.13.0",
-    "@dxos/assistant-toolkit": "0.13.0",
-    "@dxos/client": "0.13.0",
-    "@dxos/async": "0.13.0",
-    "@dxos/compute-runtime": "0.13.0",
-    "@dxos/compute": "0.13.0",
-    "@dxos/conductor": "0.13.0",
-    "@dxos/config": "0.13.0",
-    "@dxos/echo": "0.13.0",
-    "@dxos/devtools": "0.13.0",
-    "@dxos/echo-client": "0.13.0",
-    "@dxos/echo-react": "0.13.0",
-    "@dxos/edge-client": "0.13.0",
-    "@dxos/effect": "0.13.0",
-    "@dxos/errors": "0.13.0",
-    "@dxos/graph": "0.13.0",
-    "@dxos/halo-react": "0.13.0",
-    "@dxos/invariant": "0.13.0",
-    "@dxos/link": "0.13.0",
-    "@dxos/mcp-client": "0.13.0",
-    "@dxos/keys": "0.13.0",
-    "@dxos/plugin-attention": "0.13.0",
-    "@dxos/log": "0.13.0",
-    "@dxos/plugin-client": "0.13.0",
-    "@dxos/plugin-connector": "0.13.0",
-    "@dxos/plugin-deck": "0.13.0",
-    "@dxos/plugin-markdown": "0.13.0",
-    "@dxos/plugin-registry": "0.13.0",
-    "@dxos/plugin-graph": "0.13.0",
-    "@dxos/plugin-routine": "0.13.0",
-    "@dxos/plugin-space": "0.13.0",
-    "@dxos/plugin-status-bar": "0.13.0",
-    "@dxos/plugin-tasks": "0.13.0",
-    "@dxos/plugin-transcription": "0.13.0",
-    "@dxos/react-hooks": "0.13.0",
-    "@dxos/react-client": "0.13.0",
-    "@dxos/react-list": "0.13.0",
-    "@dxos/react-ui-assistant": "0.13.0",
-    "@dxos/react-ui-attention": "0.13.0",
-    "@dxos/react-ui-chat": "0.13.0",
-    "@dxos/react-ui-components": "0.13.0",
-    "@dxos/react-ui-form": "0.13.0",
-    "@dxos/react-ui-feed": "0.13.0",
-    "@dxos/react-ui-search": "0.13.0",
-    "@dxos/react-ui-menu": "0.13.0",
-    "@dxos/react-ui-task": "0.13.0",
-    "@dxos/react-ui-trace": "0.13.0",
-    "@dxos/schema": "0.13.0",
-    "@dxos/react-ui-transcription": "0.13.0",
-    "@dxos/types": "0.13.0",
-    "@dxos/ui": "0.13.0",
-    "@dxos/ui-types": "0.13.0",
-    "@dxos/util": "0.13.0",
-    "@dxos/ui-editor": "0.13.0",
-    "@dxos/react-ui-experimental": "0.13.0",
-    "@dxos/react-ui-list": "0.13.0"
+    "@dxos/agent-runtime": "0.14.0",
+    "@dxos/ai": "0.14.0",
+    "@dxos/app-framework": "0.14.0",
+    "@dxos/app-graph": "0.14.0",
+    "@dxos/app-toolkit": "0.14.0",
+    "@dxos/assistant": "0.14.0",
+    "@dxos/assistant-toolkit": "0.14.0",
+    "@dxos/async": "0.14.0",
+    "@dxos/client": "0.14.0",
+    "@dxos/compute": "0.14.0",
+    "@dxos/compute-runtime": "0.14.0",
+    "@dxos/conductor": "0.14.0",
+    "@dxos/devtools": "0.14.0",
+    "@dxos/config": "0.14.0",
+    "@dxos/echo": "0.14.0",
+    "@dxos/echo-react": "0.14.0",
+    "@dxos/edge-client": "0.14.0",
+    "@dxos/effect": "0.14.0",
+    "@dxos/errors": "0.14.0",
+    "@dxos/graph": "0.14.0",
+    "@dxos/invariant": "0.14.0",
+    "@dxos/keys": "0.14.0",
+    "@dxos/link": "0.14.0",
+    "@dxos/log": "0.14.0",
+    "@dxos/mcp-client": "0.14.0",
+    "@dxos/observability": "0.14.0",
+    "@dxos/echo-client": "0.14.0",
+    "@dxos/plugin-attention": "0.14.0",
+    "@dxos/plugin-client": "0.14.0",
+    "@dxos/plugin-connector": "0.14.0",
+    "@dxos/halo-react": "0.14.0",
+    "@dxos/plugin-graph": "0.14.0",
+    "@dxos/plugin-markdown": "0.14.0",
+    "@dxos/plugin-registry": "0.14.0",
+    "@dxos/plugin-routine": "0.14.0",
+    "@dxos/plugin-space": "0.14.0",
+    "@dxos/plugin-status-bar": "0.14.0",
+    "@dxos/plugin-tasks": "0.14.0",
+    "@dxos/plugin-transcription": "0.14.0",
+    "@dxos/plugin-deck": "0.14.0",
+    "@dxos/react-client": "0.14.0",
+    "@dxos/plugin-observability": "0.14.0",
+    "@dxos/react-hooks": "0.14.0",
+    "@dxos/react-list": "0.14.0",
+    "@dxos/react-ui-assistant": "0.14.0",
+    "@dxos/react-ui-attention": "0.14.0",
+    "@dxos/react-ui-feed": "0.14.0",
+    "@dxos/react-ui-menu": "0.14.0",
+    "@dxos/react-ui-form": "0.14.0",
+    "@dxos/react-ui-chat": "0.14.0",
+    "@dxos/react-ui-list": "0.14.0",
+    "@dxos/react-ui-task": "0.14.0",
+    "@dxos/react-ui-trace": "0.14.0",
+    "@dxos/react-ui-transcription": "0.14.0",
+    "@dxos/schema": "0.14.0",
+    "@dxos/react-ui-search": "0.14.0",
+    "@dxos/types": "0.14.0",
+    "@dxos/ui": "0.14.0",
+    "@dxos/ui-editor": "0.14.0",
+    "@dxos/util": "0.14.0",
+    "@dxos/ui-types": "0.14.0",
+    "@dxos/react-ui-experimental": "0.14.0",
+    "@dxos/react-ui-components": "0.14.0"
   },
   "devDependencies": {
     "@storybook/react-vite": "^10.6.0",
@@ -303,30 +310,32 @@
     "react": "~19.2.7",
     "react-dom": "~19.2.7",
     "vite": "^8.2.2",
-    "@dxos/assistant-toolkit": "0.13.0",
-    "@dxos/devtools": "0.13.0",
-    "@dxos/plugin-client": "0.13.0",
-    "@dxos/plugin-chess": "0.13.0",
-    "@dxos/plugin-map": "0.13.0",
-    "@dxos/plugin-preview": "0.13.0",
-    "@dxos/plugin-table": "0.13.0",
-    "@dxos/echo-client": "0.13.0",
-    "@dxos/plugin-testing": "0.13.0",
-    "@dxos/random": "0.13.0",
-    "@dxos/react-ui-mosaic": "0.13.0",
-    "@dxos/react-ui-editor": "0.13.0",
-    "@dxos/react-ui": "0.13.0",
-    "@dxos/react-ui-menu": "0.13.0",
-    "@dxos/react-ui-syntax-highlighter": "0.13.0",
-    "@dxos/ui-theme": "0.13.0"
+    "@dxos/assistant-toolkit": "0.14.0",
+    "@dxos/devtools": "0.14.0",
+    "@dxos/echo-client": "0.14.0",
+    "@dxos/edge-compute": "0.14.0",
+    "@dxos/plugin-chess": "0.14.0",
+    "@dxos/plugin-client": "0.14.0",
+    "@dxos/plugin-table": "0.14.0",
+    "@dxos/plugin-map": "0.14.0",
+    "@dxos/protocols": "0.14.0",
+    "@dxos/plugin-testing": "0.14.0",
+    "@dxos/react-ui": "0.14.0",
+    "@dxos/react-ui-editor": "0.14.0",
+    "@dxos/react-ui-menu": "0.14.0",
+    "@dxos/react-ui-mosaic": "0.14.0",
+    "@dxos/react-ui-syntax-highlighter": "0.14.0",
+    "@dxos/ui-theme": "0.14.0",
+    "@dxos/plugin-preview": "0.14.0",
+    "@dxos/random": "0.14.0"
   },
   "peerDependencies": {
     "@effect/atom-react": "4.0.0",
     "effect": "4.0.0",
     "react": "~19.2.7",
     "react-dom": "~19.2.7",
-    "@dxos/react-ui": "^0.13.0",
-    "@dxos/ui-theme": "^0.13.0"
+    "@dxos/react-ui": "^0.14.0",
+    "@dxos/ui-theme": "^0.14.0"
   },
   "publishConfig": {
     "access": "public"

package/src/capabilities/agent-service.ts

@@ -13,7 +13,7 @@ import * as LayerSpec from '@dxos/compute/LayerSpec';
 import * as Process from '@dxos/compute/Process';
 import * as RoutineCapabilities from '@dxos/plugin-routine/RoutineCapabilities';
 
-import { AssistantOptions } from '#types';
+import { AssistantCapabilities, AssistantOptions } from '#types';
 
 import { resolveTurnProducer } from './turn-producers.ts';
 
@@ -42,6 +42,7 @@ const makeAgentServiceSpec = (codeModeTurnProducer: AssistantOptions.AssistantPl
           return AgentServiceRuntime.layer({
             delegationStrategy: strategies[0],
             makeTurnProducer: (options) => resolveTurnProducer(manager, codeMode)(options),
+            processes: () => manager.getAll(AssistantCapabilities.AgentProcess),
           });
         }),
       ),

package/src/capabilities/skill-definition.ts

@@ -22,7 +22,7 @@ import * as RegistryPlugin from '@dxos/plugin-registry/RegistryPlugin';
 import * as RoutineCapabilities from '@dxos/plugin-routine/RoutineCapabilities';
 import * as DatabaseSkill from '@dxos/plugin-space/DatabaseSkill';
 
-import { AssistantSkill, PluginManagerSkill } from '#skills';
+import { AssistantSkill, PluginManagerSkill, TurnReviewSkill } from '#skills';
 
 const skillDefinition = Effect.fnUntraced(function* () {
   const manager = yield* Plugin.Service;
@@ -48,6 +48,7 @@ const skillDefinition = Effect.fnUntraced(function* () {
       SkillManagerSkill,
       DelegationSkill,
       AlarmSkill,
+      TurnReviewSkill,
     ]),
 
     // Run the conversational agent as a supervisor: delegate in-progress plan tasks to sub-agents

package/src/chat-model/chat-model.edge.test.ts

@@ -0,0 +1,301 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as KeyValueStore from 'effect/persistence/KeyValueStore';
+import * as AtomRegistry from 'effect/reactivity/AtomRegistry';
+import * as Result from 'effect/Result';
+import * as Stream from 'effect/Stream';
+import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
+
+import { AgentService as AgentServiceRuntime } from '@dxos/agent-runtime';
+import { AiService, Model, OpaqueToolkit, Provider } from '@dxos/ai';
+import { AiSession } from '@dxos/assistant';
+import * as Chat from '@dxos/assistant/Chat';
+import { Client } from '@dxos/client';
+import { type Space } from '@dxos/client/echo';
+import {
+  ProcessManager,
+  ProcessOperationInvoker,
+  RemoteTraceMonitor,
+  UnifiedProcessManager,
+  configuredCredentialsLayer,
+} from '@dxos/compute-runtime';
+import * as AgentService from '@dxos/compute/AgentService';
+import * as OperationHandlerSet from '@dxos/compute/OperationHandlerSet';
+import * as ServiceResolver from '@dxos/compute/ServiceResolver';
+import * as Trace from '@dxos/compute/Trace';
+import { configPreset } from '@dxos/config';
+import { Database, Feed, Ref, Registry } from '@dxos/echo';
+import { registryLayer } from '@dxos/echo-client';
+import { EdgeHttpClient } from '@dxos/edge-client';
+import { EdgeProcessManager } from '@dxos/edge-compute';
+import * as EffectEx from '@dxos/effect/EffectEx';
+import { DXN } from '@dxos/keys';
+import { toPublicKey } from '@dxos/protocols/buf';
+import { EdgeReplicationSetting } from '@dxos/protocols/buf/dxos/echo/metadata_pb';
+import { Message } from '@dxos/types';
+
+import { ChatModel } from './chat-model.ts';
+import { providerForModel } from './presets.ts';
+import { ChatModelRecorder } from './testing/chat-model-recorder.ts';
+import { makeSpaceLayer, makeTestRuntime } from './testing/harness.ts';
+
+/**
+ * The chat model against an EDGE-hosted agent and a real model: the same indicator log as the scripted
+ * suite, plus the latency of each stage of a turn, so a slow or silent hosted turn shows WHERE it is slow.
+ *
+ * The stack is the one Composer builds for a `remote` chat — the durable command queue in front of EDGE
+ * process control, and the swarm monitor for the agent's live trace — so what this measures is what the
+ * app sees.
+ *
+ * Run (one or more environments, comma-separated; `local` is `moon run edge:dev` in the edge repo):
+ *   DX_RUN_MANUAL_TESTS=1 DX_EDGE_ENVS=local,dev moon run plugin-assistant:test -- src/chat-model/chat-model.edge.test.ts
+ * Optional: DX_CHAT_MODEL (a model DXN; defaults to Claude Haiku 4.5), DX_CHAT_TURNS (prompts per chat).
+ */
+
+type EdgeEnv = 'local' | 'dev' | 'preview';
+
+const ENVS = (process.env.DX_EDGE_ENVS ?? 'local').split(',').map((env) => env.trim()) as EdgeEnv[];
+const MODEL = process.env.DX_CHAT_MODEL ? DXN.make(process.env.DX_CHAT_MODEL) : Model.claudeHaiku45.id;
+
+const PROMPTS = [
+  'Reply with exactly one word: pong',
+  'Count from one to twenty in words, separated by commas.',
+  'Now answer with one word: done',
+].slice(0, Number.parseInt(process.env.DX_CHAT_TURNS ?? '', 10) || 3);
+
+/** The stages of a turn, each the first moment (ms after send) at which the reader could see it. */
+type TurnTiming = {
+  prompt: string;
+  /** The chat reads as working (stop control, activity line). */
+  active?: number;
+  /** The agent process reports RUNNING (the host has taken the input). */
+  agentRunning?: number;
+  /** First phase the agent itself reported (anything past the client's own `starting`). */
+  firstAgentPhase?: number;
+  /** The provider was contacted. */
+  contactingProvider?: number;
+  /** First streamed content. */
+  firstToken?: number;
+  /** The prompt row ticks to read (the agent's queue took it). */
+  promptRead?: number;
+  /** The reply is in the thread from the feed (replicated back from EDGE). */
+  replyInThread?: number;
+  /** The chat reads idle again. */
+  settled?: number;
+  phases: string[];
+  /** EDGE process-control calls made during the turn, as `verb start→end` (ms after send). */
+  calls: string[];
+};
+
+/** EDGE process-control calls, timed, so a slow turn can be attributed to the round trip that made it slow. */
+type EdgeCall = { verb: string; start: number; end?: number };
+
+const PROCESS_VERBS = [
+  'spawnProcess',
+  'listProcesses',
+  'getProcess',
+  'submitProcessInput',
+  'readProcessEvents',
+  'terminateProcess',
+] as const;
+
+const traceEdgeCalls = (calls: EdgeCall[]) => {
+  for (const verb of PROCESS_VERBS) {
+    const original = EdgeHttpClient.prototype[verb];
+    vi.spyOn(EdgeHttpClient.prototype, verb).mockImplementation(function (
+      this: EdgeHttpClient,
+      ...args: Parameters<typeof original>
+    ) {
+      const call: EdgeCall = { verb, start: performance.now() };
+      calls.push(call);
+      return (original as (...args: unknown[]) => Promise<unknown>).apply(this, args).finally(() => {
+        call.end = performance.now();
+      });
+    } as typeof original);
+  }
+};
+
+describe.each(ENVS)('ChatModel (edge-hosted agent, %s)', { tags: ['manual'], timeout: 600_000 }, (env) => {
+  let client: Client;
+  let space: Space;
+  const calls: EdgeCall[] = [];
+
+  beforeAll(async () => {
+    client = await new Client({
+      config: configPreset({ edge: env }),
+      types: [Chat.Chat, Feed.Feed, Message.Message],
+    }).initialize();
+    await client.halo.createIdentity();
+    space = await client.spaces.create();
+    await space.waitUntilReady();
+    await space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED);
+    traceEdgeCalls(calls);
+  }, 120_000);
+
+  afterAll(async () => {
+    vi.restoreAllMocks();
+    await client?.destroy();
+  });
+
+  test('every turn keeps its indicators up while the hosted agent works', async () => {
+    const timings = await EffectEx.runPromise(
+      runTurns(client, space, calls).pipe(Effect.provide(stack(client, space))),
+    );
+
+    console.log(`\nchat-model latency on ${env} (${DXN.getName(MODEL)}), ms after send:`);
+    console.table(
+      timings.map(({ phases: _phases, calls: _calls, prompt, ...stages }) => ({
+        prompt: prompt.slice(0, 24),
+        ...stages,
+      })),
+    );
+    for (const timing of timings) {
+      console.log(`  phases: ${timing.phases.join(' → ')}`);
+      console.log(`  calls:  ${timing.calls.join(', ')}`);
+    }
+  });
+});
+
+const runTurns = (client: Client, space: Space, calls: EdgeCall[]) =>
+  Effect.gen(function* () {
+    const feed = yield* Database.add(Feed.make());
+    // The model is the chat's own from the start: one stamped later reads as a reconfiguration, which
+    // replaces the hosted process.
+    const chat = yield* Database.add(
+      Chat.make({ name: 'Latency', feed: Ref.make(feed), remote: true, session: { model: MODEL } }),
+    );
+    yield* Database.flush();
+    // The hosted process reads the chat from EDGE's copy of the space.
+    yield* Effect.promise(() => space.internal.syncToEdge());
+
+    const runtime = yield* Effect.context<Database.Service>();
+    const session = yield* EffectEx.acquireReleaseResource(() => new AiSession.Session({ feed, runtime }));
+    const registry = yield* AtomRegistry.AtomRegistry;
+    const chatModel = new ChatModel(session, yield* makeTestRuntime, feed, yield* makeSpaceLayer, {
+      chat: Ref.make(chat),
+      model: MODEL,
+      provider: Provider.edge.id,
+      observableRegistry: registry,
+    });
+
+    const timings: TurnTiming[] = [];
+    for (const prompt of PROMPTS) {
+      // Resolved per turn, with the chat model's own options: a hosted process that finished its turn is
+      // replaced, and the replacement's status is the one to watch.
+      const agent = yield* AgentService.getSession(chat, {
+        provider: providerForModel(MODEL, Provider.edge.id),
+        location: 'edge',
+      });
+      const recorder = new ChatModelRecorder(registry, chatModel, { agentRunning: agent.running });
+      const turnRows = rows(recorder.state.thread);
+      const sentAt = performance.now();
+      const firstCall = calls.length;
+      chatModel.send({ message: prompt });
+      yield* Effect.promise(() => recorder.untilSettled(300_000));
+      // The reply lands in the thread from the feed, which may trail the settle.
+      yield* Effect.promise(() =>
+        recorder.until((state) => rows(state.thread) >= turnRows + 2, 60_000).catch(() => undefined),
+      );
+      recorder.dispose();
+
+      expect(recorder.state.error).toBe('-');
+      // A hosted turn that streams nothing is the defect this suite exists for, not a slow turn.
+      expect(recorder.firstAt('streaming', 'true')).toBeDefined();
+      // Ignore the client's own idle reading before the first event of the turn.
+      expect(recorder.violations.filter((violation) => violation.at > 0)).toEqual([]);
+      timings.push({
+        ...timingOf(prompt, recorder),
+        calls: calls
+          .slice(firstCall)
+          .filter(({ verb }) => verb !== 'readProcessEvents' && verb !== 'getProcess')
+          .map(({ verb, start, end }) => {
+            const at = (time: number | undefined) => (time === undefined ? '…' : Math.round(time - sentAt));
+            return `${verb.replace('Process', '')} ${at(start)}→${at(end)}`;
+          }),
+      });
+    }
+    return timings;
+  }).pipe(Effect.scoped);
+
+/** Rows in a recorded thread (the prompt and the reply each add one). */
+const rows = (thread: string) => (thread === '-' ? 0 : thread.split(' | ').length);
+
+const timingOf = (prompt: string, recorder: ChatModelRecorder): Omit<TurnTiming, 'calls'> => {
+  const agentPhase = (value: string) => value !== '-' && value !== 'starting' && value !== 'generating';
+  const threadRows = recorder.events.filter((event) => event.signal === 'thread');
+  return {
+    prompt,
+    active: recorder.firstAt('active', 'true'),
+    agentRunning: recorder.firstAt('agent', 'running'),
+    firstAgentPhase: recorder.firstAt('activity', agentPhase),
+    contactingProvider: recorder.firstAt('activity', (value) => value.startsWith('contacting-provider')),
+    firstToken: recorder.firstAt('streaming', 'true'),
+    promptRead: threadRows.find((event) => event.value.includes(`[read]:"${prompt.slice(0, 24)}`))?.at,
+    replyInThread: threadRows.at(-1)?.at,
+    settled: recorder.events.findLast((event) => event.signal === 'active' && event.value === 'false')?.at,
+    phases: recorder.values('activity').filter((value) => value !== ''),
+  };
+};
+
+/**
+ * What Composer provides a `remote` chat: the local process manager, EDGE's behind the durable command
+ * queue, the swarm-backed live trace, and `AgentService` over both.
+ */
+const stack = (client: Client, space: Space) =>
+  Layer.empty.pipe(
+    Layer.provideMerge(ProcessOperationInvoker.layer),
+    Layer.provideMerge(AgentServiceRuntime.layer({ defaultModel: MODEL, provider: Provider.edge.id })),
+    Layer.provideMerge(UnifiedProcessManager.layer),
+    Layer.provideMerge(
+      Layer.unwrap(
+        Effect.gen(function* () {
+          const kvStore = yield* KeyValueStore.KeyValueStore;
+          return EdgeProcessManager.fromClient(client, { kvStore });
+        }),
+      ),
+    ),
+    Layer.provideMerge(Layer.succeed(RemoteTraceMonitor.Service, swarmMonitor(client))),
+    Layer.provideMerge(ProcessManager.layer()),
+    Layer.provideMerge(
+      ServiceResolver.layerRequirements(
+        Database.Service,
+        OpaqueToolkit.OpaqueToolkitProvider,
+        AiService.AiService,
+        Registry.Service,
+      ),
+    ),
+    Layer.provideMerge(OperationHandlerSet.provide(OperationHandlerSet.empty)),
+    Layer.provideMerge(Trace.layerNoop),
+    Layer.provideMerge(AiService.notAvailable),
+    Layer.provideMerge(OpaqueToolkit.providerEmpty),
+    Layer.provideMerge(configuredCredentialsLayer([])),
+    Layer.provideMerge(registryLayer()),
+    Layer.provideMerge(KeyValueStore.layerMemory),
+    Layer.provideMerge(AtomRegistry.layer),
+    Layer.provideMerge(Database.layer(space.db)),
+  );
+
+/** The swarm-backed live trace, as plugin-client contributes it. */
+const swarmMonitor = (client: Client): RemoteTraceMonitor.Monitor =>
+  RemoteTraceMonitor.createSwarmRemoteTraceMonitor({
+    subscribe: (tags) =>
+      tags.length === 0
+        ? Stream.empty
+        : Stream.unwrap(
+            Effect.sync(() => {
+              const peer = { peerKey: toPublicKey(client.halo.device?.deviceKey)?.toHex() ?? '' };
+              return client.services.rpc['NetworkService.subscribeMessages']({ peer, tags }).pipe(
+                Stream.filterMap((message) =>
+                  message.payload?.value
+                    ? Result.succeed({ payload: message.payload.value, tags: message.tags })
+                    : Result.failVoid,
+                ),
+                Stream.catch(() => Stream.empty),
+              );
+            }),
+          ),
+  });

package/src/{processor/processor.node.test.ts → chat-model/chat-model.node.test.ts}

@@ -22,12 +22,12 @@ import { TestHelpers } from '@dxos/effect/testing';
 import { DXN } from '@dxos/keys';
 import { Message } from '@dxos/types';
 
-import { AiChatProcessor, AiUsageQuotaError, parseError } from './processor.ts';
+import { AiUsageQuotaError, ChatModel, parseError } from './chat-model.ts';
 import { type ThreadProjection } from './thread.ts';
 
 const TestLayer = AssistantTestLayer({ tracing: 'noop', types: [Chat.Chat, Feed.Feed, Message.Message] });
 
-describe('Chat processor', () => {
+describe('ChatModel', () => {
   it.effect(
     'basic',
     Effect.fn(
@@ -38,19 +38,19 @@ describe('Chat processor', () => {
         const session = yield* EffectEx.acquireReleaseResource(() => new AiSession.Session({ feed, runtime }));
         const managedRuntime = ManagedRuntime.make(Layer.empty) as unknown as Capabilities.ProcessManagerRuntime;
         const registry = AtomRegistry.make();
-        const processor = new AiChatProcessor(session, managedRuntime, feed, Layer.empty as any, {
+        const chatModel = new ChatModel(session, managedRuntime, feed, Layer.empty as any, {
           observableRegistry: registry,
         });
-        expect(processor).toBeDefined();
-        expect(processor.active).toBeDefined();
+        expect(chatModel).toBeDefined();
+        expect(chatModel.active).toBeDefined();
 
-        // The thread is the processor's one view: a feed append and a sent prompt both arrive through it.
+        // The thread is the chat model's one view: a feed append and a sent prompt both arrive through it.
         const rows = (predicate: (thread: ThreadProjection) => boolean) =>
           Effect.promise(
             () =>
               new Promise<ThreadProjection>((resolve) => {
                 const unsubscribe = registry.subscribe(
-                  processor.thread,
+                  chatModel.thread,
                   (thread) => {
                     if (predicate(thread)) {
                       queueMicrotask(() => unsubscribe());
@@ -68,8 +68,8 @@ describe('Chat processor', () => {
         const appended = yield* rows((thread) => thread.messages.length === 1);
         expect(appended.tail).toBe(0);
 
-        const id = processor.send({ message: 'hello' });
-        const sent = registry.get(processor.thread);
+        const id = chatModel.send({ message: 'hello' });
+        const sent = registry.get(chatModel.thread);
         expect(sent.messages.map((message) => message.id)).toEqual([appended.messages[0].id, id]);
         expect(sent.delivery.get(id)?.outboxId).toBe(id);
         expect(sent.tail).toBe(1);
@@ -159,6 +159,16 @@ describe('parseError', () => {
     expect(parseError(err).message).toBe('Connection refused');
   });
 
+  // A provider failure inside the agent process reaches the chat as the process's stringified failure,
+  // so its typed reason is gone but the provider's own description is still in the text.
+  test('passes through the detail of an AiError stringified by the process boundary', ({ expect }) => {
+    const err = new Error('Process failed', {
+      cause:
+        'effect/ai/AiError/AiError: AnthropicClient.streamText: Invalid request. prompt is too long\n    at stack (file.ts:1:1)',
+    });
+    expect(parseError(err).message).toBe('Invalid request. prompt is too long');
+  });
+
   test('falls back to a generic message for unrecognized errors', ({ expect }) => {
     expect(parseError('something unexpected blew up').message).toBe('An unexpected error occurred.');
     expect(parseError(new Error('boom')).message).toBe('An unexpected error occurred.');