@actioneer/ads 0.1.0

package/components/ai-elements/reasoning.js

@@ -0,0 +1,131 @@
+"use client";
+import { jsx as n, jsxs as b, Fragment as y } from "react/jsx-runtime";
+import { Collapsible as D, CollapsibleTrigger as A, CollapsibleContent as E } from "../collapsible.js";
+import { Brain as O, ChevronDown as _ } from "../../lib/icons.js";
+import { cn as p } from "../../lib/cn.js";
+import { createContext as k, memo as g, useState as f, useEffect as N, useRef as M, useCallback as P, useContext as S } from "react";
+function T({
+  prop: t,
+  defaultProp: e,
+  onChange: o
+}) {
+  const [s, c] = f(e), a = t !== void 0, u = a ? t : s, i = M(o);
+  i.current = o;
+  const l = P(
+    (r) => {
+      var d;
+      a || c(r), (d = i.current) == null || d.call(i, r);
+    },
+    [a]
+  );
+  return [u, l];
+}
+const w = k(null), j = () => {
+  const t = S(w);
+  if (!t)
+    throw new Error("Reasoning components must be used within Reasoning");
+  return t;
+}, z = 1e3, I = 1e3, L = g(
+  ({
+    className: t,
+    isStreaming: e = !1,
+    open: o,
+    defaultOpen: s = !0,
+    onOpenChange: c,
+    duration: a,
+    children: u,
+    ...i
+  }) => {
+    const [l, r] = T({
+      prop: o,
+      defaultProp: s,
+      onChange: c
+    }), [d, h] = T({
+      prop: a,
+      defaultProp: void 0
+    }), [C, R] = f(!1), [m, x] = f(null);
+    return N(() => {
+      e ? m === null && x(Date.now()) : m !== null && (h(Math.ceil((Date.now() - m) / I)), x(null));
+    }, [e, m, h]), N(() => {
+      if (s && !e && l && !C) {
+        const v = setTimeout(() => {
+          r(!1), R(!0);
+        }, z);
+        return () => clearTimeout(v);
+      }
+    }, [e, l, s, r, C]), /* @__PURE__ */ n(
+      w.Provider,
+      {
+        value: { isStreaming: e, isOpen: l, setIsOpen: r, duration: d },
+        children: /* @__PURE__ */ n(
+          D,
+          {
+            className: p("mb-4", t),
+            onOpenChange: r,
+            open: l,
+            ...i,
+            children: u
+          }
+        )
+      }
+    );
+  }
+), U = (t, e) => t || e === 0 ? /* @__PURE__ */ n("span", { className: "shimmer text-foreground/40", children: "Thinking…" }) : e === void 0 ? /* @__PURE__ */ n("span", { children: "Thought for a few seconds" }) : /* @__PURE__ */ b("span", { children: [
+  "Thought for ",
+  /* @__PURE__ */ n("span", { className: "tabular-nums", children: e }),
+  " seconds"
+] }), B = g(
+  ({
+    className: t,
+    children: e,
+    getThinkingMessage: o = U,
+    ...s
+  }) => {
+    const { isStreaming: c, isOpen: a, duration: u } = j();
+    return /* @__PURE__ */ n(
+      A,
+      {
+        className: p(
+          "flex w-full items-center gap-2 text-base text-secondary transition-colors hover:text-foreground",
+          t
+        ),
+        ...s,
+        children: e ?? /* @__PURE__ */ b(y, { children: [
+          /* @__PURE__ */ n(O, { className: "size-4" }),
+          o(c, u),
+          /* @__PURE__ */ n(
+            _,
+            {
+              className: p(
+                "size-4 transition-transform duration-(--duration-fast) ease-out motion-reduce:transition-none",
+                a ? "rotate-180" : "rotate-0"
+              )
+            }
+          )
+        ] })
+      }
+    );
+  }
+), F = g(
+  ({ className: t, children: e, ...o }) => /* @__PURE__ */ n(
+    E,
+    {
+      className: p(
+        "mt-4 text-base text-secondary outline-none",
+        "data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 data-[state=closed]:animate-out data-[state=open]:animate-in motion-reduce:animate-none",
+        t
+      ),
+      ...o,
+      children: /* @__PURE__ */ n("div", { className: "leading-relaxed whitespace-pre-wrap", children: e })
+    }
+  )
+);
+L.displayName = "Reasoning";
+B.displayName = "ReasoningTrigger";
+F.displayName = "ReasoningContent";
+export {
+  L as Reasoning,
+  F as ReasoningContent,
+  B as ReasoningTrigger,
+  j as useReasoning
+};

