@assistant-ui/react 0.12.14 → 0.12.16

package/src/legacy-runtime/runtime-cores/adapters/RuntimeAdapterProvider.tsx

@@ -1,45 +1,7 @@
 "use client";
 
-import { createContext, FC, ReactNode, useContext } from "react";
-import type {
-  ThreadHistoryAdapter,
-  AttachmentAdapter,
-} from "@assistant-ui/core";
-import { ModelContextProvider } from "../../../model-context";
-
-export type RuntimeAdapters = {
-  modelContext?: ModelContextProvider;
-  history?: ThreadHistoryAdapter;
-  attachments?: AttachmentAdapter;
-};
-
-const RuntimeAdaptersContext = createContext<RuntimeAdapters | null>(null);
-
-export namespace RuntimeAdapterProvider {
-  export type Props = {
-    adapters: RuntimeAdapters;
-    children: ReactNode;
-  };
-}
-
-export const RuntimeAdapterProvider: FC<RuntimeAdapterProvider.Props> = ({
-  adapters,
-  children,
-}) => {
-  const context = useContext(RuntimeAdaptersContext);
-  return (
-    <RuntimeAdaptersContext.Provider
-      value={{
-        ...context,
-        ...adapters,
-      }}
-    >
-      {children}
-    </RuntimeAdaptersContext.Provider>
-  );
-};
-
-export const useRuntimeAdapters = () => {
-  const adapters = useContext(RuntimeAdaptersContext);
-  return adapters;
-};
+export {
+  RuntimeAdapterProvider,
+  useRuntimeAdapters,
+  type RuntimeAdapters,
+} from "@assistant-ui/core/react";

package/src/legacy-runtime/runtime-cores/adapters/attachment/CloudFileAttachmentAdapter.ts

@@ -1,101 +1,3 @@
-import type { AssistantCloud } from "assistant-cloud";
-import type {
-  Attachment,
-  PendingAttachment,
-  CompleteAttachment,
-  ThreadUserMessagePart,
-  AttachmentAdapter,
-} from "@assistant-ui/core";
+"use client";
 
-const guessAttachmentType = (
-  contentType: string,
-): "image" | "document" | "file" => {
-  if (contentType.startsWith("image/")) return "image";
-  if (contentType.startsWith("text/")) return "document";
-  return "file";
-};
-
-export class CloudFileAttachmentAdapter implements AttachmentAdapter {
-  public accept = "*";
-
-  constructor(private cloud: AssistantCloud) {}
-
-  private uploadedUrls = new Map<string, string>();
-
-  public async *add({
-    file,
-  }: {
-    file: File;
-  }): AsyncGenerator<PendingAttachment, void> {
-    const id = crypto.randomUUID();
-    const type = guessAttachmentType(file.type);
-    let attachment: PendingAttachment = {
-      id,
-      type,
-      name: file.name,
-      contentType: file.type,
-      file,
-      status: { type: "running", reason: "uploading", progress: 0 },
-    };
-    yield attachment;
-
-    try {
-      const { signedUrl, publicUrl } =
-        await this.cloud.files.generatePresignedUploadUrl({
-          filename: file.name,
-        });
-      await fetch(signedUrl, {
-        method: "PUT",
-        body: file,
-        headers: {
-          "Content-Type": file.type,
-        },
-        mode: "cors",
-      });
-      this.uploadedUrls.set(id, publicUrl);
-      attachment = {
-        ...attachment,
-        status: { type: "requires-action", reason: "composer-send" },
-      };
-      yield attachment;
-    } catch {
-      attachment = {
-        ...attachment,
-        status: { type: "incomplete", reason: "error" },
-      };
-      yield attachment;
-    }
-  }
-
-  public async remove(attachment: Attachment): Promise<void> {
-    this.uploadedUrls.delete(attachment.id);
-  }
-
-  public async send(
-    attachment: PendingAttachment,
-  ): Promise<CompleteAttachment> {
-    const url = this.uploadedUrls.get(attachment.id);
-    if (!url) throw new Error("Attachment not uploaded");
-    this.uploadedUrls.delete(attachment.id);
-
-    let content: ThreadUserMessagePart[];
-    if (attachment.type === "image") {
-      content = [{ type: "image", image: url, filename: attachment.name }];
-    } else {
-      content = [
-        {
-          type: "file",
-          data: url,
-          mimeType: attachment.contentType ?? "",
-          filename: attachment.name,
-        },
-      ];
-    }
-
-    return {
-      ...attachment,
-      status: { type: "complete" },
-      content,
-    };
-  }
-}
+export { CloudFileAttachmentAdapter } from "@assistant-ui/core/react";

package/src/legacy-runtime/runtime-cores/assistant-transport/useToolInvocations.test.ts

@@ -6,18 +6,20 @@ import { act, renderHook, waitFor } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
 import type { AssistantTransportState } from "./types";
 import { ToolExecutionStatus, useToolInvocations } from "./useToolInvocations";
-import { ReadonlyJSONObject } from "assistant-stream/utils";
+import { ReadonlyJSONObject, ReadonlyJSONValue } from "assistant-stream/utils";
 
 const createState = (
   messages: ThreadAssistantMessage[],
+  isRunning: boolean = true,
 ): AssistantTransportState => ({
   messages,
-  isRunning: true,
+  isRunning,
 });
 
 const createAssistantMessage = (
   argsText: string,
   args: Record<string, unknown>,
+  options?: { result?: ReadonlyJSONValue; isError?: boolean },
 ): ThreadAssistantMessage => ({
   id: "m-1",
   role: "assistant",
@@ -37,6 +39,8 @@ const createAssistantMessage = (
       toolName: "weatherSearch",
       args: args as ReadonlyJSONObject,
       argsText,
+      ...(options?.result !== undefined && { result: options.result }),
+      ...(options?.isError !== undefined && { isError: options.isError }),
     },
   ],
 });
