@dxos/plugin-assistant 0.8.4-main.dedc0f3 → 0.8.4-main.ead640a

package/src/capabilities/compute-runtime.ts

@@ -1,124 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type AiTool, AiToolkit } from '@effect/ai';
-import { BrowserKeyValueStore } from '@effect/platform-browser';
-import { Effect, Layer, ManagedRuntime } from 'effect';
-
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
-import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
-import { PropertiesType } from '@dxos/client/echo';
-import { Resource } from '@dxos/context';
-import { Query, Ref } from '@dxos/echo';
-import {
-  CredentialsService,
-  DatabaseService,
-  FunctionImplementationResolver,
-  InvocationTracer,
-  LocalFunctionExecutionService,
-  QueueService,
-  RemoteFunctionExecutionService,
-  TriggerDispatcher,
-} from '@dxos/functions';
-import { TriggerStateStore } from '@dxos/functions';
-import { invariant } from '@dxos/invariant';
-import { type SpaceId } from '@dxos/keys';
-import { ClientCapabilities } from '@dxos/plugin-client';
-
-import { AssistantCapabilities } from './capabilities';
-
-export default async (context: PluginContext) => {
-  const provider = await new ComputeRuntimeProviderImpl(context).open();
-  return contributes(AssistantCapabilities.ComputeRuntime, provider, async () => {
-    await provider.close();
-  });
-};
-
-class ComputeRuntimeProviderImpl extends Resource implements AssistantCapabilities.ComputeRuntimeProvider {
-  readonly #runtimes = new Map<SpaceId, ManagedRuntime.ManagedRuntime<AssistantCapabilities.ComputeServices, never>>();
-  readonly #context: PluginContext;
-
-  constructor(context: PluginContext) {
-    super();
-    this.#context = context;
-  }
-
-  protected override async _open() {}
-
-  protected override async _close() {
-    await Promise.all(Array.from(this.#runtimes.values()).map((rt) => rt.dispose()));
-    this.#runtimes.clear();
-  }
-
-  getRuntime(spaceId: SpaceId): ManagedRuntime.ManagedRuntime<AssistantCapabilities.ComputeServices, never> {
-    if (this.#runtimes.has(spaceId)) {
-      return this.#runtimes.get(spaceId)!;
-    }
-
-    const layer = Layer.unwrapEffect(
-      Effect.gen(this, function* () {
-        const client = this.#context.getCapability(ClientCapabilities.Client);
-        const serviceLayer =
-          this.#context.getCapability(AssistantCapabilities.AiServiceLayer) ?? Layer.die('AiService not found');
-
-        // TODO(dmaretskyi): Make those reactive.
-        const functions = this.#context.getCapabilities(Capabilities.Functions);
-        const toolkits = this.#context.getCapabilities(Capabilities.Toolkit);
-        const handlers = this.#context.getCapabilities(Capabilities.ToolkitHandler);
-
-        const allFunctions = functions.flat();
-        // TODO(wittjosiah): Don't cast.
-        const toolkit = AiToolkit.merge(...toolkits) as AiToolkit.Any as AiToolkit.AiToolkit<AiTool.Any>;
-        const handlersLayer = Layer.mergeAll(Layer.empty, ...handlers);
-
-        const space = client.spaces.get(spaceId);
-        invariant(space);
-        yield* Effect.promise(() => space.waitUntilReady());
-
-        return Layer.mergeAll(TriggerDispatcher.layer({ timeControl: 'natural' })).pipe(
-          Layer.provideMerge(
-            Layer.mergeAll(
-              IvocationTracerLive,
-              TriggerStateStore.layerKv.pipe(Layer.provide(BrowserKeyValueStore.layerLocalStorage)),
-              serviceLayer,
-              makeToolResolverFromFunctions(allFunctions, toolkit),
-              makeToolExecutionServiceFromFunctions(allFunctions, toolkit, handlersLayer),
-              CredentialsService.layerFromDatabase(),
-            ),
-          ),
-          Layer.provideMerge(
-            Layer.mergeAll(
-              space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable,
-              space ? QueueService.layer(space.queues) : QueueService.notAvailable,
-              LocalFunctionExecutionService.layerLive,
-              RemoteFunctionExecutionService.mockLayer,
-            ),
-          ),
-          Layer.provideMerge(FunctionImplementationResolver.layerTest({ functions: allFunctions })),
-        );
-      }),
-    );
-
-    const runtime = ManagedRuntime.make(layer);
-    this.#runtimes.set(spaceId, runtime);
-
-    return runtime;
-  }
-}
-
-const IvocationTracerLive = Layer.unwrapEffect(
-  Effect.gen(function* () {
-    const {
-      objects: [properties],
-    } = yield* DatabaseService.runQuery(Query.type(PropertiesType));
-    invariant(properties);
-    if (!properties.invocationTraceQueue) {
-      const queue = yield* QueueService.createQueue({ subspaceTag: 'trace' });
-      properties.invocationTraceQueue = Ref.fromDXN(queue.dxn);
-    }
-    const queue = properties.invocationTraceQueue.target;
-    invariant(queue);
-    return InvocationTracer.layerLive({ invocationTraceQueue: queue });
-  }),
-);

package/src/components/PromptSettings.tsx

@@ -1,90 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { type Template } from '@dxos/blueprints';
-import { Toolbar, useTranslation } from '@dxos/react-ui';
-
-import { meta } from '../meta';
-
-export const PromptSettings = ({ template }: { template: Template.Template }) => {
-  const { t } = useTranslation(meta.id);
-
-  // const handleKindChange = useCallback(
-  //   (value: string) => {
-  //     const kind = Match.type<string>().pipe(
-  //       Match.withReturnType<Schema.Schema.Type<typeof Template.Template>>(),
-  //       Match.when('always', () => ({ include: 'always' })),
-  //       Match.when('schema-matching', () => ({ include: 'schema-matching', typename: '' })),
-  //       Match.when('automatically', () => ({ include: 'automatically', description: '' })),
-  //       Match.orElse(() => ({ include: 'manual' })),
-  //     )(value);
-  //
-  //     template.kind = kind;
-  //   },
-  //   [template],
-  // );
-
-  // const handleTypenameChange = useCallback(
-  //   debounce((event: ChangeEvent<HTMLInputElement>) => {
-  //     if (template.kind.include === 'schema-matching') {
-  //       template.kind.typename = event.target.value;
-  //     }
-  //   }, 300),
-  //   [template.kind.include],
-  // );
-
-  // const handleDescriptionChange = useCallback(
-  //   debounce((event: ChangeEvent<HTMLInputElement>) => {
-  //     if (template.kind.include === 'automatically') {
-  //       template.kind.description = event.target.value;
-  //     }
-  //   }, 300),
-  //   [template.kind.include],
-  // );
-
-  return (
-    <div className='flex flex-col gap-4'>
-      <h2>{t('prompt rules label')}</h2>
-      <Toolbar.Root>
-        {/* <Select.Root value={template.kind.include} onValueChange={handleKindChange}>
-          <Toolbar.Button asChild>
-            <Select.TriggerButton />
-          </Toolbar.Button>
-          <Select.Portal>
-            <Select.Content>
-              <Select.Viewport>
-                {Template.Kinds.map((kind) => (
-                  <Select.Option key={kind} value={kind}>
-                    {kind}
-                  </Select.Option>
-                ))}
-              </Select.Viewport>
-              <Select.Arrow />
-            </Select.Content>
-          </Select.Portal>
-        </Select.Root> */}
-        {/* {template.kind.include === 'schema-matching' && (
-          <Input.Root>
-            <Input.TextInput
-              placeholder={t('typename placeholder')}
-              defaultValue={template.kind.typename}
-              onChange={handleTypenameChange}
-            />
-          </Input.Root>
-        )} */}
-        {/* {template.kind.include === 'automatically' && (
-          <Input.Root>
-            <Input.TextInput
-              placeholder={t('description placeholder')}
-              defaultValue={template.kind.description}
-              onChange={handleDescriptionChange}
-            />
-          </Input.Root>
-        )} */}
-      </Toolbar.Root>
-    </div>
-  );
-};

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

@@ -1,211 +0,0 @@
-//
-// 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 { LogLevel } from '@dxos/log';
-import { type Commit } from '@dxos/react-ui-components';
-import { ContentBlock, DataType } from '@dxos/schema';
-import { isNotFalsy } from '@dxos/util';
-
-// TODO(burdon): Move to assistant.
-
-// TODO(burdon): Add colors?
-enum IconType {
-  // General status.
-  SUCCESS = 'ph--check-circle--regular',
-  WARNING = 'ph--warning-circle--regular',
-  ERROR = 'ph--x-circle--regular',
-  FLAG = 'ph--flag--regular',
-  ROCKET = 'ph--rocket--regular',
-  TIMER = 'ph--timer--regular',
-
-  // Interactions.
-  USER = 'ph--user--regular',
-  USER_INTERACTION = 'ph--user-sound--regular',
-  AGENT = 'ph--robot--regular',
-  THINKING = '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 = messageToCommit(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,
-          parents:
-            event.parentMessage && event.toolCallId
-              ? [getToolCallId(event.parentMessage, event.toolCallId)]
-              : undefined, // TODO(burdon): Fix.
-        });
-      }
-    }
-  }
-
-  /**
-   * Returns the current state of the graph.
-   */
-  getGraph(lastRequest = false): { branches: string[]; commits: Commit[] } {
-    const idx = lastRequest ? this._commits.findLastIndex((c) => c.tags?.includes('user')) : -1;
-    const commits = idx === -1 ? this._commits : this._commits.slice(idx);
-
-    return {
-      branches: Array.from(this._branchNames),
-      commits: commits,
-    };
-  }
-}
-
-// TODO(burdon): Pass in AiToolProvider.
-const messageToCommit = (message: DataType.Message): Commit[] => {
-  return message.blocks
-    .map((block, idx) => {
-      const branch = getMessageBranch(message);
-      const parent = getParentId(message);
-      const parents = parent ? [parent] : [];
-      switch (block._tag) {
-        case 'text':
-          if (!block.text.trim().length) {
-            return null;
-          }
-          return {
-            id: getGenericBlockId(message.id, idx),
-            branch,
-            parents,
-            ...(message.sender.role === 'user'
-              ? {
-                  icon: IconType.USER,
-                  tags: ['user'],
-                  message: 'Processing request...',
-                }
-              : {
-                  icon: IconType.AGENT,
-                  message: `Response (${block.text.split(' ').length} words)`,
-                }),
-          } satisfies Commit;
-        case 'toolCall':
-          return {
-            id: getToolCallId(message.id, block.toolCallId),
-            branch,
-            parents,
-            icon: IconType.TOOL,
-            level: LogLevel.INFO,
-            // TODO(burdon): Lookup tool name/description?
-            message: `Calling tool (${block.name})`,
-          } satisfies Commit;
-        case 'toolResult':
-          return {
-            id: getToolResultId(message.id, block.toolCallId),
-            branch,
-            parents,
-            icon: block.error ? IconType.ERROR : IconType.SUCCESS,
-            level: block.error ? LogLevel.ERROR : LogLevel.INFO,
-            message: block.error ? 'Tool error: ' + block.error : 'Tool call succeeded',
-          } satisfies Commit;
-        case 'summary':
-          return {
-            id: getGenericBlockId(message.id, idx),
-            branch,
-            parents,
-            icon: IconType.ROCKET,
-            level: LogLevel.INFO,
-            message: ContentBlock.createSummaryMessage(block),
-          } satisfies Commit;
-        case 'status':
-          return {
-            id: getGenericBlockId(message.id, idx),
-            branch,
-            parents,
-            message: block.statusText,
-            level: LogLevel.INFO,
-            icon: IconType.FLAG,
-          } satisfies Commit;
-        case 'reasoning':
-          return {
-            id: getGenericBlockId(message.id, idx),
-            branch,
-            parents,
-            message: block.reasoningText ?? 'Thinking...',
-            icon: IconType.THINKING,
-          } satisfies Commit;
-        case 'reference':
-          return {
-            id: getGenericBlockId(message.id, idx),
-            branch,
-            parents,
-            icon: IconType.LINK,
-            message: stringifyRef(block.reference),
-          } satisfies Commit;
-        default:
-          return null;
-      }
-    })
-    .filter(isNotFalsy);
-};
-
-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 = (options: { parentMessage?: ObjectId; toolCallId?: string }) => {
-  if (options.parentMessage && options.toolCallId) {
-    return `${options.parentMessage}_${options.toolCallId}`;
-  } else if (options.parentMessage) {
-    return options.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 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

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

package/src/hooks/useComputeRuntimeCallback.ts

@@ -1,25 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import type { Effect } from 'effect';
-import { useCallback } from 'react';
-
-import { useCapability } from '@dxos/app-framework';
-import type { Space } from '@dxos/client/echo';
-
-import { AssistantCapabilities } from '../capabilities';
-
-/**
- * Create an effectful function that has access to compute services
- */
-export const useComputeRuntimeCallback = <T>(
-  space: Space,
-  fn: () => Effect.Effect<T, any, AssistantCapabilities.ComputeServices>,
-  deps?: React.DependencyList,
-): (() => Promise<T>) => {
-  const computeRuntime = useCapability(AssistantCapabilities.ComputeRuntime);
-  const runtime = computeRuntime.getRuntime(space.id);
-
-  return useCallback(() => runtime.runPromise(fn()), [runtime, ...(deps ?? [])]);
-};

package/src/hooks/useExecutionGraph.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useMemo } from 'react';
-
-import { type Queue } from '@dxos/client/echo';
-import { Obj } from '@dxos/echo';
-import { useQueue } from '@dxos/react-client/echo';
-
-import { ExecutionGraph } from '../execution-graph';
-
-export const useExecutionGraph = (queueRef?: Queue, lastRequest = false) => {
-  const queue = useQueue(queueRef?.dxn);
-  return useMemo(() => {
-    const graph = new ExecutionGraph();
-    graph.addEvents(queue?.objects.filter(Obj.isObject) ?? []);
-    return graph.getGraph(lastRequest);
-  }, [queue?.objects, lastRequest]);
-};