package/components/ai-elements/shimmer.d.ts

@@ -0,0 +1,25 @@
+import { ElementType, JSX } from 'react';
+/**
+ * Shimmer — an animated sweep across a line of text, for loading / "thinking"
+ * states. Ported from Vercel AI Elements (`elements.ai-sdk.dev`) onto ADS
+ * tokens.
+ *
+ * The effect is a `bg-clip-text` gradient: the resting text paints in
+ * `--text-secondary`, and a moving band of `--background` (the page white)
+ * sweeps across, momentarily lifting the ink toward the surface color. Upstream
+ * referenced the shadcn `--color-*` aliases, which ADS keeps in `@theme inline`
+ * (compiled away, not emitted at runtime) — so this port reads the raw `:root`
+ * tokens instead.
+ *
+ * It is a continuous ambient loop (like `Spinner` / `--duration-pulse`), so the
+ * `linear` timing is intentional and exempt from the <300ms UI-motion rule.
+ * Reduced-motion viewers get the static muted text with no sweep.
+ */
+export type TextShimmerProps = {
+    children: string;
+    as?: ElementType;
+    className?: string;
+    duration?: number;
+    spread?: number;
+};
+export declare const Shimmer: import('react').MemoExoticComponent<({ children, as: Component, className, duration, spread, }: TextShimmerProps) => JSX.Element>;

package/components/ai-elements/shimmer.js

@@ -0,0 +1,44 @@
+"use client";
+import { jsx as m } from "react/jsx-runtime";
+import { memo as c, useMemo as p } from "react";
+import { useReducedMotion as d, motion as g } from "motion/react";
+import { cn as u } from "../../lib/cn.js";
+const b = ({
+  children: e,
+  as: o = "p",
+  className: r,
+  duration: n = 2,
+  spread: t = 2
+}) => {
+  const a = d(), i = g.create(
+    o
+  ), s = p(
+    () => ((e == null ? void 0 : e.length) ?? 0) * t,
+    [e, t]
+  );
+  return /* @__PURE__ */ m(
+    i,
+    {
+      animate: a ? void 0 : { backgroundPosition: "0% center" },
+      className: u(
+        "relative inline-block bg-[length:250%_100%,auto] bg-clip-text text-transparent",
+        "[--bg:linear-gradient(90deg,transparent_calc(50%_-_var(--spread)),var(--background),transparent_calc(50%_+_var(--spread)))] [background-repeat:no-repeat,padding-box]",
+        r
+      ),
+      initial: { backgroundPosition: "100% center" },
+      style: {
+        "--spread": `${s}px`,
+        backgroundImage: "var(--bg), linear-gradient(var(--text-secondary), var(--text-secondary))"
+      },
+      transition: a ? void 0 : {
+        repeat: Number.POSITIVE_INFINITY,
+        duration: n,
+        ease: "linear"
+      },
+      children: e
+    }
+  );
+}, k = c(b);
+export {
+  k as Shimmer
+};

package/components/ai-elements/speech-input.d.ts

@@ -0,0 +1,16 @@
+import { ComponentProps } from 'react';
+import { Button } from '../button';
+export type SpeechInputProps = Omit<ComponentProps<typeof Button>, "children" | "onError"> & {
+    /** Fires with each finalized phrase (interim results are ignored). */
+    onTranscriptionChange?: (text: string) => void;
+    /**
+     * Fallback for browsers without the Web Speech API (Firefox / Safari).
+     * Receives the recorded audio blob and should resolve to the transcribed
+     * text, which is then passed to `onTranscriptionChange`.
+     */
+    onAudioRecorded?: (audioBlob: Blob) => Promise<string>;
+    /** Fires on permission / recognition failures (e.g. `"not-allowed"`). */
+    onError?: (error: string) => void;
+    lang?: string;
+};
+export declare const SpeechInput: ({ className, onTranscriptionChange, onAudioRecorded, onError, lang, disabled, ...props }: SpeechInputProps) => import("react").JSX.Element;

package/components/ai-elements/speech-input.js

