@dxos/plugin-assistant 0.8.4-main.f5c0578 → 0.8.4-main.fcfe5033a5

package/src/containers/TracePanel/execution-graph.ts

@@ -0,0 +1,425 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AGENT_PROCESS_KEY, AgentRequestBegin, AgentRequestEnd, CompleteBlock } from '@dxos/assistant';
+import { Trace } from '@dxos/functions';
+import { Process } from '@dxos/functions-runtime';
+import { LogLevel } from '@dxos/log';
+import { type Commit } from '@dxos/react-ui-components';
+
+/**
+ * Branch name for top-level operation invocations.
+ */
+const MAIN_BRANCH = 'main';
+
+const ICONS = {
+  agentRequestBegin: {
+    icon: 'ph--atom--regular',
+    level: LogLevel.VERBOSE,
+  },
+  agentRequestEnd: {
+    icon: 'ph--check-circle--regular',
+    level: LogLevel.INFO,
+  },
+  userMessage: {
+    icon: 'ph--user--regular',
+    level: LogLevel.VERBOSE,
+  },
+  assistantMessage: {
+    icon: 'ph--drone--regular',
+    level: LogLevel.VERBOSE,
+  },
+  statusMessage: {
+    icon: 'ph--dot-outline--regular',
+    level: LogLevel.VERBOSE,
+  },
+  toolCall: {
+    icon: 'ph--wrench--regular',
+    level: LogLevel.VERBOSE,
+  },
+  toolResult: {
+    icon: 'ph--wrench--regular',
+    level: LogLevel.INFO,
+  },
+  toolResultError: {
+    icon: 'ph--wrench--regular',
+    level: LogLevel.ERROR,
+  },
+  toolResultSuccess: {
+    icon: 'ph--check-circle--regular',
+    level: LogLevel.INFO,
+  },
+  runningAgent: {
+    icon: 'ph--spinner-gap--regular',
+    level: LogLevel.INFO,
+  },
+  operationStart: {
+    icon: 'ph--play--regular',
+    level: LogLevel.VERBOSE,
+  },
+  operationEnd: {
+    icon: 'ph--check-circle--regular',
+    level: LogLevel.INFO,
+  },
+  operationEndError: {
+    icon: 'ph--x-circle--regular',
+    level: LogLevel.ERROR,
+  },
+  operationEndSuccess: {
+    icon: 'ph--check-circle--regular',
+    level: LogLevel.INFO,
+  },
+  agentRequestRunning: {
+    icon: 'ph--spinner-gap--regular',
+    level: LogLevel.INFO,
+  },
+} as const;
+
+const tagPid = (pid: string) => `pid:${pid}`;
+const tagParentPid = (parentPid: string) => `parent-pid:${parentPid}`;
+const tagConversation = (conversationId: string) => `conversation:${conversationId}`;
+const tagOperationBegin = (pid: string) => `operation-begin:${pid}`;
+
+const getTags = (meta: Trace.Meta) => {
+  const tags: string[] = [];
+  if (meta.pid) {
+    tags.push(tagPid(meta.pid));
+  }
+  if (meta.parentPid) {
+    tags.push(tagParentPid(meta.parentPid));
+  }
+  if (meta.conversationId) {
+    tags.push(tagConversation(meta.conversationId));
+  }
+  return tags;
+};
+
+export interface BuildExecutionGraphParams {
+  traceMessages: Trace.Message[];
+  activeProcesses?: readonly Process.Info[];
+  eventLimit?: number;
+}
+
+/**
+ * Builds a Timeline-compatible execution graph from trace messages and active processes.
+ * Pure function — no signals or atoms.
+ */
+export const buildExecutionGraph = ({
+  traceMessages,
+  activeProcesses = [],
+  eventLimit = 500,
+}: BuildExecutionGraphParams): { branches: string[]; commits: Commit[] } => {
+  const builder = new GraphBuilder();
+
+  const events = traceMessages.slice(-eventLimit).flatMap((message) =>
+    message.events.map((event: Trace.Event) => ({
+      id: message.id,
+      meta: message.meta,
+      ...event,
+    })),
+  );
+
+  builder.addBranch(MAIN_BRANCH);
+
+  for (const event of events) {
+    if (Trace.isOfType(AgentRequestBegin, event)) {
+      builder.addCommit({
+        id: event.id,
+        branch: event.meta.parentPid ?? MAIN_BRANCH,
+        parents: builder.computeParents([{ branch: event.meta.parentPid ?? MAIN_BRANCH }]),
+        tags: getTags(event.meta),
+        timestamp: new Date(event.timestamp),
+        icon: ICONS.agentRequestBegin.icon,
+        level: ICONS.agentRequestBegin.level,
+        message: 'Agent processing request...',
+      });
+    } else if (Trace.isOfType(AgentRequestEnd, event)) {
+      builder.addCommit({
+        id: event.id,
+        branch: event.meta.parentPid ?? MAIN_BRANCH,
+        parents: builder.computeParents([
+          { branch: event.meta.parentPid ?? MAIN_BRANCH },
+          { commit: { tags: [event.meta.pid && tagPid(event.meta.pid)] } },
+        ]),
+        tags: getTags(event.meta),
+        timestamp: new Date(event.timestamp),
+        icon: ICONS.agentRequestEnd.icon,
+        level: ICONS.agentRequestEnd.level,
+        message: 'Agent completed request',
+      });
+    } else if (Trace.isOfType(CompleteBlock, event)) {
+      switch (event.data.block._tag) {
+        case 'text': {
+          if (event.data.role === 'user') {
+            builder.addCommit({
+              id: event.id,
+              branch: event.meta.pid ?? MAIN_BRANCH,
+              parents: builder.computeParents([
+                {
+                  branch: event.meta.pid ?? MAIN_BRANCH,
+                  fallback: { tags: [event.meta.pid && tagPid(event.meta.pid)] },
+                },
+              ]),
+              tags: getTags(event.meta),
+              timestamp: new Date(event.timestamp),
+              icon: ICONS.userMessage.icon,
+              level: ICONS.userMessage.level,
+              message: trimText(event.data.block.text),
+            });
+          }
+          break;
+        }
+        case 'status': {
+          builder.addCommit({
+            id: event.id,
+            branch: event.meta.pid ?? MAIN_BRANCH,
+            parents: builder.computeParents([
+              {
+                branch: event.meta.pid ?? MAIN_BRANCH,
+                fallback: { tags: [event.meta.pid && tagPid(event.meta.pid)] },
+              },
+            ]),
+            tags: getTags(event.meta),
+            timestamp: new Date(event.timestamp),
+            icon: ICONS.statusMessage.icon,
+            level: ICONS.statusMessage.level,
+            message: trimText(event.data.block.statusText),
+          });
+          break;
+        }
+        case 'toolCall': {
+          builder.addCommit({
+            id: `${event.data.block.toolCallId}:call`,
+            branch: event.meta.pid ?? MAIN_BRANCH,
+            parents: builder.computeParents([
+              {
+                branch: event.meta.pid ?? MAIN_BRANCH,
+                fallback: { tags: [event.meta.pid && tagPid(event.meta.pid)] },
+              },
+            ]),
+            tags: getTags(event.meta),
+            timestamp: new Date(event.timestamp),
+            icon: ICONS.toolCall.icon,
+            level: ICONS.toolCall.level,
+            message: event.data.block.name,
+          });
+          break;
+        }
+        case 'toolResult': {
+          builder.addCommit(
+            {
+              id: `${event.data.block.toolCallId}:result`,
+              branch: event.meta.pid ?? MAIN_BRANCH,
+              parents: builder.computeParents([
+                {
+                  branch: event.meta.pid ?? MAIN_BRANCH,
+                  fallback: { tags: [event.meta.pid && tagPid(event.meta.pid)] },
+                },
+              ]),
+              tags: getTags(event.meta),
+              timestamp: new Date(event.timestamp),
+              icon: event.data.block.error ? ICONS.toolResultError.icon : ICONS.toolResultSuccess.icon,
+              level: event.data.block.error ? ICONS.toolResultError.level : ICONS.toolResultSuccess.level,
+              message: event.data.block.error
+                ? `${event.data.block.name} - Error: ${trimText(event.data.block.error)}`
+                : `${event.data.block.name} - Success`,
+            },
+            {
+              replace: {
+                id: [`${event.data.block.toolCallId}:call`],
+              },
+            },
+          );
+          break;
+        }
+      }
+    } else if (Trace.isOfType(Trace.OperationStart, event)) {
+      if (!event.meta.conversationId) {
+        // Ignoring tool calls.
+        builder.addCommit({
+          id: `${event.id}:${event.data.key}:start`,
+          branch: event.meta.parentPid ?? MAIN_BRANCH,
+          parents: builder.computeParents([
+            {
+              branch: event.meta.parentPid ?? MAIN_BRANCH,
+              fallback: { tags: [event.meta.parentPid && tagPid(event.meta.parentPid)] },
+            },
+          ]),
+          tags: [...getTags(event.meta), tagOperationBegin(event.meta.pid ?? 'unknown')],
+          timestamp: new Date(event.timestamp),
+          icon: ICONS.operationStart.icon,
+          level: ICONS.operationStart.level,
+          message: event.data.name ?? event.data.key,
+        });
+      }
+    } else if (Trace.isOfType(Trace.OperationEnd, event)) {
+      if (!event.meta.conversationId) {
+        // Ignoring tool calls.
+        const children = builder.findCommits({ tags: [event.meta.pid && tagPid(event.meta.pid)] });
+        builder.addCommit(
+          {
+            id: `${event.id}:${event.data.key}:end`,
+            branch: event.meta.parentPid ?? MAIN_BRANCH,
+            parents: builder.computeParents([
+              {
+                branch: event.meta.parentPid ?? MAIN_BRANCH,
+                fallback: { tags: [event.meta.parentPid && tagPid(event.meta.parentPid)] },
+              },
+              { commit: { tags: [event.meta.pid && tagPid(event.meta.pid)] } },
+            ]),
+            tags: getTags(event.meta),
+            timestamp: new Date(event.timestamp),
+            icon: event.data.outcome === 'success' ? ICONS.operationEndSuccess.icon : ICONS.operationEndError.icon,
+            level: event.data.outcome === 'success' ? ICONS.operationEndSuccess.level : ICONS.operationEndError.level,
+            message: event.data.name ?? event.data.key,
+          },
+          {
+            replace:
+              // TODO(dmaretskyi): Deduping events in subbranches brekas graph.
+              !event.meta.parentPid && children.length > 1 // 1 is the operation begin commit.
+                ? undefined
+                : {
+                    tags: [tagOperationBegin(event.meta.pid ?? 'unknown')],
+                  },
+          },
+        );
+      }
+    }
+  }
+
+  for (const process of activeProcesses) {
+    if (
+      process.key === AGENT_PROCESS_KEY &&
+      process.params.target &&
+      (process.state === Process.State.RUNNING || process.state === Process.State.HYBERNATING)
+    ) {
+      builder.addCommit({
+        id: `running:${process.pid}`,
+        branch: process.pid,
+        parents: builder.computeParents([{ branch: process.pid }]),
+        icon: ICONS.agentRequestRunning.icon,
+        level: ICONS.agentRequestRunning.level,
+        message: 'Generating...',
+        timestamp: new Date(),
+      });
+    }
+  }
+
+  return builder.build();
+};
+
+type Falsy = false | null | undefined;
+type MaybeFalsy<T> = T | Falsy;
+
+type CommitSelector = { id?: MaybeFalsy<string>[]; tags?: MaybeFalsy<string>[] };
+
+class GraphBuilder {
+  #commits: Commit[] = [];
+  #branches = new Set<string>();
+
+  findCommits(selector: CommitSelector) {
+    return this.#commits.filter((commit) => {
+      if (selector.id && selector.id.includes(commit.id)) {
+        return true;
+      }
+      if (selector.tags && selector.tags.some((tag) => tag && commit.tags?.includes(tag))) {
+        return true;
+      }
+      return false;
+    });
+  }
+
+  addCommit(
+    commit: Commit,
+    opts?: {
+      ifMissing?: CommitSelector;
+      /**
+       * Replace in-place the last commit that matches the selector.
+       */
+      replace?: CommitSelector;
+    },
+  ) {
+    if (opts?.ifMissing) {
+      const commits = this.findCommits(opts.ifMissing);
+      if (commits.length > 0) {
+        return;
+      }
+    }
+    this.addBranch(commit.branch);
+    if (opts?.replace) {
+      const commits = this.findCommits(opts.replace);
+      if (commits.length > 0) {
+        this.#commits[this.#commits.indexOf(commits.at(-1)!)] = commit;
+        return;
+      }
+    }
+    this.#commits.push(commit);
+  }
+
+  removeCommit(selector: CommitSelector) {
+    const commits = this.findCommits(selector);
+    for (const commit of commits) {
+      this.#commits.splice(this.#commits.indexOf(commit), 1);
+    }
+  }
+
+  /**
+   * Computes parents based on a list of specs.
+   */
+  computeParents(
+    specs: (
+      | {
+          /**
+           * Parent commits selector.
+           */
+          commit?: CommitSelector;
+        }
+      | {
+          /**
+           * Last commit on this branch as parent.
+           */
+          branch?: string;
+
+          /**
+           * Fallback if branch has no commits.
+           */
+          fallback?: CommitSelector;
+        }
+    )[],
+  ): string[] {
+    return specs.flatMap((spec) => {
+      if ('commit' in spec && spec.commit) {
+        return this.findCommits(spec.commit)
+          .slice(-1)
+          .map((commit) => commit.id);
+      }
+      if ('branch' in spec && spec.branch) {
+        const lastCommit = this.#commits.findLast((commit) => commit.branch === spec.branch);
+        if (lastCommit) {
+          return [lastCommit.id];
+        } else if (spec.fallback) {
+          return this.findCommits(spec.fallback)
+            .slice(-1)
+            .map((commit) => commit.id);
+        } else {
+          return [];
+        }
+      }
+      return [];
+    });
+  }
+
+  addBranch(branch: string) {
+    this.#branches.add(branch);
+  }
+
+  build() {
+    return {
+      commits: this.#commits,
+      branches: [...this.#branches],
+    };
+  }
+}
+
+const trimText = (text: string) => text.slice(0, 100).trim().split('\n')[0];

