@assistant-ui/core 0.2.12 → 0.2.15

package/src/runtimes/local/local-thread-runtime-core.ts

@@ -49,6 +49,7 @@ export class LocalThreadRuntimeCore
     switchToBranch: true,
     switchBranchDuringRun: true,
     edit: true,
+    delete: false,
     reload: true,
     cancel: true,
     unstable_copy: true,
@@ -150,6 +151,12 @@ export class LocalThreadRuntimeCore
       hasUpdates = true;
     }
 
+    const canDelete = options.adapters?.history?.delete !== undefined;
+    if (this.capabilities.delete !== canDelete) {
+      this.capabilities.delete = canDelete;
+      hasUpdates = true;
+    }
+
     const canQueue = options.unstable_enableMessageQueue === true;
     if (canQueue && !this._queue) {
       this._queue = createMessageQueue({
@@ -275,6 +282,25 @@ export class LocalThreadRuntimeCore
     }
   }
 
+  public async deleteMessage(messageId: string): Promise<void> {
+    const adapter = this._options.adapters.history;
+    if (!adapter?.delete)
+      throw new Error("Runtime does not support deleting messages.");
+
+    const messages = this.repository.getMessages();
+    const messageIndex = messages.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1) throw new Error("Message not found.");
+
+    const message = messages[messageIndex]!;
+    const parentId = messages[messageIndex - 1]?.id ?? null;
+    const items = [{ parentId, message }];
+
+    await adapter.delete(items);
+
+    this.repository.deleteMessage(messageId);
+    this._notifySubscribers();
+  }
+
   public resumeRun({ stream, ...startConfig }: ResumeRunConfig): Promise<void> {
     if (!stream)
       throw new Error("You must pass a stream parameter to resume runs.");
@@ -297,7 +323,7 @@ export class LocalThreadRuntimeCore
 
     // add assistant message
     const id = generateId();
-    let message: ThreadAssistantMessage = {
+    const message: ThreadAssistantMessage = {
       id,
       role: "assistant",
       status: { type: "running" },
@@ -312,6 +338,15 @@ export class LocalThreadRuntimeCore
       createdAt: new Date(),
     };
 
+    return this._runLoop(parentId, message, runConfig, runCallback);
+  }
+
+  private async _runLoop(
+    parentId: string | null,
+    message: ThreadAssistantMessage,
+    runConfig: RunConfig | undefined,
+    runCallback?: ChatModelAdapter["run"],
+  ): Promise<void> {
     this._notifyEventSubscribers("runStart", {});
 
     try {
@@ -592,22 +627,93 @@ export class LocalThreadRuntimeCore
       content: newContent,
     };
     this.repository.addOrUpdateMessage(parentId, message);
+    this._notifySubscribers();
 
+    // a result may arrive mid-run or on a non-head message; the resume
+    // intentionally aborts any in-flight run, unlike respondToToolApproval
     if (
       added &&
       shouldContinue(message, this._options.unstable_humanToolNames)
     ) {
-      this.performRoundtrip(parentId, message, this._lastRunConfig).catch(
-        () => {},
-      );
+      this._runLoop(parentId, message, this._lastRunConfig).catch(() => {});
     }
   }
 
   public resumeToolCall(_options: ResumeToolCallOptions) {
-    throw new Error("Local runtime does not support resuming tool calls.");
+    throw new Error(
+      "Local runtime does not support resuming tool calls. For human-in-the-loop tools, list the tool in unstable_humanToolNames and complete the call with addToolResult.",
+    );
   }
 
-  public respondToToolApproval(_options: RespondToToolApprovalOptions) {
-    throw new Error("Local runtime does not support tool approvals.");
+  public respondToToolApproval({
+    approvalId,
+    approved,
+    optionId,
+    reason,
+  }: RespondToToolApprovalOptions) {
+    let message = this.repository
+      .getMessages()
+      .findLast(
+        (m): m is ThreadAssistantMessage =>
+          m.role === "assistant" &&
+          m.content.some(
+            (c) => c.type === "tool-call" && c.approval?.id === approvalId,
+          ),
+      );
+
+    if (!message)
+      throw new Error("Tried to respond to a non-existing tool approval");
+
+    if (this.abortController !== null)
+      throw new Error(
+        "Tried to respond to a tool approval while a run is in progress",
+      );
+
+    if (message.status?.type !== "requires-action")
+      throw new Error(
+        "Tried to respond to a tool approval on a message whose status is not requires-action",
+      );
+
+    const target = message.content.find(
+      (c) => c.type === "tool-call" && c.approval?.id === approvalId,
+    );
+    if (target?.type !== "tool-call" || !target.approval)
+      throw new Error("Tried to respond to a non-existing tool approval");
+    if (target.approval.resolution !== undefined)
+      throw new Error(
+        "Tried to respond to a tool approval that was cancelled or expired",
+      );
+    if (target.approval.approved !== undefined)
+      throw new Error("Tried to respond to an already decided tool approval");
+
+    const targetApproval = target.approval;
+    const newContent = message.content.map((c) => {
+      if (c !== target) return c;
+      const approval = {
+        ...targetApproval,
+        approved,
+        ...(optionId != null && { optionId }),
+        ...(reason != null && { reason }),
+      };
+      if (approved) return { ...c, approval };
+      return {
+        ...c,
+        approval,
+        result: { error: reason || "Tool approval denied" },
+        isError: true,
+      };
+    });
+
+    message = { ...message, content: newContent };
+    const { parentId } = this.repository.getMessage(message.id);
+    this.repository.addOrUpdateMessage(parentId, message);
+    this._notifySubscribers();
+
+    if (
+      this.repository.headId === message.id &&
+      shouldContinue(message, this._options.unstable_humanToolNames)
+    ) {
+      this._runLoop(parentId, message, this._lastRunConfig).catch(() => {});
+    }
   }
 }

package/src/runtimes/local/should-continue.ts

@@ -4,23 +4,34 @@ export const shouldContinue = (
   result: ThreadAssistantMessage,
   humanToolNames: string[] | undefined,
 ) => {
+  if (
+    result.status?.type !== "requires-action" ||
+    result.status.reason !== "tool-calls"
+  )
+    return false;
+
+  const hasPendingApproval = result.content.some(
+    (c) =>
+      c.type === "tool-call" &&
+      c.result === undefined &&
+      c.approval !== undefined &&
+      c.approval.approved === undefined &&
+      c.approval.resolution === undefined,
+  );
+  if (hasPendingApproval) return false;
+
   // TODO legacy behavior -- make specifying human tool names required
   if (humanToolNames === undefined) {
-    return (
-      result.status?.type === "requires-action" &&
-      result.status.reason === "tool-calls" &&
-      result.content.every((c) => c.type !== "tool-call" || !!c.result)
+    return result.content.every(
+      (c) => c.type !== "tool-call" || !!c.result || c.approval !== undefined,
     );
   }
 
-  return (
-    result.status?.type === "requires-action" &&
-    result.status.reason === "tool-calls" &&
-    result.content.every(
-      (c) =>
-        c.type !== "tool-call" ||
-        !!c.result ||
-        !humanToolNames.includes(c.toolName),
-    )
+  return result.content.every(
+    (c) =>
+      c.type !== "tool-call" ||
+      !!c.result ||
+      c.approval !== undefined ||
+      !humanToolNames.includes(c.toolName),
   );
 };

package/src/runtimes/readonly/ReadonlyThreadRuntimeCore.ts

@@ -47,6 +47,10 @@ export class ReadonlyThreadRuntimeCore
     throw READONLY_THREAD_ERROR;
   }
 
+  deleteMessage(): void {
+    throw READONLY_THREAD_ERROR;
+  }
+
   startRun(): void {
     throw READONLY_THREAD_ERROR;
   }
@@ -202,6 +206,7 @@ export class ReadonlyThreadRuntimeCore
     switchToBranch: false,
     switchBranchDuringRun: false,
     edit: false,
+    delete: false,
     reload: false,
     cancel: false,
     unstable_copy: false,

package/src/runtimes/remote-thread-list/empty-thread-core.ts

@@ -20,6 +20,10 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     throw EMPTY_THREAD_ERROR;
   },
 
+  deleteMessage() {
+    throw EMPTY_THREAD_ERROR;
+  },
+
   startRun() {
     throw EMPTY_THREAD_ERROR;
   },
@@ -183,6 +187,7 @@ export const EMPTY_THREAD_CORE: ThreadRuntimeCore = {
     switchToBranch: false,
     switchBranchDuringRun: false,
     edit: false,
+    delete: false,
     reload: false,
     cancel: false,
     unstable_copy: false,

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

@@ -28,6 +28,7 @@ export type RemoteThreadData =
       readonly externalId: string | undefined;
       readonly status: "regular" | "archived";
       readonly title?: string | undefined;
+      readonly lastMessageAt?: Date | undefined;
       readonly custom?: Record<string, unknown> | undefined;
     };
 
@@ -75,6 +76,7 @@ export const classifyThreads = (
       externalId: thread.externalId,
       status: thread.status,
       title: thread.title,
+      lastMessageAt: thread.lastMessageAt,
       custom: thread.custom,
       initializeTask: Promise.resolve({
         remoteId: thread.remoteId,

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

@@ -13,6 +13,7 @@ export type RemoteThreadMetadata = {
   readonly remoteId: string;
   readonly externalId?: string | undefined;
   readonly title?: string | undefined;
+  readonly lastMessageAt?: Date | undefined;
   readonly custom?: Record<string, unknown> | undefined;
 };
 

package/src/store/clients/chain-of-thought-client.ts

@@ -12,13 +12,13 @@ const COMPLETE_STATUS: MessagePartStatus = Object.freeze({
   type: "complete",
 });
 
-export const ChainOfThoughtClient = resource(function ChainOfThoughtClient({
+const useChainOfThoughtClient = ({
   parts,
   getMessagePart,
 }: {
   parts: readonly ChainOfThoughtPart[];
   getMessagePart: (selector: { index: number }) => PartMethods;
-}): ClientOutput<"chainOfThought"> {
+}): ClientOutput<"chainOfThought"> => {
   const [collapsed, setCollapsed] = useState(true);
 
   const status = useMemo(() => {
@@ -36,4 +36,6 @@ export const ChainOfThoughtClient = resource(function ChainOfThoughtClient({
     setCollapsed,
     part: getMessagePart,
   };
-});
+};
+
+export const ChainOfThoughtClient = resource(useChainOfThoughtClient);

package/src/store/clients/model-context-client.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { createResourceRoot } from "@assistant-ui/tap";
+import { createTapRoot, useResource } from "@assistant-ui/tap";
 import type { Tool } from "assistant-stream";
 import { ModelContext } from "./model-context-client";
 import type {
@@ -18,9 +18,10 @@ const toolFixture = (): Tool<any, any> =>
   ({ description: "", parameters: {} as any }) as unknown as Tool<any, any>;
 
 const render = () => {
-  const root = createResourceRoot();
-  const sub = root.render(ModelContext());
-  return { sub, unmount: () => root.unmount() };
+  const root = createTapRoot(function Root() {
+    return useResource(ModelContext());
+  });
+  return { sub: root, unmount: () => root.unmount() };
 };
 
 describe("ModelContext", () => {

package/src/store/clients/model-context-client.ts

@@ -29,25 +29,25 @@ const deriveState = (
   return { modelName, toolNames };
 };
 
-export const ModelContext = resource(
-  function ModelContext(): ClientOutput<"modelContext"> {
-    const composite = useMemo(() => new CompositeContextProvider(), []);
-    const [state, setState] = useState<ModelContextState>(() =>
-      deriveState(composite, INITIAL_STATE),
-    );
-
-    useEffect(() => {
+const useModelContext = (): ClientOutput<"modelContext"> => {
+  const composite = useMemo(() => new CompositeContextProvider(), []);
+  const [state, setState] = useState<ModelContextState>(() =>
+    deriveState(composite, INITIAL_STATE),
+  );
+
+  useEffect(() => {
+    setState((prev) => deriveState(composite, prev));
+    return composite.subscribe(() => {
       setState((prev) => deriveState(composite, prev));
-      return composite.subscribe(() => {
-        setState((prev) => deriveState(composite, prev));
-      });
-    }, [composite]);
-
-    return {
-      getState: () => deriveState(composite, state),
-      getModelContext: () => composite.getModelContext(),
-      subscribe: (callback) => composite.subscribe(callback),
-      register: (provider) => composite.registerModelContextProvider(provider),
-    };
-  },
-);
+    });
+  }, [composite]);
+
+  return {
+    getState: () => deriveState(composite, state),
+    getModelContext: () => composite.getModelContext(),
+    subscribe: (callback) => composite.subscribe(callback),
+    register: (provider) => composite.registerModelContextProvider(provider),
+  };
+};
+
+export const ModelContext = resource(useModelContext);

package/src/store/clients/no-op-composer-client.ts

@@ -3,11 +3,11 @@ import { resource } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import type { ComposerState } from "../scopes/composer";
 
-export const NoOpComposerClient = resource(function NoOpComposerClient({
+const useNoOpComposerClient = ({
   type,
 }: {
   type: "edit" | "thread";
-}): ClientOutput<"composer"> {
+}): ClientOutput<"composer"> => {
   const state = useMemo<ComposerState>(() => {
     return {
       isEditing: false,
@@ -71,4 +71,6 @@ export const NoOpComposerClient = resource(function NoOpComposerClient({
       throw new Error("Not supported");
     },
   };
-});
+};
+
+export const NoOpComposerClient = resource(useNoOpComposerClient);

package/src/store/clients/runtime-adapter.ts

@@ -1,9 +1,4 @@
-import { useEffect } from "react";
-import { useResource, resource } from "@assistant-ui/tap";
-import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
-import { ThreadListClient } from "../runtime-clients/thread-list-runtime-client";
 import {
-  useAssistantClientRef,
   Derived,
   type ScopesConfig,
   type AssistantClient,
@@ -11,25 +6,6 @@ import {
 import { ModelContext } from "./model-context-client";
 import { Suggestions } from "./suggestions";
 
-export const RuntimeAdapterResource = resource(function RuntimeAdapterResource(
-  runtime: AssistantRuntime,
-) {
-  const clientRef = useAssistantClientRef();
-
-  useEffect(() => {
-    return runtime.registerModelContextProvider(
-      clientRef.current!.modelContext(),
-    );
-  }, [runtime, clientRef]);
-
-  return useResource(
-    ThreadListClient({
-      runtime: runtime.threads,
-      __internal_assistantRuntime: runtime,
-    }),
-  );
-});
-
 export const baseRuntimeAdapterTransformScopes = (
   scopes: ScopesConfig,
   parent: AssistantClient,

package/src/store/clients/suggestions.ts

@@ -9,17 +9,19 @@ export type SuggestionConfig =
   | string
   | { title: string; label: string; prompt: string };
 
-const SuggestionClient = resource(function SuggestionClient(
+const useSuggestionClient = (
   state: SuggestionState,
-): ClientOutput<"suggestion"> {
+): ClientOutput<"suggestion"> => {
   return {
     getState: () => state,
   };
-});
+};
 
-const SuggestionsResource = resource(function SuggestionsResource(
+const SuggestionClient = resource(useSuggestionClient);
+
+const useSuggestionsResource = (
   suggestions?: SuggestionConfig[],
-): ClientOutput<"suggestions"> {
+): ClientOutput<"suggestions"> => {
   const [state] = useState<SuggestionsState>(() => {
     const normalizedSuggestions = (suggestions ?? []).map((s) => {
       if (typeof s === "string") {
@@ -42,11 +44,9 @@ const SuggestionsResource = resource(function SuggestionsResource(
   });
 
   const suggestionClients = useClientLookup(
-    () =>
-      state.suggestions.map((suggestion, index) =>
-        withKey(index, SuggestionClient(suggestion)),
-      ),
-    [state.suggestions],
+    state.suggestions.map((suggestion, index) =>
+      withKey(index, SuggestionClient(suggestion), [suggestion]),
+    ),
   );
 
   return {
@@ -55,17 +55,6 @@ const SuggestionsResource = resource(function SuggestionsResource(
       return suggestionClients.get({ index });
     },
   };
-});
+};
 
-export const Suggestions: {
-  (): import("@assistant-ui/tap").ResourceElement<
-    ClientOutput<"suggestions">,
-    undefined
-  >;
-  (
-    suggestions: SuggestionConfig[],
-  ): import("@assistant-ui/tap").ResourceElement<
-    ClientOutput<"suggestions">,
-    SuggestionConfig[]
-  >;
-} = SuggestionsResource as any;
+export const Suggestions = resource(useSuggestionsResource);

package/src/store/clients/thread-message-client.ts

@@ -11,12 +11,13 @@ import { useClientLookup } from "@assistant-ui/store";
 import type { MessageState } from "../scopes/message";
 import type { PartState } from "../scopes/part";
 import { NoOpComposerClient } from "./no-op-composer-client";
+import { getThreadMessageText } from "../../utils/text";
 
-const ThreadMessagePartClient = resource(function ThreadMessagePartClient({
+const useThreadMessagePartClient = ({
   part,
 }: {
   part: ThreadAssistantMessagePart | ThreadUserMessagePart;
-}): ClientOutput<"part"> {
+}): ClientOutput<"part"> => {
   const state = useMemo<PartState>(() => {
     return {
       ...part,
@@ -36,21 +37,25 @@ const ThreadMessagePartClient = resource(function ThreadMessagePartClient({
       throw new Error("Not supported");
     },
   };
-});
+};
+
+const ThreadMessagePartClient = resource(useThreadMessagePartClient);
+
+const useThreadMessageAttachmentClient = ({
+  attachment,
+}: {
+  attachment: Attachment;
+}): ClientOutput<"attachment"> => {
+  return {
+    getState: () => attachment,
+    remove: () => {
+      throw new Error("Not supported");
+    },
+  };
+};
 
 const ThreadMessageAttachmentClient = resource(
-  function ThreadMessageAttachmentClient({
-    attachment,
-  }: {
-    attachment: Attachment;
-  }): ClientOutput<"attachment"> {
-    return {
-      getState: () => attachment,
-      remove: () => {
-        throw new Error("Not supported");
-      },
-    };
-  },
+  useThreadMessageAttachmentClient,
 );
 export type ThreadMessageClientProps = {
   message: ThreadMessage;
@@ -60,35 +65,34 @@ export type ThreadMessageClientProps = {
   branchCount?: number;
 };
 
-export const ThreadMessageClient = resource(function ThreadMessageClient({
+const useThreadMessageClient = ({
   message,
   index,
   isLast = true,
   branchNumber = 1,
   branchCount = 1,
-}: ThreadMessageClientProps): ClientOutput<"message"> {
+}: ThreadMessageClientProps): ClientOutput<"message"> => {
   const [isCopiedState, setIsCopied] = useState(false);
   const [isHoveringState, setIsHovering] = useState(false);
 
   const parts = useClientLookup(
-    () =>
-      message.content.map((part, idx) =>
-        withKey(
-          "toolCallId" in part && part.toolCallId != null
-            ? `toolCallId-${part.toolCallId}`
-            : `index-${idx}`,
-          ThreadMessagePartClient({ part }),
-        ),
+    message.content.map((part, idx) =>
+      withKey(
+        "toolCallId" in part && part.toolCallId != null
+          ? `toolCallId-${part.toolCallId}`
+          : `index-${idx}`,
+        ThreadMessagePartClient({ part }),
+        [part],
       ),
-    [message.content],
+    ),
   );
 
   const attachments = useClientLookup(
-    () =>
-      (message.attachments ?? []).map((attachment) =>
-        withKey(attachment.id, ThreadMessageAttachmentClient({ attachment })),
-      ),
-    [message.attachments],
+    (message.attachments ?? []).map((attachment) =>
+      withKey(attachment.id, ThreadMessageAttachmentClient({ attachment }), [
+        attachment,
+      ]),
+    ),
   );
 
   const composer = useResource(NoOpComposerClient({ type: "edit" }));
@@ -137,6 +141,9 @@ export const ThreadMessageClient = resource(function ThreadMessageClient({
         return attachments.get(selector);
       }
     },
+    delete: () => {
+      throw new Error("Not supported in ThreadMessageProvider");
+    },
     reload: () => {
       throw new Error("Not supported in ThreadMessageProvider");
     },
@@ -153,16 +160,11 @@ export const ThreadMessageClient = resource(function ThreadMessageClient({
       throw new Error("Not supported in ThreadMessageProvider");
     },
     getCopyText: () => {
-      return message.content
-        .map((part) => {
-          if ("text" in part && typeof part.text === "string") {
-            return part.text;
-          }
-          return "";
-        })
-        .join("\n");
+      return getThreadMessageText(message);
     },
     setIsCopied,
     setIsHovering,
   };
-});
+};
+
+export const ThreadMessageClient = resource(useThreadMessageClient);

package/src/store/internal.ts

@@ -5,7 +5,4 @@ export { MessageClient } from "./runtime-clients/message-runtime-client";
 export { ThreadClient } from "./runtime-clients/thread-runtime-client";
 export { ThreadListItemClient } from "./runtime-clients/thread-list-item-runtime-client";
 export { ThreadListClient } from "./runtime-clients/thread-list-runtime-client";
-export {
-  RuntimeAdapterResource,
-  baseRuntimeAdapterTransformScopes,
-} from "./clients/runtime-adapter";
+export { baseRuntimeAdapterTransformScopes } from "./clients/runtime-adapter";

package/src/store/runtime-clients/attachment-runtime-client.ts

@@ -3,18 +3,18 @@ import type { ClientOutput } from "@assistant-ui/store";
 import type { AttachmentRuntime } from "../../runtime/api/attachment-runtime";
 import { useSubscribable } from "./useSubscribable";
 
-export const AttachmentRuntimeClient = resource(
-  function AttachmentRuntimeClient({
-    runtime,
-  }: {
-    runtime: AttachmentRuntime;
-  }): ClientOutput<"attachment"> {
-    const state = useSubscribable(runtime);
+const useAttachmentRuntimeClient = ({
+  runtime,
+}: {
+  runtime: AttachmentRuntime;
+}): ClientOutput<"attachment"> => {
+  const state = useSubscribable(runtime);
 
-    return {
-      getState: () => state,
-      remove: runtime.remove,
-      __internal_getRuntime: () => runtime,
-    };
-  },
-);
+  return {
+    getState: () => state,
+    remove: runtime.remove,
+    __internal_getRuntime: () => runtime,
+  };
+};
+
+export const AttachmentRuntimeClient = resource(useAttachmentRuntimeClient);