assistant-ui 0.0.112 → 0.0.114

package/src/lib/create-project.test.ts

@@ -0,0 +1,175 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { reconcileAssistantUIImportLayout } from "./create-project";
+
+describe("reconcileAssistantUIImportLayout", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "aui-cli-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  const write = (file: string, content: string) => {
+    const fullPath = path.join(projectDir, file);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+  };
+
+  const read = (file: string) =>
+    fs.readFileSync(path.join(projectDir, file), "utf8");
+
+  it("rewrites a legacy import when only the elements layout exists", async () => {
+    write(
+      "app/page.tsx",
+      'import { Thread } from "@/components/assistant-ui/thread";\n' +
+        'import { ThreadList } from "@/components/assistant-ui/thread-list";\n',
+    );
+    write("components/assistant-ui/elements/thread.aui.tsx", "export {};");
+    write("components/assistant-ui/elements/thread-list.aui.tsx", "export {};");
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("app/page.tsx")).toBe(
+      'import { Thread } from "@/components/assistant-ui/elements/thread.aui";\n' +
+        'import { ThreadList } from "@/components/assistant-ui/elements/thread-list.aui";\n',
+    );
+  });
+
+  it("rewrites module declarations without changing import-like source text", async () => {
+    write(
+      "app/page.tsx",
+      'import { Thread } from "@/components/assistant-ui/thread";\n' +
+        'export { ThreadList } from "@/components/assistant-ui/thread-list";\n' +
+        "const example = 'from \"@/components/assistant-ui/thread\"';\n" +
+        '// from "@/components/assistant-ui/thread-list"\n',
+    );
+    write("components/assistant-ui/elements/thread.aui.tsx", "export {};");
+    write("components/assistant-ui/elements/thread-list.aui.tsx", "export {};");
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("app/page.tsx")).toBe(
+      'import { Thread } from "@/components/assistant-ui/elements/thread.aui";\n' +
+        'export { ThreadList } from "@/components/assistant-ui/elements/thread-list.aui";\n' +
+        "const example = 'from \"@/components/assistant-ui/thread\"';\n" +
+        '// from "@/components/assistant-ui/thread-list"\n',
+    );
+  });
+
+  it("rewrites a legacy import to a bare elements file without the .aui segment", async () => {
+    write(
+      "app/MyThread.tsx",
+      'import { MarkdownText } from "@/components/assistant-ui/markdown-text";\n' +
+        'import { TooltipIconButton } from "@/components/assistant-ui/tooltip-icon-button";\n',
+    );
+    write("components/assistant-ui/elements/markdown-text.tsx", "export {};");
+    write(
+      "components/assistant-ui/elements/tooltip-icon-button.tsx",
+      "export {};",
+    );
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("app/MyThread.tsx")).toBe(
+      'import { MarkdownText } from "@/components/assistant-ui/elements/markdown-text";\n' +
+        'import { TooltipIconButton } from "@/components/assistant-ui/elements/tooltip-icon-button";\n',
+    );
+  });
+
+  it("prefers the .aui variant when both variants share a basename", async () => {
+    write(
+      "app/page.tsx",
+      'import { Reasoning } from "@/components/assistant-ui/reasoning";\n',
+    );
+    write("components/assistant-ui/elements/reasoning.tsx", "export {};");
+    write("components/assistant-ui/elements/reasoning.aui.tsx", "export {};");
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("app/page.tsx")).toBe(
+      'import { Reasoning } from "@/components/assistant-ui/elements/reasoning.aui";\n',
+    );
+  });
+
+  it("supports the src/ project layout", async () => {
+    write(
+      "src/routes/index.tsx",
+      'import { Thread } from "@/components/assistant-ui/thread";\n',
+    );
+    write("src/components/assistant-ui/elements/thread.aui.tsx", "export {};");
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("src/routes/index.tsx")).toBe(
+      'import { Thread } from "@/components/assistant-ui/elements/thread.aui";\n',
+    );
+  });
+
+  it("leaves imports alone when the legacy file exists", async () => {
+    const source =
+      'import { Thread } from "@/components/assistant-ui/thread";\n';
+    write("app/page.tsx", source);
+    write("components/assistant-ui/thread.tsx", "export {};");
+    write("components/assistant-ui/elements/thread.aui.tsx", "export {};");
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("app/page.tsx")).toBe(source);
+  });
+
+  it("leaves imports alone when neither layout has the file", async () => {
+    const source =
+      'import { Custom } from "@/components/assistant-ui/custom-part";\n';
+    write("app/page.tsx", source);
+    write("components/assistant-ui/elements/thread.aui.tsx", "export {};");
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("app/page.tsx")).toBe(source);
+  });
+
+  it("leaves elements imports untouched", async () => {
+    const source =
+      'import { Thread } from "@/components/assistant-ui/elements/thread.aui";\n';
+    write("app/page.tsx", source);
+    write("components/assistant-ui/elements/thread.aui.tsx", "export {};");
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("app/page.tsx")).toBe(source);
+  });
+
+  it("parses TypeScript files with generic arrow functions", async () => {
+    write(
+      "app/helpers.ts",
+      'import { Thread } from "@/components/assistant-ui/thread";\n' +
+        "export const identity = <T>(value: T) => value;\n",
+    );
+    write("components/assistant-ui/elements/thread.aui.tsx", "export {};");
+
+    await reconcileAssistantUIImportLayout(projectDir);
+
+    expect(read("app/helpers.ts")).toBe(
+      'import { Thread } from "@/components/assistant-ui/elements/thread.aui";\n' +
+        "export const identity = <T>(value: T) => value;\n",
+    );
+  });
+
+  it("leaves unparseable source files untouched", async () => {
+    const source =
+      'import { Thread } from "@/components/assistant-ui/thread";\nconst broken = ;\n';
+    write("app/broken.ts", source);
+    write("components/assistant-ui/elements/thread.aui.tsx", "export {};");
+
+    await expect(
+      reconcileAssistantUIImportLayout(projectDir),
+    ).resolves.toBeUndefined();
+    expect(read("app/broken.ts")).toBe(source);
+  });
+});

