@dxos/plugin-assistant 0.8.4-main.3eb6e50203 → 0.8.4-main.422d1c7879

package/src/components/ChatThread/testing/reasoning.md

@@ -0,0 +1,25 @@
+<prompt>How should I structure a CLI tool with subcommands?</prompt>
+
+<reasoning>
+The user is asking about CLI subcommand structure. Let me think through what they likely care about:
+
+1. Discoverability — every subcommand needs help text and a flat top-level listing.
+2. Composability — subcommands should be invokable individually for scripting.
+3. Shared concerns — auth, config, logging should not be duplicated per command.
+
+A few patterns worth considering:
+
+- A single binary that dispatches to subcommand handlers (like `git`, `kubectl`).
+- A plugin model where subcommands live in separate binaries on the PATH (like `git-foo`).
+- A library that each subcommand wraps as a thin executable.
+
+The plugin model wins for very large surfaces but adds packaging cost. For a tool with under ~30 subcommands the dispatcher pattern stays clearer.
+</reasoning>
+
+For a CLI with a moderate set of subcommands, the dispatcher pattern is usually the right default:
+
+1. One binary, one entry point.
+2. Subcommands registered as handlers off a shared root.
+3. Cross-cutting concerns (auth, config, logging) wired in at the root and inherited.
+
+If you grow past ~30 subcommands or want third-party extensions, switch to a plugin model where binaries named `<tool>-<subcommand>` are discovered on the `PATH`.

package/src/components/ChatThread/testing/thinking.md

@@ -0,0 +1,21 @@
+<prompt>create a project to track what I order online based on my emails, dont asak me questions</prompt>
+<reasoning>The user wants me to create a project that tracks their online orders based on emails. They don't want me to ask questions - just go ahead and create it. Let me first get the project rules and query for available mailboxes/inboxes.</reasoning>
+<status>Getting the project rules and finding your mailboxes to set this up...</status>
+<toolCall id="toolu_01QJcUw8RZDyemLdvMe8nSGZ" />
+<toolCall id="toolu_01JJZrCc17JqV5r36aR9wcaj" />
+<toolCall id="toolu_012r3VQFxvWZ9UmKxMNiJP48" />
+<reasoning>The mailbox query failed. Let me try a different approach to find mailboxes. Let me also enable the inbox blueprint to find mailboxes, and create the Order schema first. Let me first search for mailboxes with a different query approach.</reasoning>
+<status>Looking for your mailboxes...</status>
+<toolCall id="toolu_01P4ekwYwYJfxUnGFPHNhcCu" />
+<toolCall id="toolu_017NHbtinMDcjmwqN6vLaNQp" />
+<reasoning>I found the mailbox with DXN `dxn:echo:B6ON2Y6HN4KLJWZD75VUUDCUQ552ERQSG:01KNHKXSWWCBZX6TCPMF1M0PDE`. Now I need to: 1. Create an Order schema for tracking online orders 2. Create the project with the right blueprints and subscriptions Let me first create the Order schema, then create the project.</reasoning>
+<status>Found your mailbox. Now creating an Order schema and setting up the project...</status>
+<toolCall id="toolu_01Gk4RcfdB4ttzsVN9mnatWn" />
+<status>Order schema created. Now creating the project...</status>
+<toolCall id="toolu_01QmJcua6jmRx15wnxo5bkNQ" />
+<reasoning>The service isn't available. Let me try again.</reasoning>
+<status>Encountered a temporary service issue. Retrying...</status>
+<toolCall id="toolu_01X4CVxXuBjgW2JESGUEsm6f" />
+<reasoning>The service seems to be temporarily unavailable. Let me try once more.</reasoning>
+<toolCall id="toolu_01S9vi1pMnwqUuxNpe5FU731" />
+Got the project created. Let me know if you need anything else.

package/src/components/ChatThread/testing/thread-1.md

@@ -0,0 +1,30 @@
+<prompt>What is markdown?</prompt>
+
+<reasoning>
+The user is asking me to think deeply about what markdown is.
+
+But given the context of our conversation - we've been trying to scrape slab data from a website - I think they might be hinting at something specific.
+</reasoning>
+
+### Markdown
+
+Markdown is a lightweight markup language used to format plain text in a simple and readable way.
+
+It allows you to create structured documents using conventions for headings, lists, emphasis (bold/italic), links, images, code, blockquotes, tables, and horizontal rules.
+
+Markdown documents look like this
+
+```
+# Markdown
+
+This is a plain text.
+```
+
+Composer supports extended components via XML tags.
+
+<summary>
+The user asked about Markdown.
+
+We responded with a summary.
+
+</summary>

