@assistant-ui/core 0.2.8 → 0.2.10

package/src/react/model-context/toolbox.ts

@@ -1,5 +1,14 @@
-import type { Tool, ToolDeclaration } from "assistant-stream";
-import type { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
+import type {
+  Tool,
+  ToolCallReader,
+  ToolDeclaration,
+  ToolModelOutputFunction,
+} from "assistant-stream";
+import type { ReactNode } from "react";
+import type {
+  ToolCallMessagePartComponent,
+  ToolCallMessagePartProps,
+} from "../types/MessagePartComponentTypes";
 
 /**
  * Resolves whether a tool's UI should be presented standalone (outside the
@@ -20,23 +29,96 @@ export const isStandaloneToolDisplay = (
 type WithRender<T, TArgs extends Record<string, unknown>, TResult> = T extends {
   type: "frontend" | "human";
 }
-  ? T & { render: ToolCallMessagePartComponent<TArgs, TResult> }
+  ? T &
+      (T extends { type: "frontend" }
+        ?
+            | { render: ToolCallMessagePartComponent<TArgs, TResult> }
+            | {
+                render?: ToolCallMessagePartComponent<TArgs, TResult>;
+                renderText: ToolCallText<TArgs, TResult>;
+              }
+        : { render: ToolCallMessagePartComponent<TArgs, TResult> })
   : T & {
       render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;
+      renderText?: ToolCallText<TArgs, TResult> | undefined;
     };
 
+type ToolParameters<TArgs extends Record<string, unknown>> =
+  ToolDeclaration<TArgs>["parameters"];
+
+// ToolExecutionContext is not re-exported from assistant-stream's public entry.
+type ToolExecuteContext = Parameters<
+  NonNullable<ToolDeclaration["execute"]>
+>[1];
+
+type ToolExecute<TArgs extends Record<string, unknown>, TResult> = (
+  args: TArgs,
+  context: ToolExecuteContext,
+) => TResult | Promise<TResult>;
+
+type ToolStreamCall<TArgs extends Record<string, unknown>, TResult> = (
+  reader: ToolCallReader<TArgs, TResult>,
+  context: ToolExecuteContext,
+) => void;
+
+type ToolCallRunningText<TArgs extends Record<string, unknown>> =
+  | ReactNode
+  | ((options: { args: TArgs }) => ReactNode);
+
+type ToolCallCompleteText<TArgs extends Record<string, unknown>, TResult> =
+  | ReactNode
+  | ((options: { args: TArgs; result: TResult | undefined }) => ReactNode);
+
+export type ToolCallText<TArgs extends Record<string, unknown>, TResult> =
+  | {
+      running: ToolCallRunningText<TArgs>;
+      complete?: ToolCallCompleteText<TArgs, TResult> | undefined;
+    }
+  | {
+      running?: ToolCallRunningText<TArgs> | undefined;
+      complete: ToolCallCompleteText<TArgs, TResult>;
+    };
+
+const resolveToolCallText = <TArgs extends Record<string, unknown>, TResult>(
+  text: ToolCallText<TArgs, TResult>,
+  part: ToolCallMessagePartProps<TArgs, TResult>,
+): ReactNode => {
+  const isRunning =
+    part.status?.type === "running" || part.status?.type === "requires-action";
+
+  if (!isRunning) {
+    const value = text.complete;
+    if (typeof value !== "function") return value ?? null;
+    return value({ args: part.args, result: part.result });
+  }
+
+  const value = text.running;
+  if (typeof value !== "function") return value ?? null;
+  return value({ args: part.args });
+};
+
+export const makeToolCallTextComponent = <
+  TArgs extends Record<string, unknown>,
+  TResult,
+>(
+  text: ToolCallText<TArgs, TResult>,
+): ToolCallMessagePartComponent<TArgs, TResult> => {
+  return function ToolCallTextComponent(part) {
+    return resolveToolCallText(text, part);
+  };
+};
+
 /**
  * Tool definition accepted by the React tool registry.
  *
- * Extends the core tool contract with a render component. Human tools rely on
- * the renderer to collect input from the user. Frontend tools execute in the
- * browser and require a UI surface for their progress and result. Backend
- * tools execute server-side and may omit a renderer. The `render` component is
- * required for frontend and human tools and optional for backend tools.
+ * Extends the core tool contract with tool-call display options. Human tools
+ * rely on `render` to collect input from the user. Frontend tools execute in
+ * the browser and require either `render` or `renderText` for their progress
+ * and result. Backend tools execute server-side and may omit a renderer.
  */
 export type ToolDefinition<
-  TArgs extends Record<string, unknown>,
-  TResult,
+  TArgs extends Record<string, unknown> = Record<string, unknown>,
+  TResult = unknown,
 > = WithRender<Tool<TArgs, TResult>, TArgs, TResult>;
 
 /**
@@ -63,19 +145,96 @@ export type Toolkit = Record<string, ToolDefinition<any, any>>;
  * A tool as authored, before the build splits it: like {@link ToolDefinition}
  * but it may declare `description`, `parameters`, and a server-side `execute`
  * alongside its `render`. The `type` field is **not** authored — the
- * `"use generative"` compiler infers it (`execute: hitl()` → human; `execute`
- * with a `"use client"` directive → frontend; otherwise backend) and writes it
- * back — so declaring it here is a type error.
+ * `"use generative"` compiler infers it (`execute: hitlTool()` → human;
+ * `execute: providerTool(...)` → provider; `execute` with a `"use client"`
+ * directive → frontend; otherwise backend) and writes it back — so declaring it
+ * here is a type error.
  */
-export type ToolkitDeclarationDefinition<
+type OverrideOptionalField<
+  T,
+  TKey extends keyof T,
+  TValue,
+> = undefined extends T[TKey]
+  ? // Preserve `?: undefined` fields (for variants that explicitly disallow a
+    // callback) instead of widening them to accept the override value.
+    Exclude<T[TKey], undefined> extends never
+    ? { [K in TKey]?: undefined }
+    : { [K in TKey]?: TValue | undefined }
+  : { [K in TKey]: TValue };
+
+type OverrideToolDeclarationCallbacks<
+  T extends { streamCall?: unknown },
+  TArgs extends Record<string, unknown>,
+  TResult,
+> = Omit<
+  T,
+  | "type"
+  | "execute"
+  | "toModelOutput"
+  | "experimental_onSchemaValidationError"
+  | "streamCall"
+> & {
+  type?: never;
+} & ("execute" extends keyof T
+    ? OverrideOptionalField<T, "execute", ToolExecute<NoInfer<TArgs>, TResult>>
+    : {}) &
+  ("toModelOutput" extends keyof T
+    ? OverrideOptionalField<
+        T,
+        "toModelOutput",
+        ToolModelOutputFunction<NoInfer<TArgs>, NoInfer<TResult>>
+      >
+    : {}) &
+  ("experimental_onSchemaValidationError" extends keyof T
+    ? OverrideOptionalField<
+        T,
+        "experimental_onSchemaValidationError",
+        (
+          args: unknown,
+          context: ToolExecuteContext,
+        ) => NoInfer<TResult> | Promise<NoInfer<TResult>>
+      >
+    : {}) &
+  OverrideOptionalField<
+    T,
+    "streamCall",
+    ToolStreamCall<TArgs, NoInfer<TResult>>
+  >;
+
+// Keep the authored shape tied to ToolDeclaration's union variants while
+// overriding callback fields to avoid inference pollution.
+type ToolkitDefinitionInput<
   TArgs extends Record<string, unknown>,
   TResult,
 > = WithRender<
-  Omit<ToolDeclaration<TArgs, TResult>, "type">,
+  ToolDeclaration<TArgs, TResult> extends infer T
+    ? T extends { streamCall?: unknown }
+      ? OverrideToolDeclarationCallbacks<T, TArgs, TResult>
+      : never
+    : never,
   TArgs,
   TResult
-> & {
-  type?: never;
+>;
+
+/**
+ * A single entry in a {@link ToolkitDefinition}.
+ *
+ * Either authored inline (whose `type` the compiler infers) or an already-formed
+ * {@link ToolDefinition} produced by a factory whose own build splits it across
+ * targets — e.g. `new JSONGenerativeUI({ library }).present()`. The factory case
+ * carries a `type`, so it can only match the {@link ToolDefinition} arm of this
+ * union.
+ */
+export type ToolkitDefinitionEntry<
+  TArgs extends Record<string, unknown> = Record<string, unknown>,
+  TResult = unknown,
+> = ToolkitDefinitionInput<TArgs, TResult> | ToolDefinition<any, any>;
+
+export type ToolkitDefinitionEntryWithParameters<
+  TArgs extends Record<string, unknown> = Record<string, unknown>,
+  TResult = unknown,
+> = ToolkitDefinitionInput<TArgs, TResult> & {
+  parameters: NonNullable<ToolParameters<TArgs>>;
 };
 
 /**
@@ -83,10 +242,19 @@ export type ToolkitDeclarationDefinition<
  * {@link defineToolkit}. Backend entries may carry their server `execute` here;
  * the canonical {@link Toolkit} keeps those fields `undefined`.
  */
-export type ToolkitDeclaration = Record<
-  string,
-  ToolkitDeclarationDefinition<any, any>
->;
+export type ToolkitDefinition<
+  TArgsByName extends {
+    [K in keyof TArgsByName]: Record<string, unknown>;
+  } = Record<string, any>,
+  TResultByName extends { [K in keyof TArgsByName]: unknown } = {
+    [K in keyof TArgsByName]: any;
+  },
+> = {
+  [K in keyof TArgsByName]: ToolkitDefinitionEntry<
+    TArgsByName[K],
+    TResultByName[K]
+  >;
+};
 
 /** Configuration for the {@link Tools} resource. */
 export type ToolsConfig = {

package/src/react/model-context/useAssistantTool.ts

@@ -1,11 +1,19 @@
-import { useEffect } from "react";
+import { useEffect, useMemo } from "react";
 import { useAui } from "@assistant-ui/store";
 import type { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
 import type { AssistantToolProps as CoreAssistantToolProps } from "../..";
-import { isStandaloneToolDisplay } from "./toolbox";
+import {
+  isStandaloneToolDisplay,
+  makeToolCallTextComponent,
+  type ToolCallText,
+} from "./toolbox";
 
 /**
  * Props used to register a tool from React.
+ *
+ * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
+ * `useAui({ tools: Tools({ toolkit }) })` instead. See
+ * https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
 export type AssistantToolProps<
   TArgs extends Record<string, unknown>,
@@ -13,6 +21,8 @@ export type AssistantToolProps<
 > = CoreAssistantToolProps<TArgs, TResult> & {
   /** Component used to render calls to this tool in assistant messages. */
   render?: ToolCallMessagePartComponent<TArgs, TResult> | undefined;
+  /** Lightweight text rendered while a tool call is running or complete. */
+  renderText?: ToolCallText<TArgs, TResult> | undefined;
 };
 
 /**
@@ -28,6 +38,10 @@ export type AssistantToolProps<
  *
  * @param tool - Tool definition and name to register.
  *
+ * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
+ * `useAui({ tools: Tools({ toolkit }) })` instead. See
+ * https://assistant-ui.com/docs/migrations/toolkit-tools.
+ *
  * @example
  * ```tsx
  * const weatherTool = {
@@ -54,16 +68,22 @@ export const useAssistantTool = <
   const aui = useAui();
 
   const standalone = isStandaloneToolDisplay(tool);
+  const renderTextComponent = useMemo(
+    () =>
+      tool.renderText ? makeToolCallTextComponent(tool.renderText) : undefined,
+    [tool.renderText],
+  );
+  const render = tool.render ?? renderTextComponent;
 
   useEffect(() => {
-    if (!tool.render) return undefined;
-    return aui.tools().setToolUI(tool.toolName, tool.render, { standalone });
-  }, [aui, tool.toolName, tool.render, standalone]);
+    if (!render) return undefined;
+    return aui.tools().setToolUI(tool.toolName, render, { standalone });
+  }, [aui, tool.toolName, render, standalone]);
 
   useEffect(() => {
-    // `render` and `display` are client-only presentation concerns and never
-    // reach the model.
-    const { toolName, render, display, ...rest } = tool;
+    // `render`, `renderText`, and `display` are client-only presentation
+    // concerns and never reach the model.
+    const { toolName, render, renderText, display, ...rest } = tool;
     const context = {
       tools: {
         [toolName]: rest,

package/src/react/model-context/useAssistantToolUI.ts

@@ -2,7 +2,13 @@ import { useEffect } from "react";
 import { useAui } from "@assistant-ui/store";
 import type { ToolCallMessagePartComponent } from "../types/MessagePartComponentTypes";
 
-/** Props used to register a renderer for tool-call message parts. */
+/**
+ * Props used to register a renderer for tool-call message parts.
+ *
+ * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use
+ * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.
+ * See https://assistant-ui.com/docs/migrations/toolkit-tools.
+ */
 export type AssistantToolUIProps<TArgs, TResult> = {
   /** Name of the tool whose calls should use this renderer. */
   toolName: string;
@@ -19,11 +25,14 @@ export type AssistantToolUIProps<TArgs, TResult> = {
 /**
  * Registers a tool-call renderer while the component is mounted.
  *
- * This only affects rendering. Pair it with {@link useAssistantTool},
- * {@link Tools}, or a backend tool registry to expose the actual tool
- * definition to the model.
+ * This only affects rendering. Pair it with {@link Tools} or a backend tool
+ * registry to expose the actual tool definition to the model.
  *
  * @param tool - Tool renderer registration, or `null` to skip registration.
+ *
+ * @deprecated Put `render`/`renderText` on the matching toolkit entry, or use
+ * `MessagePrimitive.Parts` inline tool render overrides for per-message UI.
+ * See https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
 export const useAssistantToolUI = (
   tool: AssistantToolUIProps<any, any> | null,

package/src/react/model-context/useAuiToolOverrides.ts

@@ -0,0 +1,38 @@
+import { useEffect, useRef } from "react";
+import { useAui } from "@assistant-ui/store";
+import type { Tool } from "assistant-stream";
+
+type AuiToolOverride<
+  TArgs extends Record<string, unknown> = Record<string, unknown>,
+  TResult = unknown,
+> = Partial<Tool<TArgs, TResult>>;
+
+type AuiToolOverrides = Record<string, AuiToolOverride<any, any>>;
+
+/**
+ * Overrides toolkit entries for the current assistant scope.
+ *
+ * This is intended for dynamic local-state tools whose model-facing contract is
+ * declared in a `"use generative"` toolkit file with `execute: stubTool()`, but
+ * whose actual executor must close over React state in the mounted component.
+ * Keep the override keys stable after mount; dynamic key addition/removal is not
+ * currently observed.
+ * Overrides are registered at priority 1000, above toolkit defaults. Only one
+ * mounted override provider may define a given tool name at a time.
+ *
+ * @deprecated Experimental, API may change.
+ */
+export function useAuiToolOverrides(overrides: AuiToolOverrides): void {
+  const aui = useAui();
+  const overridesRef = useRef(overrides);
+  overridesRef.current = overrides;
+
+  useEffect(() => {
+    return aui.modelContext().register({
+      getModelContext: () => ({
+        priority: 1000,
+        tools: overridesRef.current as Record<string, Tool<any, any>>,
+      }),
+    });
+  }, [aui]);
+}

package/src/react/primitives/part/PartMessages.tsx

@@ -34,17 +34,19 @@ const usePartMessages = (): readonly ThreadMessage[] | undefined => {
  *
  * @example
  * ```tsx
- * const SubAgentToolUI = makeAssistantToolUI({
- *   toolName: "invoke_sub_agent",
- *   render: () => (
- *     <PartPrimitive.Messages>
- *       {({ message }) => {
- *         if (message.role === "user") return <MyUserMessage />;
- *         return <MyAssistantMessage />;
- *       }}
- *     </PartPrimitive.Messages>
- *   ),
- * });
+ * const toolkit = {
+ *   invoke_sub_agent: {
+ *     type: "backend",
+ *     render: () => (
+ *       <PartPrimitive.Messages>
+ *         {({ message }) => {
+ *           if (message.role === "user") return <MyUserMessage />;
+ *           return <MyAssistantMessage />;
+ *         }}
+ *       </PartPrimitive.Messages>
+ *     ),
+ *   },
+ * } satisfies Toolkit;
  * ```
  */
 export const PartPrimitiveMessagesImpl: FC<PartPrimitiveMessages.Props> = ({

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/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/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/runtimes/external-store/external-store-adapter.ts

@@ -24,6 +24,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 +47,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;

package/src/runtimes/external-store/external-store-thread-list-runtime-core.ts

@@ -197,6 +197,19 @@ export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore
     await onRename(threadId, newTitle);
   }
 
+  public async updateCustom(
+    threadId: string,
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void> {
+    const onUpdateCustom = this.adapter.onUpdateCustom;
+    if (!onUpdateCustom)
+      throw new Error(
+        "External store adapter does not support updating custom metadata",
+      );
+
+    await onUpdateCustom(threadId, custom);
+  }
+
   public async detach(): Promise<void> {
     // no-op
   }

package/src/runtimes/remote-thread-list/adapter/in-memory.ts

@@ -17,6 +17,10 @@ export class InMemoryThreadListAdapter implements RemoteThreadListAdapter {
     return Promise.resolve();
   }
 
+  updateCustom(): Promise<void> {
+    return Promise.resolve();
+  }
+
   archive(): Promise<void> {
     return Promise.resolve();
   }

package/src/runtimes/remote-thread-list/types.ts

@@ -29,6 +29,10 @@ export type RemoteThreadListAdapter = {
   list(params?: RemoteThreadListPageOptions): Promise<RemoteThreadListResponse>;
 
   rename(remoteId: string, newTitle: string): Promise<void>;
+  updateCustom?(
+    remoteId: string,
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void>;
   archive(remoteId: string): Promise<void>;
   unarchive(remoteId: string): Promise<void>;
   delete(remoteId: string): Promise<void>;