package/src/lib/create-project.ts

@@ -1,17 +1,15 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { downloadTemplate } from "giget";
-import { sync as globSync } from "glob";
-import { detect } from "detect-package-manager";
 import {
   parse as parseJsonc,
   printParseErrorCode,
   type ParseError,
 } from "jsonc-parser";
 import { logger } from "./utils/logger";
-import { runSpawn, SpawnExitError } from "./run-spawn";
-
-export type PackageManagerName = "npm" | "pnpm" | "yarn" | "bun";
+import { runSpawn, SpawnExitError, SpawnSignalError } from "./run-spawn";
+import { type PackageManagerName } from "./utils/package-manager";
+import { readProjectFiles } from "./utils/file-scanner";
 
 export function dlxCommand(pm: PackageManagerName): [string, string[]] {
   switch (pm) {
@@ -186,30 +184,6 @@ export async function scaffoldProject(
   }
 }
 
-function detectFromUserAgent(): PackageManagerName | undefined {
-  const ua = process.env.npm_config_user_agent;
-  if (!ua) return undefined;
-  if (ua.startsWith("bun/")) return "bun";
-  if (ua.startsWith("pnpm/")) return "pnpm";
-  if (ua.startsWith("yarn/")) return "yarn";
-  if (ua.startsWith("npm/")) return "npm";
-  return undefined;
-}
-
-export async function resolvePackageManagerForCwd(
-  cwd: string,
-  packageManager?: PackageManagerName,
-): Promise<PackageManagerName> {
-  if (packageManager) return packageManager;
-  const fromAgent = detectFromUserAgent();
-  if (fromAgent) return fromAgent;
-  try {
-    return await detect({ cwd });
-  } catch {
-    return "npm";
-  }
-}
-
 export interface TransformResult {
   registryInstallFailure?: { retryCommand: string };
 }
@@ -246,11 +220,8 @@ export async function transformProject(
     shadcnUI &&
     assistantUI
   ) {
-    const allShadcn = shadcnUI.includes("utils")
-      ? shadcnUI
-      : [...shadcnUI, "utils"];
     const auiComponents = assistantUI.map((c) => `@assistant-ui/${c}`);
-    const components = [...allShadcn, ...auiComponents];
+    const components = ["@assistant-ui/utils", ...shadcnUI, ...auiComponents];
     logger.step(`Installing components: ${components.join(", ")}...`);
     const failure = await installShadcnRegistry(
       projectDir,
@@ -259,6 +230,7 @@ export async function transformProject(
       pm,
     );
     if (failure) return { registryInstallFailure: failure };
+    await reconcileAssistantUIImportLayout(projectDir);
   }
   return {};
 }
@@ -383,16 +355,11 @@ function transformTsConfig(projectDir: string): void {
 }
 
 function transformCssFiles(projectDir: string): void {
-  const cssFiles = globSync("**/*.css", {
+  for (const { fullPath, content } of readProjectFiles("**/*.css", {
     cwd: projectDir,
     ignore: LOCAL_PROJECT_ARTIFACT_GLOB_IGNORES,
-  });
-
-  for (const file of cssFiles) {
-    const fullPath = path.join(projectDir, file);
+  })) {
     try {
-      const content = fs.readFileSync(fullPath, "utf-8");
-
       const newContent = content.replace(
         /@source\s+["'][^"']*packages\/ui\/src[^"']*["'];\s*\n?/g,
         "",
@@ -402,7 +369,7 @@ function transformCssFiles(projectDir: string): void {
         fs.writeFileSync(fullPath, newContent);
       }
     } catch {
-      // Ignore files that cannot be read/written
+      continue;
     }
   }
 }
@@ -416,32 +383,189 @@ function stripImportExtension(component: string): string {
   return component.replace(/\.[cm]?[tj]sx?$/, "");
 }
 
-function scanRequiredComponents(projectDir: string): RequiredComponents {
-  const files = globSync("**/*.{ts,tsx}", {
+const ASSISTANT_UI_OWNED_UI = new Set([
+  "accordion",
+  "badge",
+  "diff-viewer",
+  "direction",
+  "dot-matrix",
+  "number-roll",
+  "select",
+  "tabs",
+]);
+
+const BARE_ELEMENT_ITEMS = new Set([
+  "file",
+  "generative-ui",
+  "heat-graph",
+  "image",
+  "logos",
+  "markdown-text",
+  "syntax-highlighter",
+  "tooltip-icon-button",
+]);
+
+function toAssistantUIItem(specifier: string): string | null {
+  let name = stripImportExtension(specifier);
+  const inElements = name.startsWith("elements/");
+  if (inElements) {
+    name = name.slice("elements/".length);
+  } else if (name.includes("/")) {
+    return null;
+  }
+  if (name.endsWith(".aui")) {
+    return name.slice(0, -".aui".length);
+  }
+  return inElements && !BARE_ELEMENT_ITEMS.has(name)
+    ? `elements-${name}`
+    : name;
+}
+
+/**
+ * Example snapshots are downloaded at a release tag while the shadcn registry
+ * is live, so a snapshot may import components at the legacy flat path
+ * (`@/components/assistant-ui/<name>`) after the registry has moved the file
+ * to `components/assistant-ui/elements/<name>.aui.tsx`. Resolve each legacy
+ * specifier against the files the registry actually installed and rewrite it
+ * only when the legacy path is absent and the elements layout has it.
+ */
+export async function reconcileAssistantUIImportLayout(
+  projectDir: string,
+): Promise<void> {
+  const componentRoots = ["components", "src/components"]
+    .map((dir) => path.join(projectDir, dir, "assistant-ui"))
+    .filter((dir) => fs.existsSync(dir));
+  if (componentRoots.length === 0) return;
+
+  const resolvesAtLegacyPath = (name: string) =>
+    componentRoots.some((root) =>
+      [".tsx", ".ts", "/index.tsx", "/index.ts"].some((suffix) =>
+        fs.existsSync(path.join(root, `${name}${suffix}`)),
+      ),
+    );
+
+  // Index the installed tree by import name so the rewrite follows whatever
+  // layout the registry delivered — some items install as
+  // elements/<name>.aui.tsx, others as elements/<name>.tsx, and a future
+  // layout move should not require new knowledge here.
+  const installedByName = new Map<string, string>();
+  for (const root of componentRoots) {
+    for (const { file } of readProjectFiles("**/*.{ts,tsx}", { cwd: root })) {
+      const normalized = file.split(path.sep).join("/");
+      if (!normalized.includes("/")) continue;
+      const specifier = normalized.replace(/\.[cm]?[tj]sx?$/, "");
+      const name = path.posix.basename(specifier).replace(/\.aui$/, "");
+      // A flat legacy import maps to the registry's `<name>` item, which is
+      // the `.aui` file; a colliding bare file with the same basename belongs
+      // to the distinct `elements-<name>` item, so the `.aui` variant wins.
+      const existing = installedByName.get(name);
+      if (
+        existing === undefined ||
+        (!existing.endsWith(".aui") && specifier.endsWith(".aui"))
+      ) {
+        installedByName.set(name, specifier);
+      }
+    }
+  }
+  if (installedByName.size === 0) return;
+
+  const { default: jscodeshift } = await import("jscodeshift");
+  const parsers = {
+    ts: jscodeshift.withParser("ts"),
+    tsx: jscodeshift.withParser("tsx"),
+  };
+
+  for (const { fullPath, content } of readProjectFiles("**/*.{ts,tsx}", {
     cwd: projectDir,
     ignore: LOCAL_PROJECT_ARTIFACT_GLOB_IGNORES,
-  });
+  })) {
+    if (!content.includes("@/components/assistant-ui/")) continue;
+
+    const replacements: Array<{ start: number; end: number; value: string }> =
+      [];
+    const collectReplacement = (source: {
+      value?: unknown;
+      start?: number | null;
+      end?: number | null;
+    }) => {
+      if (
+        typeof source.value !== "string" ||
+        source.start == null ||
+        source.end == null
+      ) {
+        return;
+      }
 
-  const assistantUIComponents = new Set<string>();
-  const shadcnUIComponents = new Set<string>();
+      const prefix = "@/components/assistant-ui/";
+      if (!source.value.startsWith(prefix)) return;
+      const specifier = source.value.slice(prefix.length);
+      if (specifier.includes("/")) return;
+
+      const name = stripImportExtension(specifier);
+      const installed = installedByName.get(name);
+      if (resolvesAtLegacyPath(name) || installed === undefined) return;
+
+      const raw = content.slice(source.start, source.end);
+      const quote = raw[0];
+      if ((quote !== '"' && quote !== "'") || raw.at(-1) !== quote) return;
+      replacements.push({
+        start: source.start,
+        end: source.end,
+        value: `${quote}@/components/assistant-ui/${installed}${quote}`,
+      });
+    };
 
-  for (const file of files) {
-    const fullPath = path.join(projectDir, file);
+    const j = fullPath.endsWith(".tsx") ? parsers.tsx : parsers.ts;
+    let root;
     try {
-      const content = fs.readFileSync(fullPath, "utf-8");
+      root = j(content);
+    } catch {
+      continue;
+    }
+    root
+      .find(j.ImportDeclaration)
+      .forEach(({ node }) => collectReplacement(node.source));
+    root
+      .find(j.ExportNamedDeclaration)
+      .forEach(({ node }) => node.source && collectReplacement(node.source));
+    root
+      .find(j.ExportAllDeclaration)
+      .forEach(({ node }) => collectReplacement(node.source));
+
+    let next = content;
+    for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
+      next =
+        next.slice(0, replacement.start) +
+        replacement.value +
+        next.slice(replacement.end);
+    }
+    if (next !== content) fs.writeFileSync(fullPath, next);
+  }
+}
 
-      const assistantUIRegex =
-        /from\s+["']@\/components\/assistant-ui\/([^"']+)["']/g;
-      for (const match of content.matchAll(assistantUIRegex)) {
-        assistantUIComponents.add(stripImportExtension(match[1]!));
-      }
+function scanRequiredComponents(projectDir: string): RequiredComponents {
+  const assistantUIComponents = new Set<string>();
+  const shadcnUIComponents = new Set<string>();
 
-      const uiRegex = /from\s+["']@\/components\/ui\/([^"']+)["']/g;
-      for (const match of content.matchAll(uiRegex)) {
-        shadcnUIComponents.add(stripImportExtension(match[1]!));
+  for (const { content } of readProjectFiles("**/*.{ts,tsx}", {
+    cwd: projectDir,
+    ignore: LOCAL_PROJECT_ARTIFACT_GLOB_IGNORES,
+  })) {
+    const assistantUIRegex =
+      /from\s+["']@\/components\/assistant-ui\/([^"']+)["']/g;
+    for (const match of content.matchAll(assistantUIRegex)) {
+      const item = toAssistantUIItem(match[1]!);
+      if (item) assistantUIComponents.add(item);
+    }
+
+    const uiRegex = /from\s+["']@\/components\/ui\/([^"']+)["']/g;
+    for (const match of content.matchAll(uiRegex)) {
+      const name = stripImportExtension(match[1]!);
+      if (ASSISTANT_UI_OWNED_UI.has(name)) {
+        assistantUIComponents.add(name);
+      } else {
+        shadcnUIComponents.add(name);
       }
-    } catch {
-      // Ignore files that cannot be read
     }
   }
 
@@ -459,6 +583,9 @@ async function installDependencies(
   try {
     await runSpawn(pm, args, projectDir);
   } catch (error) {
+    if (error instanceof SpawnSignalError) {
+      throw error;
+    }
     if (error instanceof SpawnExitError) {
       throw new Error(`${pm} install exited with code ${error.code}`);
     }
@@ -483,6 +610,9 @@ async function installShadcnRegistry(
     await runSpawn(cmd, addArgs, projectDir);
     return undefined;
   } catch (error) {
+    if (error instanceof SpawnSignalError) {
+      throw error;
+    }
     if (error instanceof SpawnExitError) {
       logger.warn(`shadcn exited with code ${error.code}.`);
       return { retryCommand: `${cmd} ${retryArgs.join(" ")}` };

package/src/lib/handle-cli-error.test.ts

@@ -0,0 +1,67 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { handleCliError } from "./handle-cli-error";
+import { SpawnExitError, SpawnSignalError } from "./run-spawn";
+
+describe("handleCliError", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+  });
+
+  it("exits by the forwarded signal's status and re-raises it", () => {
+    const kill = vi.spyOn(process, "kill").mockReturnValue(true);
+
+    handleCliError(new SpawnSignalError("SIGINT", true));
+
+    expect(process.exitCode).toBe(130);
+    expect(kill).toHaveBeenCalledWith(process.pid, "SIGINT");
+  });
+
+  it("maps SIGTERM to 143", () => {
+    const kill = vi.spyOn(process, "kill").mockReturnValue(true);
+
+    handleCliError(new SpawnSignalError("SIGTERM", true));
+
+    expect(process.exitCode).toBe(143);
+    expect(kill).toHaveBeenCalledWith(process.pid, "SIGTERM");
+  });
+
+  it("reports a signal the child raised on itself without re-raising it", () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const kill = vi.spyOn(process, "kill").mockReturnValue(true);
+
+    handleCliError(new SpawnSignalError("SIGKILL", false));
+
+    expect(process.exitCode).toBe(137);
+    expect(kill).not.toHaveBeenCalled();
+    expect(consoleError).toHaveBeenCalledWith("Process terminated by SIGKILL");
+  });
+
+  it("stays silent on a signal the user sent", () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    vi.spyOn(process, "kill").mockReturnValue(true);
+
+    handleCliError(new SpawnSignalError("SIGINT", true));
+
+    expect(consoleError).not.toHaveBeenCalled();
+  });
+
+  it("reports any other failure as exit 1", () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const kill = vi.spyOn(process, "kill").mockReturnValue(true);
+    const error = new SpawnExitError(7);
+
+    handleCliError(error);
+
+    expect(process.exitCode).toBe(1);
+    expect(kill).not.toHaveBeenCalled();
+    expect(consoleError).toHaveBeenCalledWith(error);
+  });
+});

package/src/lib/handle-cli-error.ts

@@ -0,0 +1,17 @@
+import { constants } from "node:os";
+import { SpawnSignalError } from "./run-spawn";
+
+export function handleCliError(error: unknown): void {
+  if (error instanceof SpawnSignalError) {
+    process.exitCode = 128 + (constants.signals[error.signal] ?? 0);
+    if (error.forwarded) {
+      process.kill(process.pid, error.signal);
+    } else {
+      console.error(error.message);
+    }
+    return;
+  }
+
+  console.error(error);
+  process.exitCode = 1;
+}

package/src/lib/install-ai-sdk-lib.ts

@@ -1,6 +1,18 @@
 import { installPackageIfNeeded } from "./utils/package-installer";
 
 export default async function installAiSdkLib(): Promise<void> {
+  await installPackageIfNeeded({
+    packageName: "@assistant-ui/ai-sdk",
+    importPatterns: ["@assistant-ui/ai-sdk"],
+    promptMessage:
+      "AI SDK imports were added but @assistant-ui/ai-sdk is not installed. Do you want to install it? (Y/n) ",
+    skipMessage:
+      "@assistant-ui/ai-sdk is already installed. Skipping installation.",
+    notFoundMessage: "No AI SDK imports found; skipping installation.",
+  });
+
+  // The previous name is a separate package, so an import of it needs that
+  // package installed; the neutral one would not make it resolvable.
   await installPackageIfNeeded({
     packageName: "@assistant-ui/react-ai-sdk",
     importPatterns: ["@assistant-ui/react-ai-sdk"],
@@ -8,6 +20,6 @@ export default async function installAiSdkLib(): Promise<void> {
       "AI SDK imports were added but @assistant-ui/react-ai-sdk is not installed. Do you want to install it? (Y/n) ",
     skipMessage:
       "@assistant-ui/react-ai-sdk is already installed. Skipping installation.",
-    notFoundMessage: "No AI SDK imports found; skipping installation.",
+    notFoundMessage: "No legacy AI SDK imports found; skipping installation.",
   });
 }

package/src/lib/install-edge-lib.ts

@@ -1,17 +1,16 @@
 import { installPackageIfNeeded } from "./utils/package-installer";
 
 export default async function installEdgeLib(): Promise<void> {
+  // Only the retired edge specifier is unambiguous here. `useChatRuntime` and
+  // the AI SDK package specifiers are shared by both AI SDK packages, so
+  // installAiSdkLib resolves those by the specifier the file actually imports.
   await installPackageIfNeeded({
-    packageName: "@assistant-ui/react-ai-sdk",
-    importPatterns: [
-      "@assistant-ui/react-edge",
-      "@assistant-ui/react-ai-sdk",
-      "useChatRuntime",
-    ],
+    packageName: "@assistant-ui/ai-sdk",
+    importPatterns: ["@assistant-ui/react-edge"],
     promptMessage:
-      "Edge Runtime imports were detected but @assistant-ui/react-ai-sdk is not installed. Do you want to install it? (Y/n) ",
+      "Edge Runtime imports were detected but @assistant-ui/ai-sdk is not installed. Do you want to install it? (Y/n) ",
     skipMessage:
-      "@assistant-ui/react-ai-sdk is already installed. Skipping installation.",
+      "@assistant-ui/ai-sdk is already installed. Skipping installation.",
     notFoundMessage: "No Edge Runtime imports found; skipping installation.",
   });
 }