package/src/components/ChatThread/testing/{thread.md → thread-2.md}

@@ -35,3 +35,22 @@ What kind of information are you looking to organize? This will help me suggest
 
 <summary>OK (1 tool uses · 4.28k tokens · 11.1s)</summary>
 <summary>OK (4.30k tokens · 1.6s)</summary>
+
+<reasoning>Based on the rules, this is similar to the "Parcel tracking" example. I should: 1. First create an Order schema 2. Query for mailboxes to subscribe to 3. Query for available blueprints 4. Create the project Let me first ask a couple of qualifying questions, then proceed. Actually, the example is pretty clear - let me set things up. But first let me check for mailboxes and blueprints. Let me query for mailboxes and blueprints in parallel.</reasoning>
+
+<reasoning>I found a mailbox at `dxn:echo:B6ON2Y6HN4KLJWZD75VUUDCUQ552ERQSG:01KNHKXSWWCBZX6TCPMF1M0PDE`. Now I have everything I need to create the CRM project. The project should:
+
+1. Subscribe to the mailbox
+2. Use database, web-search, and browser blueprints
+3. Extract People and Organizations from emails
+4. Research contacts on the web
+5. Save to database avoiding duplicates
+6. Now I'm building the project structure to tie all these components together.</reasoning>
+
+<reasoning>I found the mailbox. Now I have all the information I need to create the CRM project. Let me create it with the appropriate blueprints and subscription to the mailbox. The project should:
+
+- Subscribe to the mailbox
+- On every email, extract People and Organizations
+- Save them to the database (checking for duplicates first)
+- Run web searches to enrich contact/org data
+- Blueprints needed: database, web-search, browser</reasoning>

package/src/components/ChatThread/testing/thread-widgets.md

@@ -0,0 +1,79 @@
+<prompt>Analyze this codebase and suggest improvements.</prompt>
+
+<reasoning>
+The user wants a comprehensive analysis of their codebase. I should examine the project structure, identify key patterns, and look for areas that could be improved. Let me start by reviewing the main source files and dependencies.
+</reasoning>
+
+I'll start by examining the project structure and key files.
+
+<toolCall id="toolu_01ABC123analyze" />
+
+<summary>Analyzed 42 files across 8 packages. Found 3 areas for improvement.</summary>
+
+Here's what I found after reviewing the codebase:
+
+## Architecture
+
+The project follows a modular plugin architecture with clear separation of concerns. Each plugin manages its own state and communicates through a shared event bus.
+
+## Suggested Improvements
+
+1. **Type Safety** — Several utility functions use `any` types that could be narrowed. This would catch bugs at compile time rather than runtime.
+
+2. **Error Handling** — The API layer could benefit from structured error types using discriminated unions instead of thrown exceptions.
+
+3. **Performance** — The subscription handlers in the data layer create new closures on every update. Memoizing these would reduce GC pressure.
+
+<reference ref="dxn:echo:@:123e4567-e89b-12d3-a456-426614174000">ProjectConfig</reference>
+
+Would you like me to dive deeper into any of these areas?
+
+<select>
+<option>Improve type safety</option>
+<option>Refactor error handling</option>
+<option>Optimize performance</option>
+</select>
+
+<suggestion>Show me the specific files that need type improvements</suggestion>
+
+<suggestion>Generate a refactoring plan as a document</suggestion>
+
+<stats>3 tool uses · 12.4k tokens · 18.2s</stats>
+
+<prompt>Improve type safety</prompt>
+
+<reasoning>
+The user chose to focus on type safety improvements. I should identify the specific files and patterns where `any` types are used unnecessarily and propose concrete fixes with before/after examples.
+</reasoning>
+
+Let me find all the locations where type safety can be improved.
+
+<toolCall id="toolu_01DEF456typescan" />
+
+<summary>Scanned 42 files. Found 17 instances of unnecessary `any` usage across 6 modules.</summary>
+
+Here are the key changes I recommend:
+
+### `src/utils/transform.ts`
+
+The `transform` function currently accepts `any` for its input parameter. We can use a generic constraint instead:
+
+```typescript
+// Before
+const transform = (input: any) => { ... }
+
+// After
+const transform = <T extends Record<string, unknown>>(input: T) => { ... }
+```
+
+### `src/handlers/events.ts`
+
+The event handler map uses `any` for callback types. A mapped type would preserve type information:
+
+```typescript
+type EventHandlers = {
+  [K in keyof EventMap]: (event: EventMap[K]) => void;
+};
+```
+
+<stats>1 tool use · 8.7k tokens · 12.1s</stats>

