@assistant-ui/core 0.2.9 → 0.2.11

package/src/react/providers/TextMessagePartProvider.tsx

@@ -1,39 +1,38 @@
-import type { FC, PropsWithChildren } from "react";
+import { type FC, type PropsWithChildren, useMemo } from "react";
 import { useAui, AuiProvider, type ClientOutput } from "@assistant-ui/store";
 import type { PartState } from "../../store/scopes/part";
-import { resource, tapMemo } from "@assistant-ui/tap";
 
-const TextMessagePartClient = resource(
-  ({
-    text,
-    isRunning,
-  }: {
-    text: string;
-    isRunning: boolean;
-  }): ClientOutput<"part"> => {
-    const state = tapMemo<PartState>(
-      () => ({
-        type: "text",
-        text,
-        status: isRunning ? { type: "running" } : { type: "complete" },
-      }),
-      [text, isRunning],
-    );
+import { resource } from "@assistant-ui/tap";
+
+const TextMessagePartClient = resource(function TextMessagePartClient({
+  text,
+  isRunning,
+}: {
+  text: string;
+  isRunning: boolean;
+}): ClientOutput<"part"> {
+  const state = useMemo<PartState>(
+    () => ({
+      type: "text",
+      text,
+      status: isRunning ? { type: "running" } : { type: "complete" },
+    }),
+    [text, isRunning],
+  );
 
-    return {
-      getState: () => state,
-      addToolResult: () => {
-        throw new Error("Not supported");
-      },
-      resumeToolCall: () => {
-        throw new Error("Not supported");
-      },
-      respondToToolApproval: () => {
-        throw new Error("Not supported");
-      },
-    };
-  },
-);
+  return {
+    getState: () => state,
+    addToolResult: () => {
+      throw new Error("Not supported");
+    },
+    resumeToolCall: () => {
+      throw new Error("Not supported");
+    },
+    respondToToolApproval: () => {
+      throw new Error("Not supported");
+    },
+  };
+});
 
 export const TextMessagePartProvider: FC<
   PropsWithChildren<{

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -508,6 +508,49 @@ export class RemoteThreadListThreadListRuntimeCore
     });
   }
 
+  public updateCustom(
+    threadIdOrRemoteId: string,
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void> {
+    const data = this.getItemById(threadIdOrRemoteId);
+    if (!data) throw new Error("Thread not found");
+    if (data.status === "new") throw new Error("Thread is not yet initialized");
+
+    if (!this._options.adapter.updateCustom) {
+      throw new Error(
+        "Remote thread list adapter does not support updating custom metadata",
+      );
+    }
+
+    return this._state.optimisticUpdate({
+      execute: async () => {
+        const { remoteId } = await data.initializeTask;
+        const adapter = this._options.adapter;
+        if (!adapter.updateCustom) {
+          throw new Error(
+            "Remote thread list adapter does not support updating custom metadata",
+          );
+        }
+        return adapter.updateCustom(remoteId, custom);
+      },
+      optimistic: (state) => {
+        const data = getThreadData(state, threadIdOrRemoteId);
+        if (!data) return state;
+
+        return {
+          ...state,
+          threadData: {
+            ...state.threadData,
+            [data.id]: {
+              ...data,
+              custom,
+            },
+          },
+        };
+      },
+    });
+  }
+
   private async _ensureThreadIsNotMain(threadId: string) {
     if (threadId === this.newThreadId)
       throw new Error("Cannot ensure new thread is not main");

package/src/react/runtimes/cloud/useCloudThreadListAdapter.tsx

@@ -14,6 +14,7 @@ import { InMemoryThreadListAdapter } from "../../../runtimes/remote-thread-list/
 import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
 import { RuntimeAdapterProvider } from "../RuntimeAdapterProvider";
 import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
+import { isRecord } from "../../../utils/json/is-json";
 
 type ThreadData = {
   externalId: string | undefined;
@@ -26,6 +27,9 @@ type CloudThreadListAdapterOptions = {
   delete?: ((threadId: string) => Promise<void>) | undefined;
 };
 
+const toCustom = (value: unknown): Record<string, unknown> | undefined =>
+  isRecord(value) ? value : undefined;
+
 const baseUrl =
   typeof process !== "undefined" &&
   process?.env?.NEXT_PUBLIC_ASSISTANT_BASE_URL;
@@ -91,6 +95,7 @@ export const useCloudThreadListAdapter = (
           remoteId: t.id,
           title: t.title,
           externalId: t.external_id ?? undefined,
+          custom: toCustom(t.metadata),
         })),
       };
     },