package/src/containers/TracePanel/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { TracePanel } from './TracePanel';
+
+export * from './TracePanel';
+
+export default TracePanel;

package/src/containers/TriggerStatus/TriggerStatus.tsx

@@ -0,0 +1,144 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { useActiveSpace } from '@dxos/app-toolkit/ui';
+import { type InvocationsState } from '@dxos/functions-runtime';
+import { useTriggerRuntimeControls } from '@dxos/plugin-automation/hooks';
+import { StatusBar } from '@dxos/plugin-status-bar';
+import { type Database } from '@dxos/react-client/echo';
+import { IconButton, Input, Popover, useTranslation } from '@dxos/react-ui';
+
+import { meta } from '#meta';
+
+type TriggerStatusState = 'disabled' | 'idle' | 'running' | 'error';
+
+const getIcon = (state: TriggerStatusState): string => {
+  switch (state) {
+    case 'disabled':
+      return 'ph--lightning-slash--regular';
+    case 'idle':
+      return 'ph--lightning--regular';
+    case 'running':
+      return 'ph--lightning--fill';
+    case 'error':
+      return 'ph--warning--regular';
+  }
+};
+
+const getIconClassNames = (state: TriggerStatusState): string | undefined => {
+  switch (state) {
+    case 'running':
+      return 'animate-pulse text-accent-text';
+    case 'error':
+      return 'text-error-text';
+    default:
+      return undefined;
+  }
+};
+
+export const TriggerStatus = () => {
+  const space = useActiveSpace();
+  const db = space?.db;
+  if (!db) {
+    return null;
+  }
+
+  return <SpaceStatusMain db={db} />;
+};
+
+const SpaceStatusMain = ({ db }: { db: Database.Database }) => {
+  const { t } = useTranslation(meta.id);
+  const { state, start, stop } = useTriggerRuntimeControls(db);
+  const isRunning = state?.enabled ?? false;
+
+  // Determine the current trigger status state.
+  const triggerState: TriggerStatusState = useMemo(() => {
+    if (!isRunning) {
+      return 'disabled';
+    }
+
+    // Check if there's any pending invocation.
+    const hasPending = state?.invocations.some((invocation) => invocation.result === null);
+    if (hasPending) {
+      return 'running';
+    }
+
+    // Check if the last invocation failed.
+    const lastInvocation = state?.invocations.at(-1);
+    if (lastInvocation?.result?._tag === 'Failure') {
+      return 'error';
+    }
+
+    return 'idle';
+  }, [isRunning, state?.invocations]);
+
+  return (
+    <Popover.Root>
+      <Popover.Trigger asChild>
+        <StatusBar.Item>
+          <IconButton
+            icon={getIcon(triggerState)}
+            iconOnly
+            label={t(`trigger-status-${triggerState}.label`)}
+            classNames={getIconClassNames(triggerState)}
+          />
+        </StatusBar.Item>
+      </Popover.Trigger>
+      <Popover.Portal>
+        <Popover.Content side='left'>
+          <TriggerStatusPopover
+            isRunning={isRunning}
+            state={triggerState}
+            currentFunctionName={
+              state?.invocations.at(-1)?.function?.meta.name ?? state?.invocations.at(-1)?.function?.meta.key
+            }
+            lastInvocation={state?.invocations.at(-1)}
+            onToggle={isRunning ? stop : start}
+          />
+          <Popover.Arrow />
+        </Popover.Content>
+      </Popover.Portal>
+    </Popover.Root>
+  );
+};
+
+type TriggerStatusPopoverProps = {
+  isRunning: boolean;
+  state: TriggerStatusState;
+  currentFunctionName?: string;
+  lastInvocation?: InvocationsState;
+  onToggle: () => void;
+};
+
+const TriggerStatusPopover = ({
+  isRunning,
+  state,
+  currentFunctionName,
+  lastInvocation, // TODO(burdon): Show.
+  onToggle,
+}: TriggerStatusPopoverProps) => {
+  const { t } = useTranslation(meta.id);
+
+  return (
+    <div className='flex flex-col gap-2 p-2 w-[240px]'>
+      <Input.Root>
+        <div className='flex items-center gap-2'>
+          <Input.Switch checked={isRunning} onCheckedChange={onToggle} />
+          <Input.Label>{t('trigger-runtime.label')}</Input.Label>
+        </div>
+      </Input.Root>
+
+      <div className='flex flex-col gap-1'>
+        <div className='text-sm'>{t(`trigger-status-${state}.label`)}</div>
+        {currentFunctionName && state === 'running' && (
+          <div className='text-xs text-description'>{currentFunctionName}</div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default TriggerStatus;

package/src/containers/TriggerStatus/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { TriggerStatus as default } from './TriggerStatus';

package/src/containers/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const BlueprintArticle: ComponentType<any> = lazy(() => import('./BlueprintArticle'));
+export const ChatCompanion: ComponentType<any> = lazy(() => import('./ChatCompanion'));
+export const ChatContainer: ComponentType<any> = lazy(() => import('./ChatContainer'));
+export const ChatDialog: ComponentType<any> = lazy(() => import('./ChatDialog'));
+export const AgentArticle: ComponentType<any> = lazy(() => import('./AgentArticle'));
+export const AgentProperties: ComponentType<any> = lazy(() => import('./AgentProperties'));
+export const PromptArticle: ComponentType<any> = lazy(() => import('./PromptArticle'));
+export const PromptList: ComponentType<any> = lazy(() => import('./PromptList'));
+export const TracePanel: ComponentType<any> = lazy(() => import('./TracePanel'));
+export const TriggerStatus: ComponentType<any> = lazy(() => import('./TriggerStatus'));

package/src/extensions/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { promptRunExtension, type PromptExtensionOptions } from './prompt-extension';