@@ -0,0 +1,151 @@
+"use client";
+import { jsxs as J, jsx as f } from "react/jsx-runtime";
+import { useState as b, useRef as l, useEffect as Y, useCallback as I } from "react";
+import { Button as K } from "../button.js";
+import { Spinner as Q } from "../spinner.js";
+import { Stop as V, MicOff as W, Mic as X } from "../../lib/icons.js";
+import { cn as _ } from "../../lib/cn.js";
+const Z = () => window.SpeechRecognition ?? window.webkitSpeechRecognition, $ = () => typeof window > "u" ? "none" : "SpeechRecognition" in window || "webkitSpeechRecognition" in window ? "speech-recognition" : "MediaRecorder" in window && "mediaDevices" in navigator ? "media-recorder" : "none", ce = ({
+  className: C,
+  onTranscriptionChange: M,
+  onAudioRecorded: R,
+  onError: x,
+  lang: D = "en-US",
+  disabled: F,
+  ...O
+}) => {
+  const [s, d] = b(!1), [L, z] = b(!1), [o] = b($), [T, N] = b(!1), p = l(null), g = l(null), m = l(null), y = l([]), u = l(M), h = l(R), n = l(x);
+  u.current = M, h.current = R, n.current = x, Y(() => {
+    if (o !== "speech-recognition")
+      return;
+    const t = Z();
+    if (!t)
+      return;
+    const e = new t();
+    e.continuous = !0, e.interimResults = !0, e.lang = D;
+    const c = () => d(!0), v = () => d(!1), w = (r) => {
+      var A, G;
+      const i = r;
+      let a = "";
+      for (let k = i.resultIndex; k < i.results.length; k += 1) {
+        const P = i.results[k];
+        P.isFinal && (a += ((A = P[0]) == null ? void 0 : A.transcript) ?? "");
+      }
+      a && ((G = u.current) == null || G.call(u, a));
+    }, S = (r) => {
+      var i;
+      d(!1), (i = n.current) == null || i.call(n, r.error);
+    };
+    return e.addEventListener("start", c), e.addEventListener("end", v), e.addEventListener("result", w), e.addEventListener("error", S), p.current = e, N(!0), () => {
+      e.removeEventListener("start", c), e.removeEventListener("end", v), e.removeEventListener("result", w), e.removeEventListener("error", S), e.stop(), p.current = null, N(!1);
+    };
+  }, [o, D]), Y(
+    () => () => {
+      var t;
+      if (((t = g.current) == null ? void 0 : t.state) === "recording" && g.current.stop(), m.current)
+        for (const e of m.current.getTracks())
+          e.stop();
+    },
+    []
+  );
+  const j = I(async () => {
+    var t;
+    if (h.current)
+      try {
+        const e = await navigator.mediaDevices.getUserMedia({ audio: !0 });
+        m.current = e;
+        const c = new MediaRecorder(e);
+        y.current = [];
+        const v = (r) => {
+          r.data.size > 0 && y.current.push(r.data);
+        }, w = async () => {
+          var i;
+          for (const a of e.getTracks())
+            a.stop();
+          m.current = null;
+          const r = new Blob(y.current, {
+            type: "audio/webm"
+          });
+          if (r.size > 0 && h.current) {
+            z(!0);
+            try {
+              const a = await h.current(r);
+              a && ((i = u.current) == null || i.call(u, a));
+            } catch {
+            } finally {
+              z(!1);
+            }
+          }
+        }, S = () => {
+          d(!1);
+          for (const r of e.getTracks())
+            r.stop();
+          m.current = null;
+        };
+        c.addEventListener("dataavailable", v), c.addEventListener("stop", w), c.addEventListener("error", S), g.current = c, c.start(), d(!0);
+      } catch (e) {
+        d(!1), (t = n.current) == null || t.call(
+          n,
+          e instanceof Error ? e.name : "not-allowed"
+        );
+      }
+  }, []), B = I(() => {
+    var t;
+    ((t = g.current) == null ? void 0 : t.state) === "recording" && g.current.stop(), d(!1);
+  }, []), q = I(() => {
+    var t;
+    if (o === "speech-recognition" && p.current)
+      if (s)
+        p.current.stop();
+      else
+        try {
+          p.current.start();
+        } catch (e) {
+          (t = n.current) == null || t.call(
+            n,
+            e instanceof Error ? e.name : "not-allowed"
+          );
+        }
+    else o === "media-recorder" && (s ? B() : j());
+  }, [o, s, j, B]), E = o === "none" || o === "media-recorder" && !R, H = F || E || o === "speech-recognition" && !T || L, U = L ? "Transcribing" : s ? "Stop recording" : E ? "Speech input not supported" : "Start recording";
+  return /* @__PURE__ */ J("div", { className: "relative inline-flex items-center justify-center", children: [
+    s && [
+      "",
+      "[animation-delay:var(--stagger-1)]",
+      "[animation-delay:var(--stagger-2)]"
+    ].map((t, e) => /* @__PURE__ */ f(
+      "span",
+      {
+        "aria-hidden": !0,
+        className: _(
+          "absolute inset-0 animate-ping rounded-full bg-danger/20",
+          "[animation-duration:var(--duration-pulse)] motion-reduce:hidden",
+          t
+        )
+      },
+      e
+    )),
+    /* @__PURE__ */ f(
+      K,
+      {
+        "aria-label": U,
+        "aria-pressed": s,
+        className: _(
+          "relative z-10 rounded-full",
+          s && "bg-danger text-danger-foreground shadow-none hover:bg-danger/90 focus-visible:ring-danger/40",
+          C
+        ),
+        disabled: H,
+        size: "icon",
+        title: U,
+        variant: "secondary",
+        ...O,
+        onClick: q,
+        children: L ? /* @__PURE__ */ f(Q, { size: "sm" }) : s ? /* @__PURE__ */ f(V, {}) : E ? /* @__PURE__ */ f(W, {}) : /* @__PURE__ */ f(X, {})
+      }
+    )
+  ] });
+};
+export {
+  ce as SpeechInput
+};