@@ -110,6 +115,9 @@ export const useCloudThreadListAdapter = (
     rename: async (threadId, newTitle) => {
       return cloud.threads.update(threadId, { title: newTitle });
     },
+    updateCustom: async (threadId, custom) => {
+      return cloud.threads.update(threadId, { metadata: custom ?? null });
+    },
     archive: async (threadId) => {
       return cloud.threads.update(threadId, { is_archived: true });
     },
@@ -146,6 +154,7 @@ export const useCloudThreadListAdapter = (
         remoteId: thread.id,
         title: thread.title,
         externalId: thread.external_id ?? undefined,
+        custom: toCustom(thread.metadata),
       };
     },
 

package/src/react/runtimes/createMessageConverter.ts

@@ -5,6 +5,7 @@ import { useAui, useAuiState } from "@assistant-ui/store";
 import {
   useExternalMessageConverter,
   convertExternalMessages,
+  type JoinStrategy,
 } from "./external-message-converter";
 import { getExternalStoreMessages } from "../../runtime/utils/external-store-message";
 
@@ -20,7 +21,7 @@ export const createMessageConverter = <T extends object>(
     }: {
       messages: T[];
       isRunning: boolean;
-      joinStrategy?: "concat-content" | "none" | undefined;
+      joinStrategy?: JoinStrategy | undefined;
       metadata?: useExternalMessageConverter.Metadata;
     }) => {
       return useExternalMessageConverter<T>({

package/src/react/runtimes/external-message-converter.ts

@@ -22,6 +22,8 @@ import type {
 } from "../../types/message";
 import type { MessageTiming } from "../../types/message";
 
+export type JoinStrategy = "concat-content" | "none";
+
 type ThreadMessageLikeContentItem = Exclude<
   ThreadMessageLike["content"],
   string
@@ -42,7 +44,7 @@ export namespace useExternalMessageConverter {
   export type Message =
     | (ThreadMessageLike & {
         readonly convertConfig?: {
-          readonly joinStrategy?: "concat-content" | "none";
+          readonly joinStrategy?: JoinStrategy;
         };
       })
     | {
@@ -264,7 +266,7 @@ const joinExternalMessages = (
 
 const chunkExternalMessages = <T>(
   callbackResults: CallbackResult<T>[],
-  joinStrategy?: "concat-content" | "none",
+  joinStrategy?: JoinStrategy,
 ) => {
   const results: ChunkResult<T>[] = [];
   let isAssistant = false;
@@ -397,7 +399,7 @@ export const useExternalMessageConverter = <T extends WeakKey>({
   callback: useExternalMessageConverter.Callback<T>;
   messages: T[];
   isRunning: boolean;
-  joinStrategy?: "concat-content" | "none" | undefined;
+  joinStrategy?: JoinStrategy | undefined;
   metadata?: useExternalMessageConverter.Metadata | undefined;
 }) => {
   const state = useMemo(

package/src/react/runtimes/useLocalRuntime.ts

@@ -71,6 +71,7 @@ export const splitLocalRuntimeOptions = <T extends LocalRuntimeOptions>(
     maxSteps,
     adapters,
     unstable_humanToolNames,
+    unstable_enableMessageQueue,
     ...rest
   } = options;
 
@@ -81,6 +82,7 @@ export const splitLocalRuntimeOptions = <T extends LocalRuntimeOptions>(
       maxSteps,
       adapters,
       unstable_humanToolNames,
+      unstable_enableMessageQueue,
     },
     otherOptions: rest,
   };

package/src/runtime/api/composer-runtime.ts

@@ -3,6 +3,7 @@ import type { MessageRole } from "../../types/message";
 import type { QuoteInfo } from "../../types/quote";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { RunConfig } from "../../types/message";
+import type { QueueItemState } from "../../store/scopes/queue-item";
 import {
   LazyMemoizeSubject,
   EventSubscriptionSubject,
@@ -63,6 +64,9 @@ type BaseComposerState = {
    * Undefined when no quote is set.
    */
   readonly quote: QuoteInfo | undefined;
+
+  /** Messages waiting to be processed. Empty unless the `queue` capability is set. */
+  readonly queue: readonly QueueItemState[];
 };
 
 export type ThreadComposerState = BaseComposerState & {
@@ -97,6 +101,7 @@ const getThreadComposerState = (
     attachmentAccept: runtime?.attachmentAccept ?? "",
     dictation: runtime?.dictation,
     quote: runtime?.quote,
+    queue: runtime?.queue ?? EMPTY_ARRAY,
 
     value: runtime?.text ?? "",
   });
@@ -120,6 +125,7 @@ const getEditComposerState = (
     attachmentAccept: runtime?.attachmentAccept ?? "",
     dictation: runtime?.dictation,
     quote: runtime?.quote,
+    queue: runtime?.queue ?? EMPTY_ARRAY,
 
     parentId: runtime?.parentId ?? null,
     sourceId: runtime?.sourceId ?? null,
@@ -194,6 +200,12 @@ export type ComposerRuntime = {
    */
   cancel(): void;
 
+  /** Promote a queued message so it processes next. */
+  steerQueueItem(queueItemId: string): void;
+
+  /** Remove a queued message. */
+  removeQueueItem(queueItemId: string): void;
+
   /**
    * Listens for changes to the composer state.
    * @param callback The callback to call when the composer state changes.
@@ -251,6 +263,8 @@ export abstract class ComposerRuntimeImpl implements ComposerRuntime {
     this.clearAttachments = this.clearAttachments.bind(this);
     this.send = this.send.bind(this);
     this.cancel = this.cancel.bind(this);
+    this.steerQueueItem = this.steerQueueItem.bind(this);
+    this.removeQueueItem = this.removeQueueItem.bind(this);
     this.setRole = this.setRole.bind(this);
     this.getAttachmentByIndex = this.getAttachmentByIndex.bind(this);
     this.startDictation = this.startDictation.bind(this);
@@ -303,6 +317,18 @@ export abstract class ComposerRuntimeImpl implements ComposerRuntime {
     core.cancel();
   }
 
+  public steerQueueItem(queueItemId: string) {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    core.steerQueueItem(queueItemId);
+  }
+
+  public removeQueueItem(queueItemId: string) {
+    const core = this._core.getState();
+    if (!core) throw new Error("Composer is not available");
+    core.removeQueueItem(queueItemId);
+  }
+
   public setRole(role: MessageRole) {
     const core = this._core.getState();
     if (!core) throw new Error("Composer is not available");

package/src/runtime/api/thread-list-item-runtime.ts

@@ -38,6 +38,7 @@ export type ThreadListItemRuntime = {
 
   switchTo(options?: { unarchive?: boolean }): Promise<void>;
   rename(newTitle: string): Promise<void>;
+  updateCustom(custom: Record<string, unknown> | undefined): Promise<void>;
   archive(): Promise<void>;
   unarchive(): Promise<void>;
   delete(): Promise<void>;
@@ -74,6 +75,7 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
   protected __internal_bindMethods() {
     this.switchTo = this.switchTo.bind(this);
     this.rename = this.rename.bind(this);
+    this.updateCustom = this.updateCustom.bind(this);
     this.archive = this.archive.bind(this);
     this.unarchive = this.unarchive.bind(this);
     this.delete = this.delete.bind(this);
@@ -100,6 +102,19 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
     return this._threadListBinding.rename(state.id, newTitle);
   }
 
+  public updateCustom(
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void> {
+    const state = this._core.getState();
+    if (!this._threadListBinding.updateCustom) {
+      throw new Error(
+        "Thread list runtime does not support updating custom metadata",
+      );
+    }
+
+    return this._threadListBinding.updateCustom(state.id, custom);
+  }
+
   public archive(): Promise<void> {
     const state = this._core.getState();
 

package/src/runtime/base/base-composer-runtime-core.ts

@@ -23,6 +23,10 @@ import type {
   SendOptions,
 } from "../interfaces/composer-runtime-core";
 import type { DictationAdapter } from "../../adapters/speech";
+import {
+  EMPTY_QUEUE_ITEMS,
+  type QueueItemState,
+} from "../../store/scopes/queue-item";
 import { generateId } from "../../utils/id";
 
 const isAttachmentComplete = (a: Attachment): a is CompleteAttachment =>
@@ -200,6 +204,13 @@ export abstract class BaseComposerRuntimeCore
     this.handleCancel();
   }
 
+  public get queue(): readonly QueueItemState[] {
+    return EMPTY_QUEUE_ITEMS;
+  }
+
+  public steerQueueItem(_queueItemId: string): void {}
+  public removeQueueItem(_queueItemId: string): void {}
+
   protected abstract handleSend(
     message: Omit<AppendMessage, "parentId" | "sourceId">,
     options?: SendOptions,

package/src/runtime/base/default-thread-composer-runtime-core.ts

@@ -6,6 +6,10 @@ import type {
   ThreadComposerRuntimeCore,
 } from "../interfaces/composer-runtime-core";
 import type { ThreadRuntimeCore } from "../interfaces/thread-runtime-core";
+import {
+  EMPTY_QUEUE_ITEMS,
+  type QueueItemState,
+} from "../../store/scopes/queue-item";
 import { BaseComposerRuntimeCore } from "./base-composer-runtime-core";
 
 export class DefaultThreadComposerRuntimeCore
@@ -21,6 +25,18 @@ export class DefaultThreadComposerRuntimeCore
     return !this.isEmpty && !this.runtime.isSendDisabled;
   }
 
+  public override get queue(): readonly QueueItemState[] {
+    return this.runtime.getQueueItems?.() ?? EMPTY_QUEUE_ITEMS;
+  }
+
+  public override steerQueueItem(queueItemId: string): void {
+    this.runtime.steerQueueItem?.(queueItemId);
+  }
+
+  public override removeQueueItem(queueItemId: string): void {
+    this.runtime.removeQueueItem?.(queueItemId);
+  }
+
   protected getAttachmentAdapter() {
     return this.runtime.adapters?.attachments;
   }
@@ -45,6 +61,7 @@ export class DefaultThreadComposerRuntimeCore
 
   public connect() {
     let lastIsSendDisabled = this.runtime.isSendDisabled;
+    let lastQueue = this.queue;
     return this.runtime.subscribe(() => {
       let changed = false;
       if (this.canCancel !== this.runtime.capabilities.cancel) {
@@ -55,6 +72,10 @@ export class DefaultThreadComposerRuntimeCore
         lastIsSendDisabled = this.runtime.isSendDisabled;
         changed = true;
       }
+      if (lastQueue !== this.queue) {
+        lastQueue = this.queue;
+        changed = true;
+      }
       if (changed) this._notifySubscribers();
     });
   }
@@ -68,6 +89,7 @@ export class DefaultThreadComposerRuntimeCore
       parentId: this.runtime.messages.at(-1)?.id ?? null,
       sourceId: null,
       startRun: options?.startRun,
+      steer: options?.steer,
     });
   }
 

package/src/runtime/interfaces/composer-runtime-core.ts

@@ -4,6 +4,7 @@ import type { Attachment, CreateAttachment } from "../../types/attachment";
 import type { Unsubscribe } from "../../types/unsubscribe";
 import type { RunConfig } from "../../types/message";
 import type { DictationAdapter } from "../../adapters/speech";
+import type { QueueItemState } from "../../store/scopes/queue-item";
 
 export type AttachmentAddErrorReason =
   | "no-adapter"
@@ -45,6 +46,8 @@ export type DictationState = {
 
 export type SendOptions = {
   startRun?: boolean;
+  /** Process this message next; only meaningful with the `queue` capability. */
+  steer?: boolean;
 };
 
 export type ComposerRuntimeCore = Readonly<{
@@ -78,6 +81,10 @@ export type ComposerRuntimeCore = Readonly<{
   send: (options?: SendOptions) => void;
   cancel: () => void;
 
+  queue: readonly QueueItemState[];
+  steerQueueItem: (queueItemId: string) => void;
+  removeQueueItem: (queueItemId: string) => void;
+
   dictation: DictationState | undefined;
   startDictation: () => void;
   stopDictation: () => void;

package/src/runtime/interfaces/thread-list-runtime-core.ts

@@ -44,6 +44,10 @@ export type ThreadListRuntimeCore = {
 
   detach(threadId: string): Promise<void>;
   rename(threadId: string, newTitle: string): Promise<void>;
+  updateCustom?(
+    threadId: string,
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void>;
   archive(threadId: string): Promise<void>;
   unarchive(threadId: string): Promise<void>;
   delete(threadId: string): Promise<void>;

package/src/runtime/interfaces/thread-runtime-core.ts

@@ -16,6 +16,7 @@ import type {
   EditComposerRuntimeCore,
   ThreadComposerRuntimeCore,
 } from "./composer-runtime-core";
+import type { QueueItemState } from "../../store/scopes/queue-item";
 
 export type RuntimeCapabilities = {
   readonly switchToBranch: boolean;
@@ -169,6 +170,10 @@ export type ThreadRuntimeCore = Readonly<{
   getEditComposer: (messageId: string) => EditComposerRuntimeCore | undefined;
   beginEdit: (messageId: string) => void;
 
+  getQueueItems?: () => readonly QueueItemState[];
+  steerQueueItem?: (queueItemId: string) => void;
+  removeQueueItem?: (queueItemId: string) => void;
+
   speech: SpeechState | undefined;
   voice: VoiceSessionState | undefined;
 

package/src/runtime/queue/external-thread-queue-adapter.ts

@@ -0,0 +1,14 @@
+import type { AppendMessage } from "../../types/message";
+import type { QueueItemState } from "../../store/scopes/queue-item";
+
+/**
+ * The queue surface a runtime exposes so the composer can stay usable during a
+ * run and render the pending messages.
+ */
+export type ExternalThreadQueueAdapter = {
+  items: readonly QueueItemState[];
+  enqueue: (message: AppendMessage, options: { steer: boolean }) => void;
+  steer: (queueItemId: string) => void;
+  remove: (queueItemId: string) => void;
+  clear: (reason: "edit" | "reload" | "cancel-run") => void;
+};

package/src/runtime/queue/message-queue.ts

@@ -0,0 +1,128 @@
+import type { AppendMessage } from "../../types/message";
+import {
+  EMPTY_QUEUE_ITEMS,
+  type QueueItemState,
+} from "../../store/scopes/queue-item";
+import { generateId } from "../../utils/id";
+import { getThreadMessageText } from "../../utils/text";
+import type { ExternalThreadQueueAdapter } from "./external-thread-queue-adapter";
+
+export type MessageQueueDriver = {
+  run: (message: AppendMessage, options: { steer: boolean }) => void;
+  /** When omitted, `steer` degrades to "process next" instead of interrupting. */
+  cancel?: (() => void) | undefined;
+};
+
+export type MessageQueueController = {
+  readonly adapter: ExternalThreadQueueAdapter;
+  /** Mark a run as in flight so concurrent sends buffer; call on the rising edge. */
+  notifyBusy: () => void;
+  /** Advances to the next pending message; call on the run's falling edge. */
+  notifyIdle: () => void;
+  subscribe: (callback: () => void) => () => void;
+};
+
+export const createMessageQueue = (
+  driver: MessageQueueDriver,
+): MessageQueueController => {
+  let items: readonly QueueItemState[] = EMPTY_QUEUE_ITEMS;
+  const messages = new Map<string, AppendMessage>();
+  const subscribers = new Set<() => void>();
+
+  let running = false;
+  // swallow the cancelled run's settle when steering so it does not double-advance
+  let suppressIdle = 0;
+
+  const notify = () => {
+    for (const callback of subscribers) callback();
+  };
+
+  const setItems = (next: readonly QueueItemState[]) => {
+    items = next;
+    adapter.items = next;
+    notify();
+  };
+
+  const advance = () => {
+    if (running || items.length === 0) return;
+    const head = items[0]!;
+    const message = messages.get(head.id);
+    messages.delete(head.id);
+    setItems(items.slice(1));
+    if (!message) return;
+    running = true;
+    driver.run(message, { steer: false });
+  };
+
+  const enqueue = (message: AppendMessage, { steer }: { steer: boolean }) => {
+    const id = generateId();
+    const prompt = getThreadMessageText(message);
+    messages.set(id, message);
+    setItems([...items, { id, prompt }]);
+    if (steer) {
+      steerItem(id);
+    } else {
+      advance();
+    }
+  };
+
+  const steerItem = (queueItemId: string) => {
+    if (!messages.has(queueItemId)) return;
+
+    if (driver.cancel && running) {
+      const message = messages.get(queueItemId)!;
+      messages.delete(queueItemId);
+      setItems(items.filter((item) => item.id !== queueItemId));
+      suppressIdle++;
+      driver.cancel();
+      running = true;
+      driver.run(message, { steer: true });
+      return;
+    }
+
+    const target = items.find((item) => item.id === queueItemId);
+    if (!target) return;
+    setItems([target, ...items.filter((item) => item.id !== queueItemId)]);
+    advance();
+  };
+
+  const remove = (queueItemId: string) => {
+    if (!messages.delete(queueItemId)) return;
+    setItems(items.filter((item) => item.id !== queueItemId));
+  };
+
+  const clear = () => {
+    if (items.length === 0) return;
+    messages.clear();
+    setItems(EMPTY_QUEUE_ITEMS);
+  };
+
+  const adapter: ExternalThreadQueueAdapter = {
+    items,
+    enqueue,
+    steer: steerItem,
+    remove,
+    clear,
+  };
+
+  return {
+    adapter,
+    notifyBusy: () => {
+      running = true;
+    },
+    notifyIdle: () => {
+      if (suppressIdle > 0) {
+        suppressIdle--;
+        return;
+      }
+      running = false;
+      advance();
+    },
+    subscribe: (callback) => {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    },
+  };
+};

package/src/runtimes/external-store/external-store-adapter.ts

@@ -17,6 +17,7 @@ import type {
 import type { ExportedMessageRepository } from "../../runtime/utils/message-repository";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import type { ToolExecutionStatus } from "../tool-invocations/ToolInvocationTracker";
+import type { ExternalThreadQueueAdapter } from "../../runtime/queue/external-thread-queue-adapter";
 
 export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
   status: TState;
@@ -24,6 +25,7 @@ export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
   remoteId?: string | undefined;
   externalId?: string | undefined;
   title?: string | undefined;
+  custom?: Record<string, unknown> | undefined;
 };
 
 export type ExternalStoreThreadListAdapter = {
@@ -46,6 +48,12 @@ export type ExternalStoreThreadListAdapter = {
     threadId: string,
     newTitle: string,
   ) => (Promise<void> | void) | undefined;
+  onUpdateCustom?:
+    | ((
+        threadId: string,
+        custom: Record<string, unknown> | undefined,
+      ) => Promise<void> | void)
+    | undefined;
   onArchive?: ((threadId: string) => Promise<void> | void) | undefined;
   onUnarchive?: ((threadId: string) => Promise<void> | void) | undefined;
   onDelete?: ((threadId: string) => Promise<void> | void) | undefined;
@@ -98,6 +106,8 @@ type ExternalStoreAdapterBase<T> = {
   onExportExternalState?: (() => any) | undefined;
   onLoadExternalState?: ((state: any) => void) | undefined;
   onNew: (message: AppendMessage) => Promise<void>;
+  /** Opt in to message queuing. Typically produced by `createMessageQueue`. */
+  queue?: ExternalThreadQueueAdapter | undefined;
   onEdit?: ((message: AppendMessage) => Promise<void>) | undefined;
   onReload?: // TODO: remove parentId in 0.12.0
     | ((parentId: string | null, config: StartRunConfig) => Promise<void>)