@nadicodeai/ui 0.21.0 → 1.0.0

package/dist/internal/agent-visual/shader.js

@@ -0,0 +1,158 @@
+/*
+ * Modified from Paper Shaders 0.0.78 Metaballs (Apache-2.0).
+ * The metaball field, motion, colour blending, and edge calculation remain
+ * Paper's construction. `surfacePattern` clips the four approved NadicodeAI
+ * identity materials inside that generated form. Attribution ships in NOTICE.
+ */
+export const AGENT_VISUAL_SHADER = `#version 300 es
+precision mediump float;
+
+uniform float u_time;
+uniform sampler2D u_noiseTexture;
+uniform vec4 u_colorBack;
+uniform vec4 u_colors[8];
+uniform float u_colorsCount;
+uniform float u_size;
+uniform float u_count;
+uniform float u_material;
+uniform float u_detail;
+uniform vec2 u_resolution;
+
+in vec2 v_objectUV;
+out vec4 fragColor;
+
+#define TWO_PI 6.28318530718
+
+float randomR(vec2 p) {
+  vec2 uv = floor(p) / 100. + .5;
+  return texture(u_noiseTexture, fract(uv)).r;
+}
+
+float noise(float x) {
+  float i = floor(x);
+  float f = fract(x);
+  float u = f * f * (3.0 - 2.0 * f);
+  return mix(randomR(vec2(i, 0.0)), randomR(vec2(i + 1.0, 0.0)), u);
+}
+
+float getBallShape(vec2 uv, vec2 c, float p) {
+  float s = .5 * length(uv - c);
+  s = 1. - clamp(s, 0., 1.);
+  return pow(s, p);
+}
+
+float hash21(vec2 p) {
+  p = fract(p * vec2(123.34, 456.21));
+  p += dot(p, p + 45.32);
+  return fract(p.x * p.y);
+}
+
+float orderedPoints(vec2 surfaceUV, float depth) {
+  float density = clamp(min(u_resolution.x, u_resolution.y) / 12.0 * u_detail, 6.0, 34.0);
+  vec2 pointUV = fract(surfaceUV * density) - 0.5;
+  float radius = mix(0.14, 0.23, depth);
+  return 1.0 - smoothstep(radius * 0.7, radius, length(pointUV));
+}
+
+float triangularWire(vec2 surfaceUV, float depth) {
+  float density = clamp(min(u_resolution.x, u_resolution.y) / 16.0 * u_detail, 5.0, 26.0);
+  vec2 grid = surfaceUV * density;
+  float horizontal = abs(fract(grid.y) - 0.5);
+  float diagonalA = abs(fract(grid.x + grid.y * 0.5) - 0.5);
+  float diagonalB = abs(fract(grid.x - grid.y * 0.5) - 0.5);
+  float nearestLine = min(horizontal, min(diagonalA, diagonalB));
+  float width = mix(0.032, 0.072, depth);
+  return 1.0 - smoothstep(width * 0.55, width, nearestLine);
+}
+
+float particleLayer(vec2 surfaceUV, float density, float depth, float time, float layerSeed, float threshold) {
+  vec2 gridUV = surfaceUV * density + layerSeed;
+  vec2 cell = floor(gridUV);
+  vec2 local = fract(gridUV) - 0.5;
+  float seed = hash21(cell + layerSeed);
+  vec2 jitter = vec2(hash21(cell + layerSeed + 3.17), hash21(cell + layerSeed + 8.41)) - 0.5;
+  jitter *= 0.72;
+  jitter += 0.08 * vec2(sin(time * 0.42 + seed * 18.0 + layerSeed), cos(time * 0.31 + seed * 14.0 - layerSeed));
+  float radius = mix(0.055, 0.175, hash21(cell + layerSeed + 14.3)) * mix(0.78, 1.35, depth);
+  float particle = 1.0 - smoothstep(radius * 0.68, radius, length(local - jitter));
+  float brightness = mix(0.45, 1.0, hash21(cell + layerSeed + 24.7));
+  return particle * step(threshold, seed) * brightness;
+}
+
+float livingParticles(vec2 surfaceUV, float depth, float time) {
+  float density = clamp(min(u_resolution.x, u_resolution.y) / 6.5 * u_detail, 13.0, 68.0);
+  float dust = particleLayer(surfaceUV, density, depth, time, 0.0, 0.16);
+  float motes = particleLayer(surfaceUV, density * 0.46, depth, time * 0.72, 19.7, 0.62);
+  return max(dust * 0.78, motes);
+}
+
+float surfacePattern(vec2 surfaceUV, float depth, float material, float time) {
+  if (material < 0.5) return 1.0;
+  if (material < 1.5) return orderedPoints(surfaceUV, depth);
+  if (material < 2.5) return triangularWire(surfaceUV, depth);
+  return livingParticles(surfaceUV, depth, time);
+}
+
+void main() {
+  vec2 shape_uv = v_objectUV + .5;
+  const float firstFrameOffset = 2503.4;
+  float t = .2 * (u_time + firstFrameOffset);
+  vec3 totalColor = vec3(0.);
+  float totalShape = 0.;
+  float totalOpacity = 0.;
+  vec2 weightedCenter = vec2(0.);
+  vec2 weightedOrientation = vec2(0.);
+  float centerWeight = 0.;
+
+  for (int i = 0; i < 20; i++) {
+    if (i >= int(ceil(u_count))) break;
+    float idxFract = float(i) / 20.0;
+    float angle = TWO_PI * idxFract;
+    float speed = 1. - .2 * idxFract;
+    vec2 pos = vec2(.5) + 1e-4 + .9 * (vec2(noise(angle * 10. + float(i) + t * speed), noise(angle * 20. + float(i) - t * speed)) - .5);
+    int safeIndex = i % int(u_colorsCount + 0.5);
+    vec4 ballColor = u_colors[safeIndex];
+    ballColor.rgb *= ballColor.a;
+    float sizeFrac = 1.;
+    if (float(i) > floor(u_count - 1.)) sizeFrac *= fract(u_count);
+    float shape = getBallShape(shape_uv, pos, 45. - 30. * u_size * sizeFrac);
+    shape *= pow(u_size, .2);
+    shape = smoothstep(0., 1., shape);
+    totalColor += ballColor.rgb * shape;
+    totalShape += shape;
+    totalOpacity += ballColor.a * shape;
+    float centerContribution = shape * shape;
+    weightedCenter += pos * centerContribution;
+    weightedOrientation += vec2(cos(angle), sin(angle)) * centerContribution;
+    centerWeight += centerContribution;
+  }
+
+  totalColor /= max(totalShape, 1e-4);
+  totalOpacity /= max(totalShape, 1e-4);
+  float edgeWidth = fwidth(totalShape);
+  float finalShape = smoothstep(.4, .4 + edgeWidth, totalShape);
+  vec2 fieldCenter = weightedCenter / max(centerWeight, 1e-4);
+  vec2 fieldVector = shape_uv - fieldCenter;
+  float depth = smoothstep(0.4, 1.45, totalShape);
+  float fieldRotation = 0.18 * atan(weightedOrientation.y, weightedOrientation.x);
+  float rotationCos = cos(fieldRotation);
+  float rotationSin = sin(fieldRotation);
+  vec2 surfaceUV = fieldCenter + mat2(rotationCos, rotationSin, -rotationSin, rotationCos) * fieldVector * (1.0 + 0.1 * depth);
+  vec2 gradient = vec2(dFdx(totalShape), dFdy(totalShape));
+  vec2 gradientDirection = gradient / max(length(gradient), 1e-4);
+  surfaceUV += gradientDirection * 0.008 * sin(totalShape * 4.0);
+  float feature = surfacePattern(surfaceUV, depth, u_material, t);
+  vec3 normal = normalize(vec3(-gradient * 36.0, 1.0));
+  vec3 lightDirection = normalize(vec3(-0.45, 0.65, 0.8));
+  float surfaceLight = 0.62 + 0.38 * max(dot(normal, lightDirection), 0.0);
+  float baseSurface = mix(0.012, 0.06, depth);
+  float surface = u_material < 0.5 ? 1.0 : mix(baseSurface, surfaceLight, feature);
+  vec3 color = totalColor * finalShape * surface;
+  float opacity = totalOpacity * finalShape * surface;
+  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;
+  color = color + bgColor * (1. - opacity);
+  opacity = opacity + u_colorBack.a * (1. - opacity);
+  color += 1. / 256. * (fract(sin(dot(.014 * gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453123) - .5);
+  fragColor = vec4(color, opacity);
+}
+`;