package/components/ai-elements/task-progress.d.ts

@@ -0,0 +1,41 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+export type TaskProgressStatus = "complete" | "active" | "pending";
+export interface TaskProgressStep {
+    id: React.Key;
+    label: React.ReactNode;
+    /** Plain-text label used in live screen-reader announcements. */
+    accessibilityLabel?: string;
+    status: TaskProgressStatus;
+    /** Consumer-formatted elapsed time for the active step, e.g. `0:36`. */
+    elapsed?: string;
+}
+declare const taskProgressVariants: (props?: ({
+    isSticky?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const taskProgressDockVariants: (props?: ({
+    isSticky?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface TaskProgressDockProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof taskProgressDockVariants> {
+}
+/**
+ * Pins TaskProgress directly above an existing chat composer and removes the
+ * seam between the two surfaces. Pass the real ADS Composer as the next child.
+ */
+export declare const TaskProgressDock: React.ForwardRefExoticComponent<TaskProgressDockProps & React.RefAttributes<HTMLDivElement>>;
+export interface TaskProgressProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children">, VariantProps<typeof taskProgressVariants> {
+    steps: readonly TaskProgressStep[];
+    /** Controlled expanded state. */
+    open?: boolean;
+    /** Initial expanded state when uncontrolled. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Expanded header label. */
+    title?: string;
+    /** Optional collapsed-label override. Defaults to the active/latest step. */
+    summary?: React.ReactNode;
+    /** Collapsed label when no steps exist. */
+    emptyLabel?: React.ReactNode;
+}
+export declare const TaskProgress: React.ForwardRefExoticComponent<TaskProgressProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/components/ai-elements/task-progress.js

@@ -0,0 +1,211 @@
+"use client";
+import { jsx as a, jsxs as n, Fragment as q } from "react/jsx-runtime";
+import * as l from "react";
+import { cva as C } from "class-variance-authority";
+import { Collapsible as B, CollapsibleTrigger as G, CollapsibleContent as H } from "../collapsible.js";
+import { Spinner as J } from "../spinner.js";
+import { ChevronDown as K, Check as M, Clock as Q } from "../../lib/icons.js";
+import { cn as o } from "../../lib/cn.js";
+const U = C(
+  "w-full overflow-hidden rounded-2xl bg-card text-foreground",
+  {
+    variants: {
+      isSticky: {
+        true: "sticky top-0 z-20",
+        false: "relative"
+      }
+    },
+    defaultVariants: {
+      isSticky: !0
+    }
+  }
+), X = C(
+  "flex w-full flex-col rounded-2xl bg-transparent [&_.aui-composer-root]:relative [&_.aui-composer-root]:z-10 [&_.aui-composer-root]:-mt-px",
+  {
+    variants: {
+      isSticky: {
+        true: "sticky bottom-0 z-20",
+        false: "relative"
+      }
+    },
+    defaultVariants: {
+      isSticky: !0
+    }
+  }
+), w = l.createContext(!1), Y = l.forwardRef(({ className: t, isSticky: s, ...d }, f) => /* @__PURE__ */ a(w.Provider, { value: !0, children: /* @__PURE__ */ a(
+  "div",
+  {
+    ref: f,
+    "data-slot": "task-progress-dock",
+    className: o(X({ isSticky: s }), t),
+    ...d
+  }
+) }));
+Y.displayName = "TaskProgressDock";
+function y({ status: t }) {
+  return /* @__PURE__ */ n(
+    "span",
+    {
+      "aria-hidden": !0,
+      className: o(
+        "flex size-5 shrink-0 items-center justify-center",
+        t === "complete" && "text-success",
+        t === "active" && "text-info",
+        t === "pending" && "text-tertiary"
+      ),
+      children: [
+        t === "complete" && /* @__PURE__ */ a(M, { className: "size-4", strokeWidth: 2 }),
+        t === "active" && /* @__PURE__ */ a(J, { size: "sm", color: "current", role: "presentation", "aria-hidden": !0 }),
+        t === "pending" && /* @__PURE__ */ a(Q, { className: "size-4" })
+      ]
+    }
+  );
+}
+const Z = {
+  complete: "Complete",
+  active: "In progress",
+  pending: "Pending"
+};
+function N({ elapsed: t }) {
+  return t ? /* @__PURE__ */ n("span", { className: "flex shrink-0 items-center gap-3 text-xs text-tertiary tabular-nums", children: [
+    /* @__PURE__ */ a("span", { "aria-hidden": !0, className: "h-4 w-px bg-border" }),
+    /* @__PURE__ */ a("span", { "aria-label": `Elapsed ${t}`, children: t })
+  ] }) : null;
+}
+const O = l.forwardRef(
+  ({
+    className: t,
+    steps: s,
+    open: d,
+    defaultOpen: f = !1,
+    onOpenChange: u,
+    title: c = "Task progress",
+    summary: P,
+    emptyLabel: I = "No task steps",
+    isSticky: T,
+    role: $,
+    "aria-label": z,
+    "aria-busy": D,
+    ...S
+  }, V) => {
+    const b = l.useContext(w), x = d !== void 0, [j, E] = l.useState(f), m = x ? d : j, i = s.findIndex((e) => e.status === "active"), p = s.reduce(
+      (e, F, W) => F.status === "complete" ? W : e,
+      -1
+    ), R = s.findIndex(
+      (e) => e.status === "pending"
+    ), h = i >= 0 ? i : p >= 0 ? p : R, r = h >= 0 ? s[h] : void 0, g = i >= 0 ? i + 1 : p >= 0 ? p + 1 : 0, _ = s.filter(
+      (e) => e.status === "pending"
+    ).length, k = s.length > 0 && s.every((e) => e.status === "complete"), A = i >= 0 ? "active" : k ? "complete" : "pending", v = r ? r.accessibilityLabel ?? (typeof r.label == "string" ? r.label : "") : "", L = l.useCallback(
+      (e) => {
+        x || E(e), u == null || u(e);
+      },
+      [x, u]
+    );
+    return /* @__PURE__ */ n(
+      B,
+      {
+        ref: V,
+        open: m,
+        onOpenChange: L,
+        role: $ ?? "region",
+        "aria-label": z ?? c,
+        "aria-busy": D ?? (i >= 0 || void 0),
+        ...S,
+        "data-slot": "task-progress",
+        "data-status": A,
+        className: o(
+          U({ isSticky: b ? !1 : T }),
+          b && "rounded-b-none",
+          t
+        ),
+        children: [
+          /* @__PURE__ */ a(
+            "span",
+            {
+              className: "sr-only",
+              role: "progressbar",
+              "aria-label": c,
+              "aria-valuemin": 0,
+              "aria-valuemax": s.length,
+              "aria-valuenow": g
+            }
+          ),
+          /* @__PURE__ */ a("span", { className: "sr-only", "aria-live": "polite", "aria-atomic": "true", children: k ? `All ${s.length} steps complete` : `Step ${g} of ${s.length}${v ? `: ${v}` : ""}. ${_} pending.` }),
+          /* @__PURE__ */ a(G, { asChild: !0, children: /* @__PURE__ */ n(
+            "button",
+            {
+              type: "button",
+              "aria-label": m ? `Collapse ${c}` : `Expand ${c}`,
+              className: o(
+                "flex min-h-(--panel-header-height) w-full items-center gap-3 px-4 text-left sm:px-5",
+                "rounded-t-2xl rounded-b-sm outline-none focus-visible:ring-3 focus-visible:ring-inset focus-visible:ring-ring",
+                "transition-[color,transform] duration-(--duration-fast) ease-out active:scale-(--scale-press) motion-reduce:transition-none"
+              ),
+              children: [
+                m ? /* @__PURE__ */ a("span", { className: "min-w-0 flex-1 truncate text-base font-bold text-secondary", children: c }) : /* @__PURE__ */ n(q, { children: [
+                  /* @__PURE__ */ a(y, { status: (r == null ? void 0 : r.status) ?? "pending" }),
+                  /* @__PURE__ */ a("span", { className: "min-w-0 flex-1 truncate text-base text-primary", children: P ?? (r == null ? void 0 : r.label) ?? I }),
+                  (r == null ? void 0 : r.status) === "active" && /* @__PURE__ */ a(N, { elapsed: r.elapsed })
+                ] }),
+                /* @__PURE__ */ n(
+                  "span",
+                  {
+                    "aria-hidden": !0,
+                    className: "shrink-0 text-xs font-bold text-tertiary tabular-nums",
+                    children: [
+                      g,
+                      " / ",
+                      s.length
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ a(
+                  K,
+                  {
+                    "aria-hidden": !0,
+                    className: o(
+                      "size-4 shrink-0 text-tertiary",
+                      m && "rotate-180"
+                    )
+                  }
+                )
+              ]
+            }
+          ) }),
+          /* @__PURE__ */ a(H, { className: "outline-none", children: /* @__PURE__ */ a(
+            "ol",
+            {
+              "aria-label": "Task steps",
+              className: "max-h-64 space-y-1 overflow-y-auto px-4 pb-4 sm:px-5",
+              children: s.map((e) => /* @__PURE__ */ n(
+                "li",
+                {
+                  "data-status": e.status,
+                  className: o(
+                    "flex min-h-8 items-center gap-3 text-base",
+                    e.status === "pending" ? "text-tertiary" : "text-primary"
+                  ),
+                  children: [
+                    /* @__PURE__ */ n("span", { className: "sr-only", children: [
+                      Z[e.status],
+                      ": "
+                    ] }),
+                    /* @__PURE__ */ a(y, { status: e.status }),
+                    /* @__PURE__ */ a("span", { className: "min-w-0 flex-1 truncate", children: e.label }),
+                    e.status === "active" && /* @__PURE__ */ a(N, { elapsed: e.elapsed })
+                  ]
+                },
+                e.id
+              ))
+            }
+          ) })
+        ]
+      }
+    );
+  }
+);
+O.displayName = "TaskProgress";
+export {
+  O as TaskProgress,
+  Y as TaskProgressDock
+};

package/components/ai-elements/task.d.ts

@@ -0,0 +1,35 @@
+import { ComponentProps } from 'react';
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '../collapsible';
+/**
+ * Task — a collapsible list of the steps an agent took to accomplish a goal
+ * (files searched, files read, scans run). An ADS-native port of the Vercel AI
+ * Elements `Task` component; the public API mirrors upstream 1:1.
+ */
+export type TaskItemFileProps = ComponentProps<"div">;
+/** An inline file/artifact pill inside a {@link TaskItem}. */
+export declare const TaskItemFile: {
+    ({ children, className, ...props }: TaskItemFileProps): import("react").JSX.Element;
+    displayName: string;
+};
+export type TaskItemProps = ComponentProps<"div">;
+export declare const TaskItem: {
+    ({ children, className, ...props }: TaskItemProps): import("react").JSX.Element;
+    displayName: string;
+};
+export type TaskProps = ComponentProps<typeof Collapsible>;
+export declare const Task: {
+    ({ defaultOpen, className, ...props }: TaskProps): import("react").JSX.Element;
+    displayName: string;
+};
+export type TaskTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
+    title: string;
+};
+export declare const TaskTrigger: {
+    ({ children, className, title, ...props }: TaskTriggerProps): import("react").JSX.Element;
+    displayName: string;
+};
+export type TaskContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const TaskContent: {
+    ({ children, className, ...props }: TaskContentProps): import("react").JSX.Element;
+    displayName: string;
+};