@dxos/plugin-assistant 0.8.4-main.67995b8 → 0.8.4-main.f5c0578

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

@@ -0,0 +1,184 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AgentStatus } from '@dxos/ai';
+import { Obj, type Ref } from '@dxos/echo';
+import { MESSAGE_PROPERTY_TOOL_CALL_ID } from '@dxos/functions';
+import type { ObjectId } from '@dxos/keys';
+import { DataType } from '@dxos/schema';
+
+import type { Branch, Commit } from '../components';
+
+// TODO(dmaretskyi): Deduplicate. Importing from components causes an error.
+enum IconType {
+  // General status.
+  WARN = 'ph--warning-circle--regular',
+  CHECK = 'ph--check-circle--regular',
+  ROCKET = 'ph--rocket--regular',
+  X = 'ph--x-circle--regular',
+  FLAG = 'ph--flag--regular',
+  TIMER = 'ph--timer--regular',
+
+  // Interactions.
+  USER = 'ph--user--regular',
+  USER_INTERACTION = 'ph--user-sound--regular',
+  AGENT = 'ph--robot--regular',
+  THINK = 'ph--brain--regular',
+  LINK = 'ph--link--regular',
+  TOOL = 'ph--wrench--regular',
+}
+
+/**
+ * Models the execution graph based on a stream of events.
+ */
+export class ExecutionGraph {
+  // TODO(dmaretskyi): Evolve the internal state to support chats, functions, circuit workflows, etc.
+  private _commits: Commit[] = [];
+  private _branchNames = new Set<string>();
+
+  /**
+   * Adds events to the graph.
+   */
+  addEvents(events: Obj.Any[]) {
+    for (const event of events) {
+      if (Obj.instanceOf(DataType.Message, event)) {
+        const messageCommits = chatMessageToCommit(event);
+        this._commits.push(...messageCommits);
+        messageCommits.map((c) => c.branch).forEach((branch) => this._branchNames.add(branch));
+      } else if (Obj.instanceOf(AgentStatus, event)) {
+        const branch = getBranchName({ parentMessage: event.parentMessage, toolCallId: event.toolCallId });
+        this._branchNames.add(branch);
+        this._commits.push({
+          id: event.id,
+          branch,
+          message: event.message,
+          icon: IconType.FLAG,
+          parent:
+            event.parentMessage && event.toolCallId ? getToolCallId(event.parentMessage, event.toolCallId) : undefined,
+        });
+      }
+    }
+  }
+
+  /**
+   * Returns the current state of the graph.
+   */
+  getGraph(): { commits: Commit[]; branches: Branch[] } {
+    return {
+      commits: this._commits,
+      branches: Array.from(this._branchNames).map((name) => ({ name })),
+    };
+  }
+}
+
+const getToolCallId = (messageId: ObjectId, toolCallId: string) => `${messageId}_toolCall_${toolCallId}`;
+const getToolResultId = (messageId: ObjectId, toolCallId: string) => `${messageId}_toolResult_${toolCallId}`;
+const getGenericBlockId = (messageId: ObjectId, idx: number) => `${messageId}_block_${idx}`;
+
+const getBranchName = (opts: { parentMessage?: ObjectId; toolCallId?: string }) => {
+  if (opts.parentMessage && opts.toolCallId) {
+    return `${opts.parentMessage}_${opts.toolCallId}`;
+  } else if (opts.parentMessage) {
+    return opts.parentMessage;
+  } else {
+    return 'main';
+  }
+};
+
+const getMessageBranch = (message: DataType.Message) => {
+  return getBranchName({
+    parentMessage: message.parentMessage,
+    toolCallId: message.properties?.[MESSAGE_PROPERTY_TOOL_CALL_ID],
+  });
+};
+
+const getParentId = (message: DataType.Message) => {
+  if (message.parentMessage && message.properties?.[MESSAGE_PROPERTY_TOOL_CALL_ID]) {
+    return getToolCallId(message.parentMessage, message.properties[MESSAGE_PROPERTY_TOOL_CALL_ID]);
+  } else {
+    return undefined;
+  }
+};
+
+const chatMessageToCommit = (message: DataType.Message): Commit[] => {
+  return message.blocks.map((block, idx) => {
+    const branch = getMessageBranch(message);
+    const parent = getParentId(message);
+    switch (block._tag) {
+      case 'toolCall':
+        return {
+          id: getToolCallId(message.id, block.toolCallId),
+          branch,
+          parent,
+          icon: IconType.TOOL,
+          message: block.name,
+        };
+      case 'toolResult':
+        return {
+          id: getToolResultId(message.id, block.toolCallId),
+          branch,
+          parent,
+          icon: block.error ? IconType.X : IconType.CHECK,
+          message: block.error ? block.error : block.name,
+        };
+      case 'status':
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parent,
+          message: block.statusText,
+          icon: IconType.FLAG,
+        };
+      case 'reasoning':
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parent,
+          message: block.reasoningText ?? 'Thinking...',
+          icon: IconType.THINK,
+        };
+      case 'text':
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parent,
+          icon: message.sender.role === 'user' ? IconType.USER : IconType.AGENT,
+          message: ellipsisEnd(block.text, 64),
+        };
+      case 'reference':
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parent,
+          icon: IconType.LINK,
+          message: stringifyRef(block.reference),
+        };
+      default:
+        return {
+          id: getGenericBlockId(message.id, idx),
+          branch,
+          parent,
+          message: block._tag,
+        };
+    }
+  });
+};
+
+const ellipsisEnd = (str: string, length: number) => {
+  if (str.length > length) {
+    return str.slice(0, length - 1) + '…';
+  }
+  return str;
+};
+
+const stringifyRef = (ref: Ref.Any) => {
+  if (ref.target) {
+    return stringifyObject(ref.target);
+  }
+  return ref.dxn.asEchoDXN()?.echoId ?? ref.dxn.asQueueDXN()?.objectId ?? '';
+};
+
+const stringifyObject = (obj: Obj.Any) => {
+  return Obj.getLabel(obj) ?? Obj.getTypename(obj) ?? obj.id;
+};

