@agent-native/toolkit 0.225.2-nightly-20261106152255 → 0.226.0

package/src/app/agentkit/react/components.tsx

@@ -124,12 +124,14 @@ import {
   snapshotComposerValue,
   type AgentKitComposerSubmission,
 } from "./composer-submission.js";
+import { CoreFileStorageSetupContext } from "./core-file-storage.js";
 export type { AgentKitComposerSubmission } from "./composer-submission.js";
 
 import { splitAgentKitMessageContext } from "@agent-native/agentkit";
 import type { AgentThreadState } from "@agent-native/agentkit/client";
 import {
   AgentKitCapabilityError,
+  AgentKitUploadError,
   hasActiveAgentRuns,
   isCurrentAgentSuggestion,
   selectAgentSuggestions,
@@ -6506,6 +6508,100 @@ export function AgentKitComposer({
     () => attachmentAdapter ?? createChatAttachmentAdapter(composerTranslate),
     [attachmentAdapter, composerTranslate],
   );
+  const formatUploadError = (error: unknown): string => {
+    const formatFailure = (failure: unknown): string => {
+      const code =
+        failure && typeof failure === "object" && "code" in failure
+          ? failure.code
+          : undefined;
+      const key =
+        code === "upload_too_large"
+          ? "agentChat.composer.fileTooLarge"
+          : code === "upload_session_expired"
+            ? "agentChat.composer.sessionExpired"
+            : code === "upload_unsupported_type"
+              ? "agentChat.composer.unsupportedFileType"
+              : code === "upload_network_error"
+                ? "agentChat.composer.uploadOffline"
+                : code === "upload_unavailable"
+                  ? "agentChat.composer.uploadUnavailable"
+                  : code === "upload_invalid_response"
+                    ? "agentChat.composer.uploadFailed"
+                    : undefined;
+      return key
+        ? composerTranslate(key, { size: 25 })
+        : formatAttachmentError(failure, labels.dropFileFailed);
+    };
+    return error instanceof AgentKitUploadError
+      ? error.failures
+          .map((failure) => `${failure.name}: ${formatFailure(failure.error)}`)
+          .join("\n")
+      : formatFailure(error);
+  };
+  const coreFileStorageSetup = useContext(CoreFileStorageSetupContext);
+  const storageAnchorRef = useRef<HTMLDivElement>(null);
+  const [storageState, setStorageState] = useState<
+    "unknown" | "pending" | "ready" | "missing" | "unavailable"
+  >("unknown");
+  const [storageOpen, setStorageOpen] = useState(false);
+  const storageOpenRef = useRef(false);
+  const changeStorageOpen = useCallback((open: boolean) => {
+    storageOpenRef.current = open;
+    setStorageOpen(open);
+  }, []);
+  const storageScope = useMemo(
+    () => ({ current: true }),
+    [controller, threadId, canUpload, coreFileStorageSetup?.scopeKey],
+  );
+  useEffect(() => {
+    storageScope.current = true;
+    return () => {
+      storageScope.current = false;
+    };
+  }, [storageScope, changeStorageOpen]);
+  useEffect(() => {
+    changeStorageOpen(false);
+    setStorageState("unknown");
+  }, [storageScope, changeStorageOpen]);
+  const storageReadRef = useRef<{
+    scope: typeof storageScope;
+    pending: Promise<{ configured: boolean }>;
+  } | null>(null);
+  const requestCoreAttachment = useCallback(async () => {
+    const isCurrentScope = () => storageScope.current;
+    if (!canUpload || !isCurrentScope() || !coreFileStorageSetup)
+      return "stale" as const;
+    setStorageState("pending");
+    changeStorageOpen(false);
+    const previous = storageReadRef.current;
+    const sharedRead =
+      previous?.scope === storageScope ? previous.pending : null;
+    const pending = sharedRead ?? coreFileStorageSetup.readStatus();
+    storageReadRef.current = { scope: storageScope, pending };
+    try {
+      const status = await pending;
+      if (!isCurrentScope()) return "stale" as const;
+      setStorageState(status.configured ? "ready" : "missing");
+      changeStorageOpen(!status.configured);
+      return status.configured ? ("ready" as const) : ("missing" as const);
+    } catch (error) {
+      if (!isCurrentScope()) return "stale" as const;
+      setStorageState("unavailable");
+      changeStorageOpen(true);
+      onAttachmentError?.(formatAttachmentError(error, labels.dropFileFailed));
+      return "unavailable" as const;
+    } finally {
+      const currentRead = () => storageReadRef.current;
+      if (currentRead()?.pending === pending) storageReadRef.current = null;
+    }
+  }, [
+    canUpload,
+    coreFileStorageSetup,
+    storageScope,
+    onAttachmentError,
+    labels.dropFileFailed,
+    changeStorageOpen,
+  ]);
   const starting = useAgentKitSubmissionStarting(threadId);
   const active = hasActiveRuns(thread) || starting;
   const composerInitialText = editingMessage
@@ -6538,10 +6634,12 @@ export function AgentKitComposer({
     return true;
   };
   const focusComposer = useCallback(() => {
-    if (!autoFocus) return;
+    if (!autoFocus || storageOpenRef.current) return;
     composerRef.current?.focus();
     if (typeof globalThis.requestAnimationFrame === "function") {
-      globalThis.requestAnimationFrame(() => composerRef.current?.focus());
+      globalThis.requestAnimationFrame(() => {
+        if (!storageOpenRef.current) composerRef.current?.focus();
+      });
     }
   }, [autoFocus]);
   const reportAttachmentError = useCallback(
@@ -6650,6 +6748,25 @@ export function AgentKitComposer({
     const onLocalSubmit = () => {
       options.onLocalSubmit?.();
     };
+    if (files.length && !uploadGateRef.current.enabled) {
+      throw new AgentKitCapabilityError(
+        "uploads",
+        "unavailable",
+        uploadGateRef.current.reason ?? labels.error,
+      );
+    }
+    if (files.length && coreFileStorageSetup) {
+      const status = await requestCoreAttachment();
+      if (status !== "ready") {
+        throw new Error(
+          composerTranslate(
+            status === "missing"
+              ? "onboarding.fileStorage.title"
+              : "onboarding.fileStorage.statusUnavailable",
+          ),
+        );
+      }
+    }
     if (!editingMessage && onSubmitOverride) {
       const readinessEngine = options.engine ?? selectedEngine;
       await controller.assertAiSetupReady({
@@ -6663,13 +6780,6 @@ export function AgentKitComposer({
       await onSubmitOverride(text, files, references, submitOptions);
       return;
     }
-    if (files.length && !uploadGateRef.current.enabled) {
-      throw new AgentKitCapabilityError(
-        "uploads",
-        "unavailable",
-        uploadGateRef.current.reason ?? labels.error,
-      );
-    }
     const effort = options.effort;
     const executionMode = options.requestMode ?? "act";
     const contextItemsForSubmission = options.contextItems ?? contextItems;
@@ -6911,7 +7021,40 @@ export function AgentKitComposer({
   const suggestions = selectAgentSuggestions(thread);
   return (
     <ComposerNoticeScope>
-      <div className={`agentkit-composer-stack ${className ?? ""}`}>
+      <div
+        ref={storageAnchorRef}
+        className={`agentkit-composer-stack ${className ?? ""}`}
+      >
+        {coreFileStorageSetup && canUpload && (
+          <>
+            <coreFileStorageSetup.Setup
+              open={storageOpen}
+              anchorRef={storageAnchorRef}
+              onOpenChange={(open) => {
+                changeStorageOpen(open);
+                if (!open) composerRef.current?.focus();
+              }}
+              onConnected={() => {
+                void requestCoreAttachment();
+              }}
+              {...(storageState === "unavailable"
+                ? {
+                    status: "unavailable" as const,
+                    onRetry: () => {
+                      void requestCoreAttachment();
+                    },
+                  }
+                : { status: "missing" as const })}
+            />
+            {storageState === "pending" && (
+              <span role="status" className="text-sm text-foreground">
+                {composerTranslate("agentChat.common.loading", {
+                  defaultValue: "Loading...",
+                })}
+              </span>
+            )}
+          </>
+        )}
         {announcePendingSubmission && submissionPending ? (
           <span
             className="agentkit-visually-hidden"
@@ -7134,6 +7277,10 @@ export function AgentKitComposer({
           stopButton={stopButton === undefined ? defaultStopButton : stopButton}
           noticeOutlet
           attachmentsEnabled={canUpload}
+          onAttachmentRequest={onAttachmentRequest}
+          contextButtonTooltipDisabled={
+            contextButtonTooltipDisabled || storageOpen
+          }
           includeDefaultSlashCommands={includeDefaultSlashCommands ?? false}
           includeDefaultSlashSkills={includeDefaultSlashSkills ?? false}
           plusMenuMode={plusMenuMode ?? "full"}
@@ -7170,7 +7317,7 @@ export function AgentKitComposer({
             dismissLabel={labels.dismissNotice}
           >
             <span {...SESSION_REPLAY_MASK_PROPS}>
-              {sendOrCommandError.message}
+              {formatUploadError(sendOrCommandError)}
             </span>
           </ComposerNotice>
         ) : null}

package/src/app/agentkit/react/composer-context.spec.tsx

@@ -18,6 +18,8 @@ import type {
   AgentChatContextItem,
   ComposerContextMenuItem,
 } from "../../../agentkit.js";
+import { ComposerRuntimeAdaptersProvider } from "../../../composer/runtime-adapters.js";
+import { FileStorageSetupPopover } from "../../chat/FileStorageSetupPopover.js";
 import {
   AgentKitChat,
   AgentKitComposer,
@@ -25,9 +27,14 @@ import {
 } from "./components.js";
 import { createAgentKitComposerSubmission } from "./composer-submission.js";
 import { AgentKitProvider } from "./context.js";
+import { CoreFileStorageSetupContext } from "./core-file-storage.js";
 
 const capture = vi.hoisted(() => ({
   props: undefined as PromptComposerProps | undefined,
+  storageStatus: vi.fn(),
+  storage: undefined as
+    | { open: boolean; status?: string; onRetry?: () => void }
+    | undefined,
 }));
 vi.mock("../../../agentkit.js", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../../../agentkit.js")>();
@@ -40,6 +47,20 @@ vi.mock("../../../agentkit.js", async (importOriginal) => {
   };
 });
 
+vi.mock("@agent-native/core/client/uploads", () => ({
+  readFileUploadStatus: capture.storageStatus,
+}));
+vi.mock("../../chat/FileStorageSetupPopover.js", () => ({
+  FileStorageSetupPopover: (props: {
+    open: boolean;
+    status?: string;
+    onRetry?: () => void;
+  }) => {
+    capture.storage = props;
+    return null;
+  },
+}));
+
 let root: Root;
 let container: HTMLDivElement;
 let client: AgentKitClient;
@@ -50,6 +71,8 @@ beforeEach(() => {
   document.body.append(container);
   root = createRoot(container);
   capture.props = undefined;
+  capture.storage = undefined;
+  capture.storageStatus.mockReset();
 });
 
 afterEach(async () => {
@@ -98,6 +121,163 @@ function withActiveRun(runtime: ReturnType<typeof transport>) {
 }
 
 describe("AgentKit composer context submission", () => {
+  it.each(["missing", "unavailable"] as const)(
+    "blocks raw-file custom submissions with visible %s storage state",
+    async (state) => {
+      client = new AgentKitClient({
+        transport: { ...transport(), capabilities: { uploads: true } },
+      });
+      if (state === "missing")
+        capture.storageStatus.mockResolvedValue({ configured: false });
+      else capture.storageStatus.mockRejectedValue(new Error("Status denied"));
+      const submit = vi.fn();
+      const upload = vi.spyOn(client, "uploadFiles");
+      await act(async () =>
+        root.render(
+          <AgentKitProvider controller={client} threadId="thread-1">
+            <CoreFileStorageSetupContext.Provider
+              value={{
+                scopeKey: "user-1:org-1",
+                readStatus: capture.storageStatus,
+                Setup: FileStorageSetupPopover,
+              }}
+            >
+              <AgentKitComposer onSubmit={submit} />
+            </CoreFileStorageSetupContext.Provider>
+          </AgentKitProvider>,
+        ),
+      );
+      await act(async () => {
+        await expect(
+          capture.props?.onSubmit(
+            "Preserve draft",
+            [new File(["bytes"], "note.txt")],
+            [],
+            {},
+          ),
+        ).rejects.toThrow();
+      });
+      expect(submit).not.toHaveBeenCalled();
+      expect(upload).not.toHaveBeenCalled();
+      expect(capture.storage?.open).toBe(true);
+      expect(capture.storage?.status).toBe(state);
+    },
+  );
+  it("localizes create-upload failures while retaining the original draft and files", async () => {
+    const failure = Object.assign(new Error("upload_too_large"), {
+      code: "upload_too_large",
+      status: 413,
+    });
+    const runtime = {
+      ...transport(),
+      capabilities: { uploads: true },
+      createUpload: vi.fn().mockRejectedValue(failure),
+      completeUpload: vi.fn(),
+    } satisfies AgentTransport;
+    const upload = vi.fn();
+    client = new AgentKitClient({ transport: runtime, upload });
+    const onLocalSubmit = vi.fn();
+    await act(async () =>
+      root.render(
+        <ComposerRuntimeAdaptersProvider
+          adapters={{ translate: (key) => `translated:${key}` }}
+        >
+          <AgentKitProvider controller={client} threadId="thread-1">
+            <AgentKitComposer initialText="Original draft" />
+          </AgentKitProvider>
+        </ComposerRuntimeAdaptersProvider>,
+      ),
+    );
+    const files = [
+      new File(["Original bytes"], "note.txt", { type: "text/plain" }),
+    ];
+    await act(async () => {
+      await expect(
+        capture.props?.onSubmit("Original draft", files, [], { onLocalSubmit }),
+      ).rejects.toThrow();
+    });
+    expect(runtime.createUpload).toHaveBeenCalledOnce();
+    expect(upload).not.toHaveBeenCalled();
+    expect(runtime.startRun).not.toHaveBeenCalled();
+    expect(onLocalSubmit).not.toHaveBeenCalled();
+    expect(files[0].name).toBe("note.txt");
+    expect(container.textContent).toContain(
+      "translated:agentChat.composer.fileTooLarge",
+    );
+    expect(container.textContent).not.toContain("upload_too_large");
+  });
+  it("ignores a delayed storage response after the identity scope changes", async () => {
+    client = new AgentKitClient({
+      transport: { ...transport(), capabilities: { uploads: true } },
+    });
+    let resolveStatus: ((value: { configured: boolean }) => void) | undefined;
+    capture.storageStatus.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          resolveStatus = resolve;
+        }),
+    );
+    const render = (scopeKey: string) =>
+      root.render(
+        <AgentKitProvider controller={client} threadId="thread-1">
+          <CoreFileStorageSetupContext.Provider
+            value={{
+              scopeKey,
+              readStatus: capture.storageStatus,
+              Setup: FileStorageSetupPopover,
+            }}
+          >
+            <AgentKitComposer />
+          </CoreFileStorageSetupContext.Provider>
+        </AgentKitProvider>,
+      );
+    await act(async () => render("user-1:org-1"));
+    let submission: Promise<unknown> | undefined;
+    await act(async () => {
+      submission = capture.props?.onSubmit(
+        "draft",
+        [new File(["bytes"], "note.txt")],
+        [],
+        {},
+      );
+    });
+    await act(async () => render("user-2:org-2"));
+    await act(async () => {
+      resolveStatus?.({ configured: false });
+      await submission?.catch(() => undefined);
+    });
+    expect(capture.storage?.open).toBe(false);
+    expect(capture.props?.attachmentsEnabled).toBe(true);
+  });
+  it("preserves supported external upload adapters without querying Core storage", async () => {
+    client = new AgentKitClient({
+      transport: { ...transport(), capabilities: { uploads: true } },
+    });
+    await act(async () =>
+      root.render(
+        <AgentKitProvider controller={client} threadId="thread-1">
+          <AgentKitComposer />
+        </AgentKitProvider>,
+      ),
+    );
+    expect(capture.props?.attachmentsEnabled).toBe(true);
+    expect(capture.props?.onAttachmentRequest).toBeUndefined();
+    expect(capture.storageStatus).not.toHaveBeenCalled();
+  });
+  it("keeps unsupported generic transports outside the Core storage setup flow", async () => {
+    client = new AgentKitClient({ transport: transport() });
+    await act(async () =>
+      root.render(
+        <AgentKitProvider controller={client} threadId="thread-1">
+          <AgentKitComposer />
+        </AgentKitProvider>,
+      ),
+    );
+    expect(capture.props?.attachmentsEnabled).toBe(false);
+    expect(capture.props?.onAttachmentRequest).toBeUndefined();
+    expect(capture.storageStatus).not.toHaveBeenCalled();
+  });
+
   it.each([
     ["immediate", "capability"],
     ["queued", "capability"],

package/src/app/agentkit/react/core-file-storage.tsx

@@ -0,0 +1,14 @@
+import { createContext, type ComponentType, type RefObject } from "react";
+
+type SetupProps = {
+  open: boolean;
+  anchorRef: RefObject<HTMLElement | null>;
+  onOpenChange: (open: boolean) => void;
+  onConnected: () => void;
+} & ({ status: "missing" } | { status: "unavailable"; onRetry: () => void });
+
+export const CoreFileStorageSetupContext = createContext<{
+  scopeKey: string;
+  readStatus: () => Promise<{ configured: boolean }>;
+  Setup: ComponentType<SetupProps>;
+} | null>(null);

package/src/app/auth/AuthPage.interaction.spec.tsx

@@ -43,6 +43,149 @@ describe("AuthPage interactions", () => {
     vi.unstubAllGlobals();
   });
 
+  it.each(["control", "automatic"] as const)(
+    "shows Builder legal disclosure before Google-only signup only for the %s assignment",
+    async (variant) => {
+      vi.stubGlobal(
+        "fetch",
+        vi.fn(async (input: RequestInfo | URL) => ({
+          ok: true,
+          status: 200,
+          json: async () =>
+            String(input).includes("builder-signup-experiment")
+              ? {
+                  status: "assigned",
+                  id: "a".repeat(32),
+                  variant,
+                  policy: "builder-signup-2026-11-06",
+                }
+              : { available: false },
+        })),
+      );
+      await act(async () => {
+        root.render(
+          <AuthPage
+            {...propsFromHtml(
+              getOnboardingHtml({
+                requestHost: "127.0.0.1",
+                requestPath: "/signup",
+              }),
+            )}
+            trackingApp="design"
+            googleOnly
+            showGoogle
+            identitySsoEnabled={false}
+          />,
+        );
+      });
+      expect(
+        container.textContent?.includes(
+          "Your Design signup also creates a Builder.io account",
+        ),
+      ).toBe(variant === "automatic");
+      expect(
+        container.querySelector<HTMLButtonElement>("#google-btn")?.disabled,
+      ).toBe(false);
+      if (variant === "automatic") {
+        expect(
+          container.querySelector(
+            'a[href="https://www.builder.io/legal/terms"]',
+          ),
+        ).not.toBeNull();
+        expect(
+          container.querySelector(
+            'a[href="https://www.builder.io/legal/privacy"]',
+          ),
+        ).not.toBeNull();
+      }
+    },
+  );
+
+  it.each([200, 409])(
+    "opens Google immediately and preserves the existing flow when acceptance returns %s",
+    async (acceptStatus) => {
+      window.history.replaceState({}, "", "/signup");
+      const popup = {
+        closed: false,
+        location: { href: "" },
+      } as unknown as Window;
+      const open = vi.fn(() => popup);
+      vi.stubGlobal("open", open);
+      let accept: () => void = () => {
+        throw new Error("Acceptance has not started");
+      };
+      const oauthRequests = vi.fn();
+      let oauthUrl: string | undefined;
+      vi.stubGlobal(
+        "fetch",
+        vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
+          const url = String(input);
+          if (
+            url.includes("builder-signup-experiment") &&
+            init?.method === "POST"
+          ) {
+            return new Promise<Response>((resolve) => {
+              accept = () =>
+                resolve(
+                  new Response(JSON.stringify({ status: "accepted" }), {
+                    status: acceptStatus,
+                  }),
+                );
+            });
+          }
+          if (url.includes("google/auth-url")) {
+            oauthUrl = url;
+            oauthRequests();
+            return new Promise<Response>(() => {});
+          }
+          return Promise.resolve(
+            new Response(
+              JSON.stringify(
+                url.includes("builder-signup-experiment")
+                  ? {
+                      status: "assigned",
+                      id: "a".repeat(32),
+                      variant: "automatic",
+                      policy: "builder-signup-2026-11-06",
+                    }
+                  : { available: false },
+              ),
+            ),
+          );
+        }),
+      );
+      await act(async () => {
+        root.render(
+          <AuthPage
+            {...propsFromHtml(
+              getOnboardingHtml({
+                requestHost: "127.0.0.1",
+                requestPath: "/signup",
+              }),
+            )}
+            trackingApp="design"
+            identitySsoEnabled={false}
+            googleViaIdentitySso={false}
+            googleAuthMode="popup"
+            showGoogle
+          />,
+        );
+      });
+      const button = container.querySelector<HTMLButtonElement>("#google-btn");
+      await act(async () => button?.click());
+      expect(open).toHaveBeenCalledTimes(1);
+      expect(button?.getAttribute("aria-busy")).toBe("true");
+      expect(oauthRequests).not.toHaveBeenCalled();
+      await act(async () => accept());
+      expect(oauthRequests).toHaveBeenCalledTimes(1);
+      expect(
+        new URL(oauthUrl ?? "", "https://design.example.com").searchParams.has(
+          "builder_signup_attempt",
+        ),
+      ).toBe(acceptStatus === 200);
+    },
+  );
+
   it("opens and closes the auth options without dropping focus from the localized toggle", async () => {
     await act(async () => {
       root.render(