package/dist/internal/assistant-ui/attachment.d.ts

@@ -0,0 +1,5 @@
+import { type FC } from "react";
+export declare const UserMessageAttachments: FC;
+export declare const ComposerAttachments: FC;
+export declare const ComposerAddAttachment: FC;
+//# sourceMappingURL=attachment.d.ts.map

package/dist/internal/assistant-ui/attachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment.d.ts","sourceRoot":"","sources":["../../../src/internal/assistant-ui/attachment.tsx"],"names":[],"mappings":"AAEA,OAAO,EAA+C,KAAK,EAAE,EAAkB,MAAM,OAAO,CAAC;AAkN7F,eAAO,MAAM,sBAAsB,EAAE,EAMpC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,EAMjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,EAiBnC,CAAC"}

package/dist/internal/assistant-ui/attachment.js

@@ -0,0 +1,93 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState, isValidElement } from "react";
+import { XIcon, PlusIcon, FileText, Loader2Icon, AlertCircleIcon } from "lucide-react";
+import { AttachmentPrimitive, ComposerPrimitive, MessagePrimitive, useAuiState, useAui, } from "@assistant-ui/react";
+import { useShallow } from "zustand/shallow";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../../components/tooltip.js";
+import { Dialog, DialogTitle, DialogContent, DialogTrigger } from "../../components/dialog.js";
+import { Avatar, AvatarImage, AvatarFallback } from "../../components/avatar.js";
+import { TooltipIconButton } from "./tooltip-icon-button.js";
+import { cn } from "../../lib/utils.js";
+const useFileSrc = (file) => {
+    const [src, setSrc] = useState(undefined);
+    useEffect(() => {
+        if (!file) {
+            setSrc(undefined);
+            return;
+        }
+        const objectUrl = URL.createObjectURL(file);
+        setSrc(objectUrl);
+        return () => {
+            URL.revokeObjectURL(objectUrl);
+        };
+    }, [file]);
+    return src;
+};
+const useAttachmentSrc = () => {
+    const { file, src } = useAuiState(useShallow((s) => {
+        if (s.attachment.type !== "image")
+            return {};
+        if (s.attachment.file)
+            return { file: s.attachment.file };
+        const src = s.attachment.content?.filter((c) => c.type === "image")[0]?.image;
+        if (!src)
+            return {};
+        return { src };
+    }));
+    return useFileSrc(file) ?? src;
+};
+const AttachmentPreview = ({ src }) => {
+    return (_jsx("img", { src: src, alt: "Attachment preview", className: "aui-attachment-preview-image block h-auto max-h-[80vh] w-auto max-w-full rounded-sm object-contain" }));
+};
+const AttachmentPreviewDialog = ({ children }) => {
+    const src = useAttachmentSrc();
+    if (!src)
+        return children;
+    return (_jsxs(Dialog, { children: [_jsx(DialogTrigger, { nativeButton: false, className: "aui-attachment-preview-trigger", render: isValidElement(children) ? children : _jsx("button", { type: "button" }) }), _jsxs(DialogContent, { className: "aui-attachment-preview-dialog-content [&>button]:bg-foreground/60 [&>button]:hover:bg-foreground/80 [&_svg]:text-background p-2 sm:max-w-3xl [&>button]:rounded-full [&>button]:p-1 [&>button]:opacity-100 [&>button]:ring-0!", children: [_jsx(DialogTitle, { className: "aui-sr-only sr-only", children: "Image Attachment Preview" }), _jsx("div", { className: "aui-attachment-preview bg-background relative mx-auto flex max-h-[80dvh] w-full items-center justify-center overflow-hidden rounded-sm", children: _jsx(AttachmentPreview, { src: src }) })] })] }));
+};
+const AttachmentThumb = () => {
+    const src = useAttachmentSrc();
+    return (_jsxs(Avatar, { className: "aui-attachment-tile-avatar h-full w-full rounded-none after:hidden", children: [_jsx(AvatarImage, { src: src, alt: "Attachment preview", className: "aui-attachment-tile-image object-cover" }), _jsx(AvatarFallback, { children: _jsx(FileText, { className: "aui-attachment-tile-fallback-icon text-muted-foreground/80 size-6 stroke-[1.5]" }) })] }));
+};
+const AttachmentUI = () => {
+    const aui = useAui();
+    const isComposer = aui.attachment.source !== "message";
+    const isImage = useAuiState((s) => s.attachment.type === "image");
+    const typeLabel = useAuiState((s) => {
+        const type = s.attachment.type;
+        switch (type) {
+            case "image":
+                return "Image";
+            case "document":
+                return "Document";
+            case "file":
+                return "File";
+            default:
+                return type;
+        }
+    });
+    const uploadState = useAuiState((s) => s.attachment.status.type === "running"
+        ? "uploading"
+        : s.attachment.status.type === "incomplete" && s.attachment.status.reason === "error"
+            ? "error"
+            : undefined);
+    const isUploading = uploadState === "uploading";
+    const isError = uploadState === "error";
+    const errorMessage = useAuiState((s) => s.attachment.status.type === "incomplete" && s.attachment.status.reason === "error"
+        ? (s.attachment.status.message ?? "Upload failed")
+        : undefined);
+    return (_jsx(TooltipProvider, { children: _jsxs(Tooltip, { children: [_jsxs(AttachmentPrimitive.Root, { className: cn("aui-attachment-root relative", isComposer && "nc-transition-opacity", isImage && !isComposer && "aui-attachment-root-message only:*:first:size-24"), children: [_jsx(AttachmentPreviewDialog, { children: _jsxs(TooltipTrigger, { render: _jsx("div", { className: cn("aui-attachment-tile nc-transition-transform relative size-14 cursor-pointer overflow-hidden rounded-[calc(var(--composer-radius)-var(--composer-padding))] bg-muted outline-none after:pointer-events-none after:absolute after:inset-0 after:rounded-[inherit] after:ring-1 after:ring-border after:ring-inset focus-visible:ring-[length:var(--ring-width-focus)] focus-visible:ring-ring/50 hover:after:bg-foreground/10", isError && "after:ring-destructive/60"), role: "button", tabIndex: 0, "aria-label": `${typeLabel} attachment${isError ? ", upload failed" : isUploading ? ", uploading" : ""}` }), children: [_jsx(AttachmentThumb, {}), isUploading && (_jsx("div", { "aria-hidden": "true", className: "aui-attachment-tile-uploading nc-transition-opacity absolute inset-0 flex items-center justify-center bg-background/60 backdrop-blur-[2px]", children: _jsx(Loader2Icon, { className: "size-4 text-muted-foreground motion-safe:animate-spin motion-reduce:animate-pulse" }) })), isError && (_jsx("div", { "aria-hidden": "true", className: "aui-attachment-tile-error nc-transition-opacity absolute inset-0 flex items-center justify-center bg-background/70 backdrop-blur-[2px]", children: _jsx(AlertCircleIcon, { className: "text-destructive size-4" }) }))] }) }), isComposer && _jsx(AttachmentRemove, {})] }), _jsxs(TooltipContent, { side: "top", children: [_jsx(AttachmentPrimitive.Name, {}), errorMessage && _jsx("p", { className: "aui-attachment-error-message", children: errorMessage })] })] }) }));
+};
+const AttachmentRemove = () => {
+    return (_jsx(AttachmentPrimitive.Remove, { render: _jsx(TooltipIconButton, { tooltip: "Remove file", className: "aui-attachment-tile-remove absolute end-1 top-1 size-5 rounded-full bg-foreground/70! text-background! backdrop-blur-sm after:absolute after:-inset-1.5 hover:bg-foreground/85!", side: "top" }), children: _jsx(XIcon, { className: "aui-attachment-remove-icon size-3 stroke-[2.5]" }) }));
+};
+export const UserMessageAttachments = () => {
+    return (_jsx("div", { className: "aui-user-message-attachments-end col-span-full col-start-1 row-start-1 flex w-full flex-row justify-end gap-2", children: _jsx(MessagePrimitive.Attachments, { children: () => _jsx(AttachmentUI, {}) }) }));
+};
+export const ComposerAttachments = () => {
+    return (_jsx("div", { className: "aui-composer-attachments flex w-full flex-row items-center gap-2 overflow-x-auto empty:hidden", children: _jsx(ComposerPrimitive.Attachments, { children: () => _jsx(AttachmentUI, {}) }) }));
+};
+export const ComposerAddAttachment = () => {
+    return (_jsx(ComposerPrimitive.AddAttachment, { render: _jsx(TooltipIconButton, { tooltip: "Add Attachment", side: "bottom", variant: "ghost", size: "icon", className: "aui-composer-add-attachment size-7 rounded-full p-1 text-xs font-semibold hover:bg-muted", "aria-label": "Add Attachment" }), children: _jsx(PlusIcon, { className: "aui-attachment-add-icon size-4.5 stroke-[1.5px]" }) }));
+};