package/src/execution-graph/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './execution-graph';

package/src/functions/analysis.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Schema } from 'effect';
+
+import { defineFunction } from '@dxos/functions';
+import { log } from '@dxos/log';
+
+export default defineFunction({
+  name: 'dxos.org/function/assistant-analysis',
+  description: 'Enter analysis analysis mode.',
+  inputSchema: Schema.Struct({
+    enable: Schema.Boolean.annotations({ description: 'Enable or disable analysis mode.' }),
+  }),
+  outputSchema: Schema.Void,
+  handler: Effect.fn(function* ({ data: { enable } }) {
+    log.info('analysis mode', { enable });
+  }),
+});

package/src/functions/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as analysis } from './analysis';
+export { default as list } from './list';
+export { default as load } from './load';

package/src/functions/list.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Schema } from 'effect';
+
+import { Filter, Obj, Query } from '@dxos/echo';
+import { DatabaseService, defineFunction } from '@dxos/functions';
+import { trim } from '@dxos/util';
+
+// TODO(burdon): Factor out to space plugin.
+export default defineFunction({
+  name: 'dxos.org/function/assistant/list',
+  description:
+    // TODO(wittjosiah): Find a better way to prompt for looking up typenames before querying with them.
+    trim`
+      Lists the objects of the given type.
+      Check the list-schemas tool for available types before calling this function.
+    `,
+  inputSchema: Schema.Struct({
+    typename: Schema.String.annotations({
+      description: 'The typename of the objects to list.',
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    results: Schema.Array(
+      Schema.Struct({
+        dxn: Schema.String.annotations({ description: 'The DXN of the object.' }),
+        label: Schema.optional(Schema.String.annotations({ description: 'The label of the object.' })),
+      }),
+    ),
+  }),
+  handler: Effect.fn(function* ({ data: { typename } }) {
+    const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.typename(typename)));
+    const results = objects.map((object) => ({
+      dxn: Obj.getDXN(object).toString(),
+      label: Obj.getLabel(object),
+    }));
+
+    return { results };
+  }),
+});

package/src/functions/load.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Option, Schema, pipe } from 'effect';
+
+import { ArtifactId } from '@dxos/assistant';
+import { Obj } from '@dxos/echo';
+import { DatabaseService, defineFunction } from '@dxos/functions';
+import { log } from '@dxos/log';
+
+// TODO(burdon): Common error handling.
+// TODO(burdon): Factor out to space plugin.
+export default defineFunction({
+  name: 'dxos.org/function/assistant/load',
+  description: 'Loads the object.',
+  inputSchema: Schema.Struct({
+    id: ArtifactId.annotations({
+      description: 'The ID of the object.',
+    }),
+    typename: Schema.String.annotations({
+      description: 'The typename of the object.',
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    // TODO(wittjosiah): Type.Obj.Any | Type.Relation.Any
+    object: Schema.Any,
+  }),
+  handler: Effect.fn(function* ({ data: { id, typename } }) {
+    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id));
+    return yield* pipe(
+      Option.fromNullable(object),
+      Option.flatMap((object) => (Obj.getTypename(object) === typename ? Option.some(object) : Option.none())),
+      Option.match({
+        onNone: () => Effect.fail('Object not found.'),
+        onSome: (object) => {
+          log.info('object', { object });
+          return Effect.succeed({ object });
+        },
+      }),
+    );
+  }),
+});