@dxos/plugin-automation 0.7.5-labs.5f04cf6 → 0.7.5-labs.8a82073

package/src/hooks/processor.ts

@@ -2,27 +2,23 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ReadonlySignal, type Signal, computed, signal } from '@preact/signals-core';
+import { type Signal, batch, computed, signal } from '@preact/signals-core';
 
 import { type PromiseIntentDispatcher } from '@dxos/app-framework';
-import { type Tool, Message } from '@dxos/artifact';
+import { type Tool, Message, type MessageContentBlock } from '@dxos/artifact';
 import {
+  isToolUse,
+  runTools,
   type AIServiceClientImpl,
   type GenerateRequest,
   type GenerationStream,
-  isToolUse,
-  runTools,
+  MixedStreamParser,
 } from '@dxos/assistant';
 import { createStatic } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { type Space } from '@dxos/react-client/echo';
 
-const defaultOptions: Pick<GenerateRequest, 'model' | 'systemPrompt'> = {
-  model: '@anthropic/claude-3-5-sonnet-20241022',
-  systemPrompt: '',
-};
-
 // TODO(burdon): Factor out.
 declare global {
   interface ToolContextExtensions {
@@ -31,56 +27,109 @@ declare global {
   }
 }
 
+type RequestOptions = {
+  history?: Message[];
+  onComplete?: (messages: Message[]) => void;
+};
+
+export type ChatProcessorOptions = Pick<GenerateRequest, 'model' | 'systemPrompt'>;
+
+const defaultOptions: ChatProcessorOptions = {
+  model: '@anthropic/claude-3-5-sonnet-20241022',
+  systemPrompt: 'you are a helpful assistant',
+};
+
 /**
- * Handles interactions with an AI service.
- * Manages message history, and executes tools based on AI responses.
+ * Handles interactions with the AI service.
  * Maintains a queue of messages and handles streaming responses from the AI service.
+ * Executes tools based on AI responses.
  * Supports cancellation of in-progress requests.
  */
-// TODO(burdon): Tests.
 export class ChatProcessor {
+  /** SSE stream parser. */
+  private readonly _parser = new MixedStreamParser();
+
+  /** Current streaming response (iterator). */
+  private _stream: GenerationStream | undefined;
+
+  /** Pending messages (incl. the user request). */
+  private readonly _pending: Signal<Message[]> = signal([]);
+
+  /** Current streaming block (from the AI service). */
+  private readonly _block: Signal<MessageContentBlock | undefined> = signal(undefined);
+
   /** Prior history from queue. */
   private _history: Message[] = [];
 
-  /** Pending messages (incl. the initial user message). */
-  private _pending: Signal<Message[]> = signal([]);
+  /**
+   * Streaming state.
+   * @reactive
+   */
+  public readonly streaming: Signal<boolean> = computed(() => this._block.value !== undefined);
 
-  /** Streaming messages (from the AI service). */
-  private _streaming: Signal<Message[]> = signal([]);
+  /**
+   * Array of Messages (incl. the current message being streamed).
+   * @reactive
+   */
+  public readonly messages: Signal<Message[]> = computed(() => {
+    const messages = [...this._pending.value];
+    if (this._block.value) {
+      const current = messages.pop();
+      invariant(current);
+      const { content, ...rest } = current;
+      const message = { ...rest, content: [...content, this._block.value] };
+      messages.push(message);
+    }
 
-  /** Current streaming response. */
-  private _response: GenerationStream | undefined;
+    return messages;
+  });
 
   constructor(
     private readonly _client: AIServiceClientImpl,
-    private readonly _tools?: Tool[],
+    private _tools?: Tool[],
     private readonly _extensions?: ToolContextExtensions,
-    private readonly _options: Pick<GenerateRequest, 'model' | 'systemPrompt'> = defaultOptions,
-  ) {}
-
-  get isStreaming(): ReadonlySignal<boolean> {
-    return computed(() => this._pending.value.length > 0);
+    private readonly _options: ChatProcessorOptions = defaultOptions,
+  ) {
+    // Message complete.
+    this._parser.message.on((message) => {
+      batch(() => {
+        this._pending.value = [...this._pending.value, message];
+        this._block.value = undefined;
+      });
+    });
+
+    // Streaming update (happens before message complete).
+    this._parser.update.on((block) => {
+      batch(() => {
+        this._block.value = block;
+      });
+    });
   }
 
-  get messages(): ReadonlySignal<Message[]> {
-    return computed(() => [...this._pending.value, ...this._streaming.value]);
+  /**
+   * Update tools.
+   */
+  setTools(tools: Tool[]) {
+    this._tools = tools;
   }
 
   /**
    * Make GPT request.
    */
-  async request(message: string, history: Message[] = []): Promise<Message[]> {
-    log.info('requesting...', { message, history: history.length });
-    this._history = history;
-    this._pending.value = [
-      createStatic(Message, {
-        role: 'user',
-        content: [{ type: 'text', text: message }],
-      }),
-    ];
-    this._streaming.value = [];
-
-    await this.generate();
+  async request(message: string, options: RequestOptions = {}): Promise<Message[]> {
+    batch(() => {
+      this._history = options.history ?? [];
+      this._pending.value = [
+        createStatic(Message, {
+          role: 'user',
+          content: [{ type: 'text', text: message }],
+        }),
+      ];
+      this._block.value = undefined;
+    });
+
+    await this._generate();
+    options.onComplete?.(this._pending.value);
     return this._reset();
   }
 
@@ -90,51 +139,52 @@ export class ChatProcessor {
    */
   async cancel(): Promise<Message[]> {
     log.info('cancelling...');
-    this._response?.abort();
+    this._stream?.abort();
     return this._reset();
   }
 
   private async _reset(): Promise<Message[]> {
-    const pending = this._pending.value;
-    this._history = [];
-    this._pending.value = [];
-    this._streaming.value = [];
-    return pending;
+    const messages = this._pending.value;
+    batch(() => {
+      this._history = [];
+      this._pending.value = [];
+      this._block.value = undefined;
+    });
+
+    return messages;
   }
 
-  private async generate() {
+  /**
+   * Generate a response from the AI service.
+   * Iterates over tool requests.
+   */
+  private async _generate() {
     try {
       let more = false;
       do {
-        log.info('requesting...', { history: this._history.length, pending: this._pending.value.length });
-        this._response = await this._client.generate({
+        log.info('requesting...', { history: this._history.length, messages: this._pending.value.length });
+        this._stream = await this._client.generate({
           ...this._options,
           // TODO(burdon): Rename messages or separate history/message.
           history: [...this._history, ...this._pending.value],
           tools: this._tools,
         });
 
-        // Process the stream.
-        queueMicrotask(async () => {
-          invariant(this._response);
-          for await (const event of this._response) {
-            log.info('event', { event: event.type });
-            this._streaming.value = this._response.accumulatedMessages.map((message) => createStatic(Message, message));
-          }
-        });
+        // Wait until complete.
+        await this._parser.parse(this._stream);
+        await this._stream.complete();
 
-        // Update pending messages.
-        const messages = await this._response.complete();
-        log.info('response', { messages: messages.length });
-        this._pending.value.push(...messages.map((message) => createStatic(Message, message)));
-        this._streaming.value = [];
+        // Add messages.
+        log.info('response', { messages: this._pending.value });
 
         // Resolve tool use locally.
         more = false;
-        if (messages.length > 0 && isToolUse(messages.at(-1)!)) {
+        const message = this._pending.value.at(-1);
+        invariant(message);
+        if (isToolUse(message)) {
           log.info('tool request...');
           const response = await runTools({
-            message: messages.at(-1)!,
+            message: this._pending.value.at(-1)!,
             tools: this._tools ?? [],
             extensions: this._extensions,
           });
@@ -142,7 +192,7 @@ export class ChatProcessor {
           log.info('tool response', { response });
           switch (response.type) {
             case 'continue': {
-              this._pending.value.push(response.message);
+              this._pending.value = [...this._pending.value, response.message];
               more = true;
               break;
             }
@@ -154,8 +204,7 @@ export class ChatProcessor {
       log.catch('request failed', { err });
     } finally {
       log.info('done');
-      this._response = undefined;
-      this._streaming.value = [];
+      this._stream = undefined;
     }
   }
 }

package/src/hooks/useChatProcessor.tsx

@@ -0,0 +1,86 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect, useMemo, useState } from 'react';
+
+import { Capabilities, useCapabilities, useCapability, useIntentDispatcher } from '@dxos/app-framework';
+import { createSystemPrompt, type Tool } from '@dxos/artifact';
+import { FunctionType } from '@dxos/functions';
+import { useConfig } from '@dxos/react-client';
+import { Filter, getSpace, useQuery } from '@dxos/react-client/echo';
+import { isNotNullOrUndefined } from '@dxos/util';
+
+import { AutomationCapabilities } from '../capabilities';
+import { ChatProcessor } from '../hooks';
+import { covertFunctionToTool, createToolsFromService } from '../tools';
+import { ServiceType, type AIChatType } from '../types';
+
+/**
+ * Creates a processor for the chat.
+ */
+export const useChatProcessor = (chat: AIChatType) => {
+  const aiClient = useCapability(AutomationCapabilities.AiClient);
+  const globalTools = useCapabilities(Capabilities.Tools);
+  const artifactDefinitions = useCapabilities(Capabilities.ArtifactDefinition);
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const space = getSpace(chat);
+
+  // Services.
+  const services = useQuery(space, Filter.schema(ServiceType));
+  const [serviceTools, setServiceTools] = useState<Tool[]>([]);
+  useEffect(() => {
+    queueMicrotask(async () => {
+      const tools = await Promise.all(services.map((service) => createToolsFromService(service)));
+      setServiceTools(tools.flat());
+    });
+  }, [services]);
+
+  // Tools.
+  const config = useConfig();
+  const functions = useQuery(space, Filter.schema(FunctionType));
+  const tools = useMemo(
+    () => [
+      ...globalTools.flat(),
+      ...artifactDefinitions.flatMap((definition) => definition.tools),
+      ...serviceTools,
+      ...functions
+        .map((fn) => covertFunctionToTool(fn, config.values.runtime?.services?.edge?.url ?? '', space?.id))
+        .filter(isNotNullOrUndefined),
+    ],
+    [globalTools, artifactDefinitions, serviceTools, functions, space?.id],
+  );
+
+  // Prompt.
+  const systemPrompt = useMemo(
+    () => createSystemPrompt({ artifacts: artifactDefinitions.map((definition) => definition.instructions) }),
+    [artifactDefinitions],
+  );
+
+  // Create processor.
+  const processor = useMemo(
+    () =>
+      new ChatProcessor(
+        aiClient,
+        tools,
+        {
+          space,
+          dispatch,
+        },
+        {
+          model: '@anthropic/claude-3-5-sonnet-20241022',
+          systemPrompt,
+        },
+      ),
+    [aiClient, tools, space, dispatch, systemPrompt],
+  );
+
+  // Update processor.
+  // useEffect(() => {
+  //   if (processor) {
+  //     processor.setTools(tools.flat());
+  //   }
+  // }, [processor, tools]);
+
+  return processor;
+};

package/src/hooks/useMessageQueue.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { type Message } from '@dxos/artifact';
+import { DXN, QueueSubspaceTags } from '@dxos/keys';
+import { getSpace } from '@dxos/react-client/echo';
+import { useEdgeClient, useQueue } from '@dxos/react-edge-client';
+
+import { type AIChatType } from '../types';
+
+export const useMessageQueue = (chat: AIChatType) => {
+  const edgeClient = useEdgeClient();
+  const space = getSpace(chat);
+  const queueDxn = useMemo(
+    () => new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, space!.id, chat.queue.dxn.parts.at(-1)!]),
+    [chat.queue.dxn],
+  );
+
+  return useQueue<Message>(edgeClient, queueDxn);
+};

package/src/hooks/useServices.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect, useMemo, useState } from 'react';
+
+import { type Space } from '@dxos/client/echo';
+
+import { MockServiceRegistry } from '../testing';
+import { type ServiceType, type ServiceQuery } from '../types';
+
+/**
+ * Retrieves matching services from the registry.
+ */
+export const useServices = (space: Space, query?: ServiceQuery): ServiceType[] => {
+  const registry = useMemo(() => new MockServiceRegistry(), []);
+  const [services, setServices] = useState<ServiceType[]>([]);
+  useEffect(() => {
+    const t = setTimeout(async () => {
+      const services = await registry.queryServices(query);
+      setServices(services);
+    });
+
+    return () => clearTimeout(t);
+  }, [query, registry]);
+
+  return services;
+};

package/src/meta.ts

@@ -9,7 +9,8 @@ export const AUTOMATION_PLUGIN = 'dxos.org/plugin/automation';
 export const meta = {
   id: AUTOMATION_PLUGIN,
   name: 'Automation',
-  description: 'Automation workflows.',
+  description:
+    'The Automation tab allows you to trigger pre-defined workflows related to the element you are interacting with inside of Composer.',
   icon: 'ph--magic-wand--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-automation',
   tags: ['experimental'],

package/src/testing/index.ts

@@ -2,4 +2,5 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './testing';
+export * from './test-functions';
+export * from './test-services';

package/src/testing/test-services.ts

@@ -0,0 +1,131 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createStatic } from '@dxos/echo-schema';
+
+import {
+  type ApiAuthorization,
+  type BaseServiceRegistry,
+  type ServiceQuery,
+  ServiceType,
+  categoryIcons,
+} from '../types';
+
+export class MockServiceRegistry implements BaseServiceRegistry {
+  async queryServices(query?: ServiceQuery): Promise<ServiceType[]> {
+    return TEST_SERVICES;
+  }
+}
+
+// TODO(burdon): Can we generalize credentials?
+
+const AMADEUS_AUTH: ApiAuthorization = {
+  type: 'oauth',
+  clientId: 'BOEnpLd1sMyKjAPGKYeAPFFy60u53QEG',
+  clientSecret: 'n4qldSN7usvD57gm',
+  tokenUrl: 'https://test.api.amadeus.com/v1/security/oauth2/token',
+  grantType: 'client_credentials',
+};
+
+const VISUAL_CROSSING_CREDENTIALS: ApiAuthorization = {
+  type: 'api-key',
+  key: 'FDPRVS953KB4GQQLD25GRT975',
+  placement: {
+    type: 'query',
+    name: 'key',
+  },
+};
+
+// Registries:
+//  - https://apis.guru
+//  - https://rapidapi.com
+//  - https://github.com/konfig-sdks/openapi-examples
+//  - https://publicapis.io/?utm_source=chatgpt.com
+
+// Examples:
+//  - https://petstore.swagger.io/v2/swagger.json (testing)
+//  - https://lichess.org/api
+//  - https://github.com/konfig-sdks/openapi-examples/tree/main/xkcd
+//  - https://api.coindesk.com/v1/bpi/currentprice.json
+//  - https://www.coingecko.com/en/api/documentation
+
+// TODO(burdon): Support yaml endpoints.
+//  - e.g., https://github.com/konfig-sdks/openapi-examples/blob/main/xkcd/openapi.yaml
+
+const TEST_SERVICES: ServiceType[] = [
+  createStatic(ServiceType, {
+    serviceId: 'amadeus.com/service/FlightSearch',
+    name: 'Amadeus Flight Search',
+    description: 'Search for local and international flights.',
+    category: 'travel',
+    interfaces: [
+      {
+        kind: 'api',
+        schemaUrl: 'https://api.apis.guru/v2/specs/amadeus.com/amadeus-flight-availabilities-search/1.0.2/swagger.json',
+        authorization: AMADEUS_AUTH,
+      },
+    ],
+  }),
+
+  createStatic(ServiceType, {
+    serviceId: 'amadeus.com/service/HotelSearch',
+    name: 'Amadeus Hotel Search',
+    description: 'Search for local and international hotels.',
+    category: 'travel',
+    interfaces: [
+      {
+        kind: 'api',
+        schemaUrl: 'https://api.apis.guru/v2/specs/amadeus.com/amadeus-hotel-search/3.0.8/swagger.json',
+        authorization: AMADEUS_AUTH,
+      },
+    ],
+  }),
+
+  createStatic(ServiceType, {
+    serviceId: 'visualcrossing.com/service/Weather',
+    name: 'Visual Crossing Weather',
+    description: 'Search for global weather forecasts.',
+    category: 'weather',
+    interfaces: [
+      {
+        kind: 'api',
+        schemaUrl: 'https://api.apis.guru/v2/specs/visualcrossing.com/weather/4.6/openapi.json',
+        authorization: VISUAL_CROSSING_CREDENTIALS,
+      },
+    ],
+  }),
+
+  // TODO(burdon): Needs auth.
+  createStatic(ServiceType, {
+    serviceId: 'abstractapi.com/service/GeoLocation',
+    name: 'Abstract GeoLocation',
+    description: 'Get the location of any IP address.',
+    category: 'geolocation',
+    interfaces: [
+      {
+        kind: 'api',
+        schemaUrl: 'https://api.apis.guru/v2/specs/abstractapi.com/geolocation/1.0.0/openapi.json',
+      },
+    ],
+  }),
+
+  //
+  // Testing
+  //
+
+  ...Array.from({ length: 20 }, (_, i) =>
+    createStatic(ServiceType, {
+      serviceId: `example.com/service/test-${i}`,
+      name: `Test ${i}`,
+      description: `Test ${i}`,
+      category: Object.keys(categoryIcons)[Math.floor(Math.random() * Object.keys(categoryIcons).length)],
+      interfaces: [
+        {
+          kind: 'api',
+          schemaUrl: 'https://petstore.swagger.io/v2/swagger.json',
+        },
+      ],
+    }),
+  ),
+] as const;

package/src/tools/function.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { defineTool, ToolResult } from '@dxos/artifact';
+import type { Tool } from '@dxos/artifact';
+import { toEffectSchema } from '@dxos/echo-schema';
+import { getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions';
+import type { FunctionType } from '@dxos/functions';
+import { log } from '@dxos/log';
+import type { SpaceId } from '@dxos/react-client/echo';
+import { getMeta } from '@dxos/react-client/echo';
+
+export const covertFunctionToTool = (
+  fn: FunctionType,
+  edgeUrl: string,
+  spaceId?: SpaceId | undefined,
+): Tool | undefined => {
+  if (!fn.description || !fn.inputSchema) {
+    return undefined;
+  }
+
+  const existingFunctionUrl = getUserFunctionUrlInMetadata(getMeta(fn));
+  if (!existingFunctionUrl) {
+    return undefined;
+  }
+  const url = getInvocationUrl(existingFunctionUrl, edgeUrl, {
+    spaceId,
+  });
+
+  return defineTool({
+    name: fn.name,
+    description: fn.description,
+    schema: toEffectSchema(fn.inputSchema),
+    execute: async (input) => {
+      log.info('execute function tool', { name: fn.name, url, input });
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(input),
+      });
+      return ToolResult.Success(await response.text());
+    },
+  });
+};

package/src/tools/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './function';
+export * from './openapi';