package/dist/internal/assistant-ui/follow-up-suggestions.d.ts

@@ -0,0 +1,3 @@
+import { type FC } from "react";
+export declare const ThreadFollowupSuggestions: FC;
+//# sourceMappingURL=follow-up-suggestions.d.ts.map

package/dist/internal/assistant-ui/follow-up-suggestions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"follow-up-suggestions.d.ts","sourceRoot":"","sources":["../../../src/internal/assistant-ui/follow-up-suggestions.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,OAAO,CAAC;AAwBhC,eAAO,MAAM,yBAAyB,EAAE,EAMvC,CAAC"}

package/dist/internal/assistant-ui/follow-up-suggestions.js

@@ -0,0 +1,8 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AuiIf, ThreadPrimitive, useAuiState } from "@assistant-ui/react";
+const FollowupSuggestionsRow = () => {
+    const suggestions = useAuiState((s) => s.thread.suggestions);
+    return (_jsx("div", { className: "aui-thread-followup-suggestions -my-1 w-full overflow-x-auto py-1 [-ms-overflow-style:none] [scrollbar-width:none] [&::-webkit-scrollbar]:hidden", children: _jsx("div", { className: "mx-auto flex min-h-8 w-max items-center gap-2 px-0.5", children: suggestions.map((suggestion, index) => (_jsx(ThreadPrimitive.Suggestion, { className: "aui-thread-followup-suggestion nc-transition-paint rounded-full border bg-background px-3 py-1 text-sm whitespace-nowrap hover:bg-muted/80", prompt: suggestion.prompt, method: "replace", autoSend: true, children: suggestion.prompt }, index))) }) }));
+};
+export const ThreadFollowupSuggestions = () => (_jsx(AuiIf, { condition: (s) => !s.thread.isEmpty && !s.thread.isRunning && s.thread.suggestions.length > 0, children: _jsx(FollowupSuggestionsRow, {}) }));