@@ -223,4 +227,223 @@ describe("useToolInvocations", () => {
     });
     expect(Object.keys(statuses)).not.toContain("tool-1:rewrite:0");
   });
+
+  it("does not close args stream early for non-executable tool snapshots", () => {
+    const getTools = () => ({
+      weatherSearch: {
+        parameters: { type: "object", properties: {} },
+      } satisfies Tool,
+    });
+    const onResult = vi.fn();
+    const setToolStatuses = vi.fn();
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    try {
+      const { rerender } = renderHook(
+        ({ state }: { state: AssistantTransportState }) =>
+          useToolInvocations({
+            state,
+            getTools,
+            onResult,
+            setToolStatuses,
+          }),
+        {
+          initialProps: {
+            state: createState([]),
+          },
+        },
+      );
+
+      act(() => {
+        rerender({
+          state: createState([createAssistantMessage("{}", {})]),
+        });
+      });
+
+      act(() => {
+        rerender({
+          state: createState([
+            createAssistantMessage('{"title":"Weekly"', {
+              title: "Weekly",
+            }),
+          ]),
+        });
+      });
+
+      act(() => {
+        rerender({
+          state: createState([
+            createAssistantMessage('{"title":"Weekly","columns":["name"]}', {
+              title: "Weekly",
+              columns: ["name"],
+            }),
+          ]),
+        });
+      });
+
+      expect(warnSpy).not.toHaveBeenCalledWith(
+        "argsText updated after controller was closed:",
+        expect.anything(),
+      );
+      expect(warnSpy).not.toHaveBeenCalledWith(
+        "argsText updated after controller was closed, restarting tool args stream:",
+        expect.anything(),
+      );
+      expect(onResult).not.toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it("closes non-executable complete args stream after run settles", () => {
+    const getTools = () => ({
+      weatherSearch: {
+        parameters: { type: "object", properties: {} },
+      } satisfies Tool,
+    });
+    const onResult = vi.fn();
+    const setToolStatuses = vi.fn();
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    try {
+      const { rerender } = renderHook(
+        ({ state }: { state: AssistantTransportState }) =>
+          useToolInvocations({
+            state,
+            getTools,
+            onResult,
+            setToolStatuses,
+          }),
+        {
+          initialProps: {
+            state: createState([]),
+          },
+        },
+      );
+
+      act(() => {
+        rerender({
+          state: createState(
+            [
+              createAssistantMessage('{"title":"Weekly"}', {
+                title: "Weekly",
+              }),
+            ],
+            true,
+          ),
+        });
+      });
+
+      act(() => {
+        rerender({
+          state: createState(
+            [
+              createAssistantMessage('{"title":"Weekly"}', {
+                title: "Weekly",
+              }),
+            ],
+            false,
+          ),
+        });
+      });
+
+      act(() => {
+        rerender({
+          state: createState(
+            [
+              createAssistantMessage('{"title":"Weekly","columns":["name"]}', {
+                title: "Weekly",
+                columns: ["name"],
+              }),
+            ],
+            false,
+          ),
+        });
+      });
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        "argsText updated after controller was closed, restarting tool args stream:",
+        expect.objectContaining({
+          previous: '{"title":"Weekly"}',
+          next: '{"title":"Weekly","columns":["name"]}',
+        }),
+      );
+      expect(onResult).not.toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it("handles backend result when equivalent complete argsText reorders keys", async () => {
+    let resolveExecute: ((value: unknown) => void) | undefined;
+    const execute = vi.fn(
+      () =>
+        new Promise<unknown>((resolve) => {
+          resolveExecute = resolve;
+        }),
+    );
+    const getTools = () => ({
+      weatherSearch: {
+        parameters: { type: "object", properties: {} },
+        execute,
+      } satisfies Tool,
+    });
+    const onResult = vi.fn();
+    const setToolStatuses = vi.fn();
+
+    const { rerender } = renderHook(
+      ({ state }: { state: AssistantTransportState }) =>
+        useToolInvocations({
+          state,
+          getTools,
+          onResult,
+          setToolStatuses,
+        }),
+      {
+        initialProps: {
+          state: createState([]),
+        },
+      },
+    );
+
+    act(() => {
+      rerender({
+        state: createState([
+          createAssistantMessage('{"a":1,"b":2}', {
+            a: 1,
+            b: 2,
+          }),
+        ]),
+      });
+    });
+
+    await waitFor(() => {
+      expect(execute).toHaveBeenCalledTimes(1);
+    });
+
+    act(() => {
+      rerender({
+        state: createState([
+          createAssistantMessage(
+            '{"b":2,"a":1}',
+            {
+              a: 1,
+              b: 2,
+            },
+            {
+              result: { source: "backend" },
+            },
+          ),
+        ]),
+      });
+    });
+
+    await act(async () => {
+      resolveExecute?.({ source: "client" });
+    });
+
+    await waitFor(() => {
+      expect(onResult).not.toHaveBeenCalled();
+    });
+  });
 });