@athenaintel/react 0.13.0 → 0.15.0

package/dist/chat-ui/thread/chat-thread-shell.d.ts

@@ -0,0 +1,97 @@
+import type { FC, ReactNode } from "react";
+export interface ChatThreadMessageComponents {
+    UserMessage: FC;
+    AssistantMessage: FC;
+}
+export interface ChatThreadShellProps {
+    /**
+     * Rendered as the first child of the panel — for absolutely-positioned
+     * scrims that must cover the whole panel (AthenaChat's thread-loading
+     * overlay). The shell does not force a positioning context; hosts include
+     * `relative` in `panelClassName` when the scrim anchors to the panel.
+     */
+    overlay?: ReactNode;
+    /**
+     * Rendered above the viewport, inside the panel: header rows, slide-over
+     * panels, and anything else the host docks at the top.
+     */
+    header?: ReactNode;
+    /** Status/approval banners rendered between the header and the viewport. */
+    banners?: ReactNode;
+    /**
+     * Nodes rendered inside the scroll viewport before the message column —
+     * absolutely/sticky-positioned overlays (thread-switch skeletons,
+     * scroll-to-top controls) and invisible observers (read receipts).
+     */
+    viewportOverlay?: ReactNode;
+    /** Empty-thread state, rendered via ThreadPrimitive.Empty when provided. */
+    welcome?: ReactNode;
+    /** Message renderers for ThreadPrimitive.Messages. */
+    components: ChatThreadMessageComponents;
+    /**
+     * Wraps the messages element — for hosts that provide message-scoped
+     * context (e.g. activity-grouping providers). Must render its argument.
+     */
+    renderMessages?: (messages: ReactNode) => ReactNode;
+    /**
+     * Rendered between the viewport and the composer: connection banners,
+     * queued-message trays.
+     */
+    belowViewport?: ReactNode;
+    /** The composer dock (or a read-only notice replacing it). */
+    composer?: ReactNode;
+    /**
+     * Replaces the docked-panel card chrome — for hosts that render a
+     * full-page column (AthenaChat's `aui-*` surface) instead of the
+     * side-panel/task-pane card.
+     */
+    panelClassName?: string;
+    /**
+     * Value of the `--thread-max-width` variable read by width-capped
+     * message/welcome/footer columns. Panels fill their width (the default,
+     * "100%"); full-page hosts cap the column (AthenaChat defaults to 44rem).
+     */
+    maxWidth?: string;
+    /**
+     * Anchors the latest turn to the top of the viewport instead of pinning
+     * scroll to the bottom (AthenaChat). Omitted = the primitive's default.
+     */
+    turnAnchor?: "top" | "bottom";
+    /** Replaces the scroll-viewport chrome (padding, overflow tuning). */
+    viewportClassName?: string;
+    /**
+     * Replaces the message-column chrome. Hosts whose welcome screen centers
+     * vertically make this a flex column so the welcome node can grow.
+     */
+    contentClassName?: string;
+    /**
+     * Thread-level "Thinking..." indicator rendered after the messages. Hosts
+     * whose message components render their own per-message indicators pass
+     * null so the two never double up.
+     */
+    runningIndicator?: ReactNode;
+    /**
+     * Replaces the default centered scroll-to-bottom pill inside the sticky
+     * viewport footer (AthenaChat floats a circular button above its composer).
+     */
+    scrollToBottom?: ReactNode;
+    /**
+     * Content docked inside the sticky viewport footer, after the
+     * scroll-to-bottom control — for hosts whose banners + composer float over
+     * the scrolling messages (AthenaChat) instead of sitting below the
+     * viewport via `belowViewport`/`composer`.
+     */
+    viewportFooter?: ReactNode;
+    /** Replaces the sticky viewport-footer chrome. */
+    viewportFooterClassName?: string;
+}
+/**
+ * The shared thread layout: panel chrome, scroll viewport with welcome +
+ * messages + running indicator, the sticky scroll-to-bottom control, and the
+ * host-supplied composer dock.
+ *
+ * Hosts express their genuine divergences through the slots above; the
+ * layout, scroll behaviour, and empty/running states stay identical across
+ * surfaces so fixes land once.
+ */
+export declare function ChatThreadShell({ overlay, header, banners, viewportOverlay, welcome, components, renderMessages, belowViewport, composer, panelClassName, maxWidth, turnAnchor, viewportClassName, contentClassName, runningIndicator, scrollToBottom, viewportFooter, viewportFooterClassName, }: ChatThreadShellProps): import("react/jsx-runtime").JSX.Element;

package/dist/chat-ui/thread/composer-send-or-stop.d.ts

@@ -0,0 +1,67 @@
+import type { FC, RefObject } from "react";
+import { type ComposerAction } from "../composer/composer-action";
+import { type ComposerSendButtonProps, type ComposerStopButtonProps } from "../messages/message-components";
+/**
+ * The slice of a composer handle this control needs: something whose draft
+ * can be submitted. `TiptapComposerHandle` satisfies it; hosts with their own
+ * editor plumbing (the SDK's AthenaChat) expose a compatible handle.
+ */
+export interface ComposerSubmitHandle {
+    submit: () => void | Promise<void>;
+}
+export interface ComposerStopControls {
+    /**
+     * Cancels the active run via the runtime. Returns false when cancellation
+     * threw (e.g. the run already settled), so hosts can report whether their
+     * own teardown still needs to stop backend work.
+     */
+    cancelRun: () => boolean;
+}
+/**
+ * Control renderers, for hosts with their own published theming contract
+ * (AthenaChat's `aui-*` class system). Defaults render the shared buttons.
+ */
+export interface ComposerSendOrStopComponents {
+    SendButton?: FC<ComposerSendButtonProps>;
+    StopButton?: FC<ComposerStopButtonProps>;
+}
+export interface ComposerSendOrStopProps {
+    composerRef: RefObject<ComposerSubmitHandle | null>;
+    hasDraft: boolean;
+    /**
+     * Whether a draft may queue behind an active run (server-owned queue).
+     * Hosts on transports without a queue pass false so an active run always
+     * resolves to stop. Defaults to true.
+     */
+    canQueue?: boolean;
+    /** Disables both send and stop (e.g. while a conversation restores). */
+    disabled?: boolean;
+    /**
+     * Blocks sending (not stopping) with this reason as the tooltip — e.g. a
+     * broken host tunnel that would make tool calls silently fail.
+     */
+    sendBlockedReason?: string | null;
+    /** Tooltip for the send/queue control while `disabled`. */
+    sendDisabledTitle?: string;
+    /** Tooltip for the stop control while `disabled`. */
+    stopDisabledTitle?: string;
+    /**
+     * Host work to run before the draft submits (per-turn bookkeeping).
+     * `action` distinguishes a fresh send from queueing into an active run.
+     */
+    onBeforeSend?: (context: {
+        action: Extract<ComposerAction, "send" | "queue">;
+    }) => void | Promise<void>;
+    /**
+     * Full custom stop sequence. Hosts that must tear down in-flight host-side
+     * work sequence it around `controls.cancelRun()`. Default: cancel the run.
+     */
+    onStop?: (controls: ComposerStopControls) => void;
+    components?: ComposerSendOrStopComponents;
+}
+/**
+ * The shared send/queue/stop control: sends the composer draft, queues it as
+ * a follow-up while a run is in flight, or stops the run when there is
+ * nothing to queue.
+ */
+export declare const ComposerSendOrStop: FC<ComposerSendOrStopProps>;