package/dist/internal/assistant-ui/markdown-text.d.ts

@@ -0,0 +1,2 @@
+export declare const MarkdownText: import("react").MemoExoticComponent<() => import("react").JSX.Element>;
+//# sourceMappingURL=markdown-text.d.ts.map

package/dist/internal/assistant-ui/markdown-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-text.d.ts","sourceRoot":"","sources":["../../../src/internal/assistant-ui/markdown-text.tsx"],"names":[],"mappings":"AA2BA,eAAO,MAAM,YAAY,wEAAyB,CAAC"}

package/dist/internal/assistant-ui/markdown-text.js

@@ -0,0 +1,54 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { MarkdownTextPrimitive, unstable_memoizeMarkdownComponents as memoizeMarkdownComponents, useIsMarkdownCodeBlock, } from "@assistant-ui/react-markdown";
+import remarkGfm from "remark-gfm";
+import { memo } from "react";
+import { CheckIcon, CopyIcon } from "lucide-react";
+import { TooltipIconButton } from "./tooltip-icon-button.js";
+import { useCopyToClipboard } from "../../lib/use-copy-to-clipboard.js";
+import { cn } from "../../lib/utils.js";
+const MarkdownTextImpl = () => {
+    return (_jsx(MarkdownTextPrimitive, { remarkPlugins: [remarkGfm], className: "aui-md", components: defaultComponents, defer: true }));
+};
+export const MarkdownText = memo(MarkdownTextImpl);
+const CodeHeader = ({ language, code }) => {
+    const { isCopied, copyToClipboard } = useCopyToClipboard({
+        text: code,
+        timeout: 3000,
+        skipWhileCopied: true,
+    });
+    const onCopy = () => {
+        if (!code || isCopied)
+            return;
+        void copyToClipboard();
+    };
+    return (_jsxs("div", { className: "aui-code-header-root border-border/50 bg-muted/50 mt-3 flex items-center justify-between rounded-t-xl border border-b-0 px-3.5 py-1.5 text-xs", children: [_jsx("span", { className: "aui-code-header-language text-muted-foreground font-medium lowercase", children: language }), _jsxs(TooltipIconButton, { tooltip: "Copy", onClick: onCopy, children: [!isCopied && _jsx(CopyIcon, {}), isCopied && _jsx(CheckIcon, {})] })] }));
+};
+const defaultComponents = memoizeMarkdownComponents({
+    h1: ({ className, ...props }) => (_jsx("h1", { className: cn("aui-md-h1 mt-5 mb-2 scroll-m-20 text-xl font-semibold first:mt-0 last:mb-0", className), ...props })),
+    h2: ({ className, ...props }) => (_jsx("h2", { className: cn("aui-md-h2 mt-5 mb-2 scroll-m-20 text-lg font-semibold first:mt-0 last:mb-0", className), ...props })),
+    h3: ({ className, ...props }) => (_jsx("h3", { className: cn("aui-md-h3 mt-4 mb-1.5 scroll-m-20 text-base font-semibold first:mt-0 last:mb-0", className), ...props })),
+    h4: ({ className, ...props }) => (_jsx("h4", { className: cn("aui-md-h4 mt-3.5 mb-1 scroll-m-20 text-base font-medium first:mt-0 last:mb-0", className), ...props })),
+    h5: ({ className, ...props }) => (_jsx("h5", { className: cn("aui-md-h5 mt-3 mb-1 text-sm font-semibold first:mt-0 last:mb-0", className), ...props })),
+    h6: ({ className, ...props }) => (_jsx("h6", { className: cn("aui-md-h6 mt-3 mb-1 text-sm font-medium first:mt-0 last:mb-0", className), ...props })),
+    p: ({ className, ...props }) => (_jsx("p", { className: cn("aui-md-p my-3 leading-relaxed first:mt-0 last:mb-0", className), ...props })),
+    a: ({ className, ...props }) => (_jsx("a", { className: cn("aui-md-a text-primary hover:text-primary/80 underline underline-offset-2", className), ...props })),
+    blockquote: ({ className, ...props }) => (_jsx("blockquote", { className: cn("aui-md-blockquote border-muted-foreground/30 text-muted-foreground my-3 border-s-2 ps-4", className), ...props })),
+    ul: ({ className, ...props }) => (_jsx("ul", { className: cn("aui-md-ul marker:text-muted-foreground my-3 ms-5 list-disc [&>li]:mt-1", className), ...props })),
+    ol: ({ className, ...props }) => (_jsx("ol", { className: cn("aui-md-ol marker:text-muted-foreground my-3 ms-5 list-decimal [&>li]:mt-1", className), ...props })),
+    hr: ({ className, ...props }) => (_jsx("hr", { className: cn("aui-md-hr border-muted-foreground/20 my-3", className), ...props })),
+    table: ({ className, ...props }) => (_jsx("table", { className: cn("aui-md-table my-3 w-full border-separate border-spacing-0 overflow-y-auto", className), ...props })),
+    th: ({ className, ...props }) => (_jsx("th", { className: cn("aui-md-th bg-muted px-3 py-1.5 text-start font-medium first:rounded-ss-lg last:rounded-se-lg [[align=center]]:text-center [[align=right]]:text-right", className), ...props })),
+    td: ({ className, ...props }) => (_jsx("td", { className: cn("aui-md-td border-muted-foreground/20 border-s border-b px-3 py-1.5 text-start last:border-e [[align=center]]:text-center [[align=right]]:text-right", className), ...props })),
+    tr: ({ className, ...props }) => (_jsx("tr", { className: cn("aui-md-tr m-0 border-b p-0 first:border-t [&:last-child>td:first-child]:rounded-es-lg [&:last-child>td:last-child]:rounded-ee-lg", className), ...props })),
+    li: ({ className, ...props }) => (_jsx("li", { className: cn("aui-md-li leading-relaxed", className), ...props })),
+    strong: ({ className, ...props }) => (_jsx("strong", { className: cn("aui-md-strong font-semibold", className), ...props })),
+    sup: ({ className, ...props }) => (_jsx("sup", { className: cn("aui-md-sup [&>a]:text-xs [&>a]:no-underline", className), ...props })),
+    pre: ({ className, ...props }) => (_jsx("pre", { className: cn("aui-md-pre border-border/50 bg-muted/30 overflow-x-auto rounded-t-none rounded-b-xl border border-t-0 p-3.5 text-[13px] leading-relaxed", className), ...props })),
+    code: function Code({ className, ...props }) {
+        const isCodeBlock = useIsMarkdownCodeBlock();
+        return (_jsx("code", { className: cn(!isCodeBlock &&
+                "aui-md-inline-code bg-muted rounded-md px-1.5 py-0.5 font-mono text-[0.85em]", className), ...props }));
+    },
+    CodeHeader,
+});