package/src/components/ChatThread/tool-widget-state.test.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { createMessage } from '#testing';
+
+import { rehydrateToolWidgetsFromMessages } from './tool-widget-state';
+
+describe('rehydrateToolWidgetsFromMessages', () => {
+  test('replays toolCall then toolResult in order', () => {
+    const calls: Array<{ id: string; kind: 'object' | 'function' }> = [];
+    const sink = {
+      updateWidget: (id: string, value: unknown) => {
+        calls.push({ id, kind: typeof value === 'function' ? 'function' : 'object' });
+      },
+    };
+
+    const messages = [
+      createMessage('assistant', [
+        { _tag: 'toolCall', toolCallId: 't1', name: 'foo', input: '{}', providerExecuted: false },
+        { _tag: 'toolResult', toolCallId: 't1', name: 'foo', result: '{}', providerExecuted: false },
+      ]),
+    ];
+
+    rehydrateToolWidgetsFromMessages(sink, messages);
+
+    expect(calls).toEqual([
+      { id: 't1', kind: 'object' },
+      { id: 't1', kind: 'function' },
+    ]);
+  });
+});

package/src/components/ChatThread/tool-widget-state.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ContentBlock, type Message } from '@dxos/types';
+import { type StateDispatch } from '@dxos/ui-editor';
+
+/**
+ * Minimal surface used to push tool call / result blocks into {@link MarkdownStreamController} widget state.
+ */
+export type ToolWidgetStateSink = {
+  updateWidget<T>(id: string, value: StateDispatch<T>): void;
+};
+
+/**
+ * Mirrors tool-related branches of {@link blockToMarkdown} so widget props stay in sync with message blocks.
+ */
+export const applyToolBlockToWidgetState = (context: ToolWidgetStateSink, block: ContentBlock.Any): void => {
+  switch (block._tag) {
+    case 'toolCall': {
+      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, {
+        blocks: [block],
+      });
+      break;
+    }
+    case 'toolResult': {
+      context.updateWidget<{ blocks: ContentBlock.Any[] }>(block.toolCallId, ({ blocks = [] } = { blocks: [] }) => ({
+        blocks: [...blocks, block],
+      }));
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+};
+
+/**
+ * Re-applies tool widget state after a full document replace (e.g. {@link MarkdownStreamController.setContent}),
+ * which clears accumulated widget props via `xmlTagResetEffect`.
+ */
+export const rehydrateToolWidgetsFromMessages = (context: ToolWidgetStateSink, messages: Message.Message[]): void => {
+  for (const message of messages) {
+    for (const block of message.blocks) {
+      applyToolBlockToWidgetState(context, block);
+    }
+  }
+};

package/src/components/ChatThread/widgets/FallbackWidget.tsx

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { TogglePanel } from '@dxos/react-ui-components';
+import { JsonHighlighter } from '@dxos/react-ui-syntax-highlighter';
+import { type XmlWidgetProps } from '@dxos/ui-editor';
+
+import { type MessageThreadContext } from '../sync';
+
+export const FallbackWidget = ({ _tag, ...props }: XmlWidgetProps<MessageThreadContext>) => {
+  return (
+    <TogglePanel.Root>
+      <TogglePanel.Header classNames='bg-group-surface'>{_tag}</TogglePanel.Header>
+      <TogglePanel.Content classNames='bg-modal-surface'>
+        <TogglePanel.Viewport>
+          <JsonHighlighter classNames='p-2! text-sm' data={props} />
+        </TogglePanel.Viewport>
+      </TogglePanel.Content>
+    </TogglePanel.Root>
+  );
+};
+
+FallbackWidget.displayName = 'Fallback';

package/src/components/ChatThread/widgets/PromptWidget.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { WidgetType } from '@codemirror/view';
+
+import { Domino } from '@dxos/ui';
+
+/**
+ * Simple prompt widget.
+ */
+export class PromptWidget extends WidgetType {
+  constructor(private text: string) {
+    super();
+  }
+
+  override eq(other: this) {
+    return this.text === other.text;
+  }
+
+  /**
+   * NOTE: An ancestor element must set `data-hue` so `.dx-panel` resolves to the user's hue tokens
+   * (see `packages/ui/ui-theme/src/css/components/panel.css`).
+   */
+  override toDOM() {
+    return Domino.of('div')
+      .classNames('flex justify-end my-2')
+      .append(Domino.of('div').classNames('dx-panel px-3 py-1.5 rounded-sm').text(this.text)).root;
+  }
+}

package/src/components/ChatThread/widgets/ReasoningWidget.stories.tsx

@@ -0,0 +1,68 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useEffect, useRef } from 'react';
+
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { ReasoningWidget } from './ReasoningWidget';
+
+export type DefaultStoryProps = {
+  text: string;
+};
+
+// TODO(burdon): Generalize factory for DOM widgets.
+const DefaultStory = ({ text }: DefaultStoryProps) => {
+  const hostRef = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    const host = hostRef.current;
+    if (!host) {
+      return;
+    }
+
+    host.replaceChildren();
+    const widget = new ReasoningWidget(text, 0);
+    const dom = widget.toDOM();
+    host.appendChild(dom);
+    widget.updateDOM(dom);
+    return () => {
+      widget.destroy(dom);
+      host.replaceChildren();
+    };
+  }, [text]);
+
+  return <div ref={hostRef} />;
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/components/ChatWidgets/ReasoningWidget',
+  component: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'column' })],
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    text: 'The user is asking about nested flex layouts and overflow. I should mention min-height 0 and grid track sizing.',
+  },
+};
+
+export const LongText: Story = {
+  args: {
+    text: [
+      'Step 1: Identify the scroll container and ensure it participates in a definite height chain.',
+      'Step 2: Apply min-h-0 to flex children that should shrink and scroll.',
+      'Step 3: Prefer overflow-y-auto on the leaf viewport, not on every ancestor.',
+      'Step 4: Use min-h-0 on the scroll container to ensure it participates in a definite height chain.',
+      'Step 5: Use min-w-0 on the scroll container to ensure it participates in a definite width chain.',
+    ].join('\n\n'),
+  },
+};