package/dist/internal/assistant-ui/reasoning.d.ts

@@ -0,0 +1,31 @@
+import { type VariantProps } from "class-variance-authority";
+import { type ReasoningMessagePartComponent } from "@assistant-ui/react";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../../components/collapsible";
+declare const reasoningVariants: (props?: ({
+    variant?: "outline" | "ghost" | "muted" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ReasoningRootProps = Omit<React.ComponentProps<typeof Collapsible>, "open" | "onOpenChange"> & VariantProps<typeof reasoningVariants> & {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    defaultOpen?: boolean;
+    /**
+     * Whether the reasoning is currently streaming. While `true` the
+     * disclosure is held open with a bottom-pinned live preview; when
+     * streaming ends it returns to `defaultOpen`, and the first manual
+     * toggle takes over the open/close state permanently. The live preview
+     * keeps following the newest tokens while the disclosure is open during
+     * streaming, even after a manual toggle, and pauses while the reader is
+     * scrolled up.
+     */
+    streaming?: boolean;
+};
+declare function ReasoningRoot({ className, variant, open: controlledOpen, onOpenChange: controlledOnOpenChange, defaultOpen, streaming, children, ...props }: ReasoningRootProps): import("react").JSX.Element;
+declare function ReasoningTrigger({ active, duration, className, ...props }: React.ComponentProps<typeof CollapsibleTrigger> & {
+    active?: boolean;
+    duration?: number;
+}): import("react").JSX.Element;
+declare function ReasoningContent({ className, children, ...props }: React.ComponentProps<typeof CollapsibleContent>): import("react").JSX.Element;
+declare function ReasoningText({ className, children, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare const Reasoning: ReasoningMessagePartComponent;
+export { Reasoning, ReasoningRoot, ReasoningTrigger, ReasoningContent, ReasoningText };
+//# sourceMappingURL=reasoning.d.ts.map

package/dist/internal/assistant-ui/reasoning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning.d.ts","sourceRoot":"","sources":["../../../src/internal/assistant-ui/reasoning.tsx"],"names":[],"mappings":"AAYA,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EAAiB,KAAK,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AAExF,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAO/F,QAAA,MAAM,iBAAiB;;8EAWrB,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACnC,KAAK,CAAC,cAAc,CAAC,OAAO,WAAW,CAAC,EACxC,MAAM,GAAG,cAAc,CACxB,GACC,YAAY,CAAC,OAAO,iBAAiB,CAAC,GAAG;IACvC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEJ,iBAAS,aAAa,CAAC,EACrB,SAAS,EACT,OAAO,EACP,IAAI,EAAE,cAAc,EACpB,YAAY,EAAE,sBAAsB,EACpC,WAAmB,EACnB,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,kBAAkB,+BAsDpB;AAkCD,iBAAS,gBAAgB,CAAC,EACxB,MAAM,EACN,QAAQ,EACR,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,kBAAkB,CAAC,GAAG;IACnD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,+BA2CA;AAED,iBAAS,gBAAgB,CAAC,EACxB,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,kBAAkB,CAAC,+BAmBjD;AAED,iBAAS,aAAa,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,+BA6DpF;AAID,QAAA,MAAM,SAAS,EAAqC,6BAA6B,CAAC;AAIlF,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,aAAa,EAAE,CAAC"}

package/dist/internal/assistant-ui/reasoning.js

@@ -0,0 +1,118 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, memo, useCallback, useContext, useEffect, useLayoutEffect, useRef, useState, } from "react";
+import { cva } from "class-variance-authority";
+import { BrainIcon, ChevronDownIcon } from "lucide-react";
+import { useScrollLock } from "@assistant-ui/react";
+import { MarkdownText } from "./markdown-text.js";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../../components/collapsible.js";
+import { cn } from "../../lib/utils.js";
+const ANIMATION_DURATION = 200;
+const ReasoningPreviewContext = createContext(false);
+const reasoningVariants = cva("aui-reasoning-root mb-4 w-full", {
+    variants: {
+        variant: {
+            outline: "rounded-lg border px-3 py-2",
+            ghost: "",
+            muted: "bg-muted/50 rounded-lg px-3 py-2",
+        },
+    },
+    defaultVariants: {
+        variant: "outline",
+    },
+});
+function ReasoningRoot({ className, variant, open: controlledOpen, onOpenChange: controlledOnOpenChange, defaultOpen = false, streaming, children, ...props }) {
+    const collapsibleRef = useRef(null);
+    const initialOpenRef = useRef(defaultOpen);
+    const [userOpen, setUserOpen] = useState(null);
+    const lockScroll = useScrollLock(collapsibleRef, ANIMATION_DURATION);
+    const isControlled = controlledOpen !== undefined;
+    const isOpen = isControlled
+        ? controlledOpen
+        : (userOpen ?? (streaming || initialOpenRef.current));
+    const isPreview = streaming === true && isOpen;
+    const prevStreamingRef = useRef(streaming);
+    useLayoutEffect(() => {
+        if (prevStreamingRef.current === streaming)
+            return;
+        prevStreamingRef.current = streaming;
+        // A streaming transition only animates the panel when the resting state
+        // is collapsed; with `defaultOpen` the disclosure stays open across it.
+        if (!isControlled && userOpen === null && !initialOpenRef.current) {
+            lockScroll();
+        }
+    }, [streaming, isControlled, userOpen, lockScroll]);
+    const handleOpenChange = useCallback((open) => {
+        lockScroll();
+        if (!isControlled) {
+            setUserOpen(open);
+        }
+        controlledOnOpenChange?.(open);
+    }, [lockScroll, isControlled, controlledOnOpenChange]);
+    return (_jsx(Collapsible, { ref: collapsibleRef, "data-slot": "reasoning-root", "data-variant": variant, open: isOpen, onOpenChange: handleOpenChange, className: cn("group/reasoning-root", reasoningVariants({ variant, className })), style: {
+            "--animation-duration": `${ANIMATION_DURATION}ms`,
+        }, ...props, children: _jsx(ReasoningPreviewContext.Provider, { value: isPreview, children: children }) }));
+}
+function ReasoningFade({ side = "bottom", className, ...props }) {
+    if (side === "top") {
+        return (_jsx("div", { "data-slot": "reasoning-fade", className: cn("aui-reasoning-fade pointer-events-none absolute inset-x-0 top-0 z-10 h-8", "bg-background/90 group-data-[variant=muted]/reasoning-root:bg-muted/90", className), ...props }));
+    }
+    return (_jsx("div", { "data-slot": "reasoning-fade", className: cn("aui-reasoning-fade pointer-events-none absolute inset-x-0 bottom-0 z-10 h-8", "bg-background/90 group-data-[variant=muted]/reasoning-root:bg-muted/90", className), ...props }));
+}
+function ReasoningTrigger({ active, duration, className, ...props }) {
+    const durationText = duration ? ` (${duration}s)` : "";
+    return (_jsxs(CollapsibleTrigger, { "data-slot": "reasoning-trigger", className: cn("aui-reasoning-trigger nc-transition-paint group/trigger flex max-w-[75%] origin-left items-center gap-2 py-1.5 text-sm text-muted-foreground hover:text-foreground", className), ...props, children: [_jsx(BrainIcon, { "data-slot": "reasoning-trigger-icon", className: "aui-reasoning-trigger-icon size-4 shrink-0" }), _jsxs("span", { "data-slot": "reasoning-trigger-label", className: "aui-reasoning-trigger-label-wrapper relative inline-block leading-none tabular-nums", children: [_jsxs("span", { children: ["Reasoning", durationText] }), active ? (_jsxs("span", { "aria-hidden": true, "data-slot": "reasoning-trigger-shimmer", className: "aui-reasoning-trigger-shimmer shimmer pointer-events-none absolute inset-0 motion-reduce:animate-none", children: ["Reasoning", durationText] })) : null] }), _jsx(ChevronDownIcon, { "data-slot": "reasoning-trigger-chevron", className: cn("aui-reasoning-trigger-chevron mt-0.5 size-4 shrink-0", "transition-transform duration-(--animation-duration) ease-[var(--nc-ease-out-strong)] motion-reduce:transition-none", "-rotate-90", "group-data-open/trigger:rotate-0", "group-data-panel-open/trigger:rotate-0") })] }));
+}
+function ReasoningContent({ className, children, ...props }) {
+    const isPreview = useContext(ReasoningPreviewContext);
+    return (_jsxs(CollapsibleContent, { "data-slot": "reasoning-content", className: cn("aui-reasoning-content text-muted-foreground relative overflow-hidden text-sm outline-none", "group/collapsible-content", "data-closed:pointer-events-none", className), ...props, children: [_jsx(ReasoningFade, { side: "top" }), children, isPreview ? _jsx(ReasoningFade, {}) : null] }));
+}
+function ReasoningText({ className, children, ...props }) {
+    const isPreview = useContext(ReasoningPreviewContext);
+    const scrollRef = useRef(null);
+    const contentRef = useRef(null);
+    useEffect(() => {
+        if (!isPreview)
+            return;
+        const scrollEl = scrollRef.current;
+        const contentEl = contentRef.current;
+        if (!scrollEl || !contentEl)
+            return;
+        let pinned = true;
+        let lastScrollTop = scrollEl.scrollTop;
+        let lastScrollHeight = scrollEl.scrollHeight;
+        const isAtBottom = () => Math.abs(scrollEl.scrollHeight - scrollEl.scrollTop - scrollEl.clientHeight) <= 1 ||
+            scrollEl.scrollHeight <= scrollEl.clientHeight;
+        const pin = () => {
+            if (!pinned)
+                return;
+            scrollEl.scrollTop = scrollEl.scrollHeight;
+        };
+        // A pin's own scroll event can arrive after new content grew the scroll
+        // height and read as "not at bottom"; only an upward move at unchanged
+        // scroll height is user intent.
+        const onScroll = () => {
+            if (isAtBottom()) {
+                pinned = true;
+            }
+            else if (scrollEl.scrollTop < lastScrollTop && scrollEl.scrollHeight === lastScrollHeight) {
+                pinned = false;
+            }
+            lastScrollTop = scrollEl.scrollTop;
+            lastScrollHeight = scrollEl.scrollHeight;
+        };
+        pin();
+        scrollEl.addEventListener("scroll", onScroll);
+        const observer = new ResizeObserver(pin);
+        observer.observe(contentEl);
+        return () => {
+            scrollEl.removeEventListener("scroll", onScroll);
+            observer.disconnect();
+        };
+    }, [isPreview]);
+    return (_jsx("div", { ref: scrollRef, "data-slot": "reasoning-text", className: cn("aui-reasoning-text relative z-0 max-h-64 overflow-y-auto ps-6 pt-2 pb-2 leading-relaxed text-pretty", "nc-transition-opacity", className), ...props, children: _jsx("div", { ref: contentRef, className: "aui-reasoning-text-content space-y-4", children: children }) }));
+}
+const ReasoningImpl = () => _jsx(MarkdownText, {});
+const Reasoning = memo(ReasoningImpl);
+Reasoning.displayName = "Reasoning";
+export { Reasoning, ReasoningRoot, ReasoningTrigger, ReasoningContent, ReasoningText };

package/dist/internal/assistant-ui/thread.d.ts

@@ -0,0 +1,26 @@
+import { MessagePrimitive, type ToolCallMessagePartComponent } from "@assistant-ui/react";
+import { type ComponentType, type FC, type PropsWithChildren } from "react";
+export type ThreadGroupPart = MessagePrimitive.GroupedParts.GroupPart;
+/**
+ * Optional component overrides for the thread. `AssistantMessage` and
+ * `Welcome` replace whole sections; the remaining slots override how the
+ * assistant message renders tool calls and part groups. Tool UIs registered
+ * by name (toolkit `render`, `useAssistantDataUI`) take precedence over
+ * `ToolFallback`.
+ */
+export type ThreadComponents = {
+    AssistantMessage?: ComponentType | undefined;
+    Welcome?: ComponentType | undefined;
+    ToolFallback?: ToolCallMessagePartComponent | undefined;
+    ToolGroup?: ComponentType<PropsWithChildren<{
+        group: ThreadGroupPart;
+    }>> | undefined;
+    ReasoningGroup?: ComponentType<PropsWithChildren<{
+        group: ThreadGroupPart;
+    }>> | undefined;
+};
+export type ThreadProps = {
+    components?: ThreadComponents | undefined;
+};
+export declare const Thread: FC<ThreadProps>;
+//# sourceMappingURL=thread.d.ts.map

package/dist/internal/assistant-ui/thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../../src/internal/assistant-ui/thread.tsx"],"names":[],"mappings":"AAyBA,OAAO,EASL,gBAAgB,EAGhB,KAAK,4BAA4B,EAElC,MAAM,qBAAqB,CAAC;AAe7B,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,EAAE,EACP,KAAK,iBAAiB,EACvB,MAAM,OAAO,CAAC;AAEf,MAAM,MAAM,eAAe,GAAG,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,gBAAgB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7C,OAAO,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,YAAY,CAAC,EAAE,4BAA4B,GAAG,SAAS,CAAC;IACxD,SAAS,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC;QAAE,KAAK,EAAE,eAAe,CAAA;KAAE,CAAC,CAAC,GAAG,SAAS,CAAC;IACrF,cAAc,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC;QAAE,KAAK,EAAE,eAAe,CAAA;KAAE,CAAC,CAAC,GAAG,SAAS,CAAC;CAC3F,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAWF,eAAO,MAAM,MAAM,EAAE,EAAE,CAAC,WAAW,CAQlC,CAAC"}