package/src/components/ChatThread/widgets/ReasoningWidget.ts

@@ -0,0 +1,133 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { WidgetType } from '@codemirror/view';
+
+import { Domino } from '@dxos/ui';
+
+/**
+ * Props used to derive a stable key for a reasoning block across CodeMirror widget rebuilds.
+ * CodeMirror does not assign persistent IDs to widgets; streaming re-runs the factory each tick.
+ */
+export type ReasoningWidgetBlockIdProps = {
+  id?: string;
+  range?: { from: number; to: number };
+};
+
+/**
+ * AI reasoning widget.
+ */
+export class ReasoningWidget extends WidgetType {
+  readonly #pos: string;
+  /** The timer id last registered for this instance (may differ from the map if superseded). */
+  #ownedTimerId: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(
+    private readonly text: string,
+    pos: string | number | undefined,
+  ) {
+    super();
+    this.#pos = pos === undefined || pos === '' ? 'reasoning' : String(pos);
+  }
+
+  override eq(other: this) {
+    return this.text === other.text && this.#pos === other.#pos;
+  }
+
+  override toDOM() {
+    const root = Domino.of('div')
+      .classNames('pt-2 pb-2')
+      .append(
+        Domino.of('div')
+          .classNames('relative overflow-hidden p-px rounded-sm border border-subdued-separator')
+          .attributes({ 'data-trail-container': '' })
+          .append(
+            Domino.of('div')
+              .classNames('relative z-10 bg-base-surface rounded-sm text-sm text-description px-2 py-1')
+              .append(
+                Domino.of('div')
+                  .classNames('max-h-[5lh] overflow-y-auto')
+                  .text(this.text)
+                  .attributes({ 'data-reasoning-text': '' }),
+              ),
+            Domino.of('div').attributes({ 'data-id': this.#pos }),
+          ),
+      ).root;
+
+    return root;
+  }
+
+  override updateDOM(dom: HTMLElement) {
+    // Update only the text leaf; `dom` may be wrapped in an outer shell, and the trail host is a
+    // sibling of the text node inside the bordered container — setting `textContent` on the wrong
+    // ancestor would remove `[data-id]`.
+    dom.querySelector<HTMLElement>('[data-reasoning-text]')?.replaceChildren(this.text);
+
+    // Recreate trail host if it was removed by a prior timeout (streaming paused > TRAIL_REMOVAL_DELAY_MS).
+    const container = dom.querySelector<HTMLElement>('[data-trail-container]');
+    let trailHost = container?.querySelector<HTMLElement>('[data-id]');
+    if (container && !trailHost) {
+      trailHost = Domino.of('div').attributes({ 'data-id': this.#pos }).root;
+      container.append(trailHost);
+    }
+    if (trailHost?.childElementCount === 0) {
+      trailHost.append(...createTrailLayers());
+    }
+
+    this.#scheduleTrailRemoval(dom);
+    return true;
+  }
+
+  override destroy(_dom: HTMLElement) {
+    this.#clearOwnedTrailTimer();
+  }
+
+  #scheduleTrailRemoval(dom: HTMLElement) {
+    const previous = trailRemovalTimers.get(this.#pos);
+    if (previous !== undefined) {
+      clearTimeout(previous);
+    }
+
+    const timerId = setTimeout(() => {
+      if (trailRemovalTimers.get(this.#pos) !== timerId) {
+        return;
+      }
+      trailRemovalTimers.delete(this.#pos);
+      this.#ownedTimerId = null;
+      dom.querySelector<HTMLElement>('[data-id]')?.remove();
+    }, TRAIL_REMOVAL_DELAY_MS);
+
+    trailRemovalTimers.set(this.#pos, timerId);
+    this.#ownedTimerId = timerId;
+  }
+
+  #clearOwnedTrailTimer() {
+    const active = trailRemovalTimers.get(this.#pos);
+    if (active !== undefined && active === this.#ownedTimerId) {
+      clearTimeout(active);
+      trailRemovalTimers.delete(this.#pos);
+    }
+    this.#ownedTimerId = null;
+  }
+}
+
+const trail = [
+  'absolute z-0 aspect-[2/1] w-16',
+  'bg-[radial-gradient(at_100%_50%,_theme(colors.green.700),_transparent_80%)]',
+  '[offset-anchor:100%_50%] [offset-path:border-box]',
+];
+
+/** Delay after the last content update before hiding the trail. */
+const TRAIL_REMOVAL_DELAY_MS = 1_000;
+
+/**
+ * One pending removal timer per logical block. Streaming creates a new widget instance each tick;
+ * `destroy` may run after the next instance has already scheduled, so we must not clear a newer timer.
+ */
+const trailRemovalTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+const createTrailLayers = (): [HTMLElement, HTMLElement] => [
+  Domino.of('div').classNames(...trail, 'animate-trail').root,
+  Domino.of('div').classNames(...trail, 'animate-trail-offset').root,
+];

package/src/components/ChatThread/widgets/ReferenceWidget.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { WidgetType } from '@codemirror/view';
+
+import { Domino } from '@dxos/ui';
+
+export class ReferenceWidget extends WidgetType {
+  constructor(
+    private text: string,
+    private dxn: string,
+  ) {
+    super();
+  }
+
+  override eq(other: this) {
+    return this.dxn === other.dxn;
+  }
+
+  override toDOM() {
+    return Domino.of('div')
+      .classNames('pt-2 pb-2')
+      .append(
+        Domino.of('dx-anchor' as any)
+          .classNames('dx-tag--anchor')
+          .attributes({ dxn: this.dxn })
+          .text(this.text),
+      ).root;
+  }
+}

package/src/components/ChatThread/widgets/SelectWidget.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { WidgetType } from '@codemirror/view';
+
+import { Domino } from '@dxos/ui';
+
+/**
+ * Simple prompt widget.
+ */
+export class SelectWidget extends WidgetType {
+  constructor(private options: string[]) {
+    super();
+  }
+
+  override eq(other: this) {
+    return JSON.stringify(this.options) === JSON.stringify(other.options);
+  }
+
+  /**
+   * NOTE: Container must set var based on user's identity.
+   */
+  override toDOM() {
+    return Domino.of('div')
+      .attributes({ role: 'group' })
+      .classNames('flex flex-wrap pt-2 pb-2 gap-1')
+      .append(
+        ...this.options.map((option) =>
+          Domino.of('button')
+            .classNames('dx-button inline-block max-w-[100cqi]')
+            .attributes({ 'data-action': 'submit', 'data-value': option, 'data-density': 'fine' })
+            .text(option),
+        ),
+      ).root;
+  }
+}

package/src/components/ChatThread/widgets/StatsWidget.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { WidgetType } from '@codemirror/view';
+
+import { Domino } from '@dxos/ui';
+
+/**
+ * Simple stats widget.
+ */
+export class StatsWidget extends WidgetType {
+  constructor(private text: string) {
+    super();
+  }
+
+  override eq(other: this) {
+    return this.text === other.text;
+  }
+
+  override toDOM() {
+    return Domino.of('div').classNames('pt-2 pb-4 text-sm text-placeholder').text(this.text).root;
+  }
+
+  override updateDOM(dom: HTMLElement) {
+    dom.textContent = this.text;
+    return true;
+  }
+}