@fromsko/chat-ui 0.0.0-stage → 0.1.6

package/lib/primitives/Tooltip.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { cn } from "../utils/cn";
+export function Tooltip({ content, children, side = "top", className }) {
+    const [open, setOpen] = useState(false);
+    return (_jsxs("span", { className: cn("relative inline-flex", className), onMouseEnter: () => setOpen(true), onMouseLeave: () => setOpen(false), onFocus: () => setOpen(true), onBlur: () => setOpen(false), children: [children, open ? (_jsx("span", { role: "tooltip", className: cn("pointer-events-none absolute left-1/2 z-tooltip -translate-x-1/2 whitespace-nowrap rounded-[var(--radius-sm)] border border-border bg-popover px-1.5 py-1 text-micro text-popover-foreground shadow-md", side === "top" ? "bottom-full mb-1.5" : "top-full mt-1.5"), children: content })) : null] }));
+}

package/lib/primitives/index.d.ts

@@ -0,0 +1,14 @@
+export { Button, type ButtonProps, type ButtonVariant, type ButtonSize } from "./Button";
+export { Badge, type BadgeProps, type BadgeVariant } from "./Badge";
+export { Textarea, type TextareaProps } from "./Textarea";
+export { Input, type InputProps } from "./Input";
+export { Kbd } from "./Kbd";
+export { Spinner } from "./Spinner";
+export { Separator, type SeparatorProps } from "./Separator";
+export { Collapsible, type CollapsibleProps } from "./Collapsible";
+export { Tooltip, type TooltipProps } from "./Tooltip";
+export { DropdownMenu, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, type DropdownMenuProps, } from "./DropdownMenu";
+export { Popover, type PopoverProps } from "./Popover";
+export { Dialog, type DialogProps } from "./Dialog";
+export { ScrollArea, type ScrollAreaProps } from "./ScrollArea";
+export { Empty, type EmptyProps } from "./Empty";

package/lib/primitives/index.js

@@ -0,0 +1,14 @@
+export { Button } from "./Button";
+export { Badge } from "./Badge";
+export { Textarea } from "./Textarea";
+export { Input } from "./Input";
+export { Kbd } from "./Kbd";
+export { Spinner } from "./Spinner";
+export { Separator } from "./Separator";
+export { Collapsible } from "./Collapsible";
+export { Tooltip } from "./Tooltip";
+export { DropdownMenu, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, } from "./DropdownMenu";
+export { Popover } from "./Popover";
+export { Dialog } from "./Dialog";
+export { ScrollArea } from "./ScrollArea";
+export { Empty } from "./Empty";

package/lib/reactbits/Motion.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from "react";
+export declare function ShimmerText({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function CountUp({ value, duration, className, }: {
+    value: number;
+    duration?: number;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function BlurIn({ children, delay, className, }: {
+    children: ReactNode;
+    delay?: number;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function StaggerChildren({ children, className, step, }: {
+    children: ReactNode;
+    className?: string;
+    step?: number;
+}): import("react").JSX.Element;
+export declare function GlowCard({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/lib/reactbits/Motion.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { animate, stagger, useInView } from "motion/react";
+import { cn } from "../utils/cn";
+export function ShimmerText({ children, className, }) {
+    return (_jsx("span", { className: cn("animate-shimmer bg-gradient-to-r from-muted-foreground/50 via-foreground to-muted-foreground/50 bg-[length:200%_100%] bg-clip-text text-transparent", className), children: children }));
+}
+export function CountUp({ value, duration = 0.8, className, }) {
+    const ref = useRef(null);
+    const [display, setDisplay] = useState(value);
+    const prev = useRef(value);
+    useEffect(() => {
+        const el = ref.current;
+        if (!el)
+            return;
+        const controls = animate(prev.current, value, {
+            duration,
+            ease: "easeOut",
+            onUpdate: (v) => setDisplay(Math.round(v)),
+        });
+        prev.current = value;
+        return () => controls.stop();
+    }, [value, duration]);
+    return (_jsx("span", { ref: ref, className: cn("tabular-nums", className), children: display }));
+}
+export function BlurIn({ children, delay = 0, className, }) {
+    const ref = useRef(null);
+    const inView = useInView(ref, { once: true });
+    useEffect(() => {
+        const el = ref.current;
+        if (!el || !inView)
+            return;
+        animate(el, { opacity: [0, 1], filter: ["blur(8px)", "blur(0px)"], y: [12, 0] }, { duration: 0.5, delay, ease: "easeOut" });
+    }, [inView, delay]);
+    return (_jsx("div", { ref: ref, className: cn("opacity-0", className), children: children }));
+}
+export function StaggerChildren({ children, className, step = 0.05, }) {
+    const ref = useRef(null);
+    useEffect(() => {
+        const el = ref.current;
+        if (!el)
+            return;
+        const items = Array.from(el.children);
+        if (items.length === 0)
+            return;
+        animate(items, { opacity: [0, 1], y: [8, 0] }, { duration: 0.35, delay: stagger(step), ease: "easeOut" });
+    }, [step]);
+    return (_jsx("div", { ref: ref, className: className, children: children }));
+}
+export function GlowCard({ children, className, }) {
+    return (_jsx("div", { className: cn("cursor-glow relative rounded-[var(--radius-lg)] border border-border bg-card p-4 transition-shadow hover:shadow-lg", className), children: children }));
+}

package/lib/reactbits/index.d.ts

@@ -0,0 +1 @@
+export { ShimmerText, CountUp, BlurIn, StaggerChildren, GlowCard, } from "./Motion";

package/lib/reactbits/index.js

@@ -0,0 +1 @@
+export { ShimmerText, CountUp, BlurIn, StaggerChildren, GlowCard, } from "./Motion";

package/lib/stores/chat-store.d.ts

@@ -0,0 +1,33 @@
+import type { Agent } from "../types/agent";
+import type { Conversation, ConversationId, ConversationStatus } from "../types/conversation";
+import type { Attachment, ChatMessage } from "../types/message";
+import { type ConversationAction, type ConversationState } from "../domain/reducer";
+export interface ChatStore extends ConversationState {
+    dispatch: (action: ConversationAction) => void;
+    select: (id: ConversationId) => void;
+    setDraft: (id: ConversationId, value: string) => void;
+    append: (id: ConversationId, message: ChatMessage) => void;
+    deleteMessage: (id: ConversationId, messageId: string) => void;
+    insertMessageAt: (id: ConversationId, index: number, message: ChatMessage) => void;
+    replaceAgents: (agents: Record<string, Agent>) => void;
+    reportError: (message: string) => void;
+    clearPersistError: () => void;
+    bindRequest: (requestId: string) => void;
+    streamDelta: (requestId: string, text: string) => void;
+    streamReasoning: (requestId: string, text: string) => void;
+    streamToolCall: (requestId: string, toolCallId: string, name: string, args: unknown) => void;
+    streamToolResult: (requestId: string, toolCallId: string, result: string, isError: boolean) => void;
+    streamContextUsage: (requestId: string, inputTokens: number, outputTokens: number, window: number) => void;
+    streamMemory: (requestId: string, count: number, excerpt: string) => void;
+    streamCompaction: (requestId: string | null, beforeTokens: number, afterTokens: number, reason: string) => void;
+    streamDisplay: (requestId: string, view: string, title?: string, payload?: unknown) => void;
+    streamOutput: (requestId: string, outputKind: "text" | "file" | "link" | "json", label?: string, value?: string) => void;
+    streamEnd: (requestId: string, outcome: "done" | "error", error?: string) => void;
+    send: (text: string, attachments?: Attachment[], deliver?: (text: string, attachments?: Attachment[] | undefined) => void | Promise<void>) => void;
+}
+export declare const useChatStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ChatStore>>;
+export declare const selectActive: (s: ChatStore) => Conversation | null;
+export declare const selectActiveMessages: (s: ChatStore) => ChatMessage[];
+export declare const selectActiveMembers: (s: ChatStore) => Agent[];
+export declare const selectActiveStreaming: (s: ChatStore) => boolean;
+export declare const selectActiveStatus: (s: ChatStore) => ConversationStatus;

package/lib/stores/chat-store.js

@@ -0,0 +1,93 @@
+import { create } from "zustand";
+import { conversationReducer, createConversationState, isConversationStreaming, } from "../domain/reducer";
+import { clockLabel } from "../adapters/labels";
+let seq = 0;
+function nextId(prefix) {
+    seq += 1;
+    return `${prefix}-${seq}`;
+}
+export const useChatStore = create()((set, get) => {
+    const dispatch = (action) => set((state) => conversationReducer(state, action));
+    return {
+        ...createConversationState(),
+        dispatch,
+        select: (id) => dispatch({ type: "select", id }),
+        setDraft: (id, value) => dispatch({ type: "draft", id, value }),
+        append: (id, message) => dispatch({ type: "append", id, message }),
+        deleteMessage: (id, messageId) => dispatch({ type: "deleteMessage", id, messageId }),
+        insertMessageAt: (id, index, message) => dispatch({ type: "insertMessageAt", id, index, message }),
+        replaceAgents: (agents) => dispatch({ type: "replaceAgents", agents }),
+        reportError: (message) => dispatch({ type: "persistError", value: message }),
+        clearPersistError: () => dispatch({ type: "persistError", value: null }),
+        bindRequest: (requestId) => dispatch({ type: "bindRequest", requestId }),
+        streamDelta: (requestId, text) => dispatch({ type: "streamDelta", requestId, text }),
+        streamReasoning: (requestId, text) => dispatch({ type: "streamReasoning", requestId, text }),
+        streamToolCall: (requestId, toolCallId, name, args) => dispatch({ type: "streamToolCall", requestId, toolCallId, name, args }),
+        streamToolResult: (requestId, toolCallId, result, isError) => dispatch({
+            type: "streamToolResult",
+            requestId,
+            toolCallId,
+            result,
+            isError,
+        }),
+        streamContextUsage: (requestId, inputTokens, outputTokens, window) => dispatch({
+            type: "streamContextUsage",
+            requestId,
+            inputTokens,
+            outputTokens,
+            window,
+        }),
+        streamMemory: (requestId, count, excerpt) => dispatch({ type: "streamMemory", requestId, count, excerpt }),
+        streamCompaction: (requestId, beforeTokens, afterTokens, reason) => dispatch({
+            type: "streamCompaction",
+            requestId,
+            beforeTokens,
+            afterTokens,
+            reason,
+        }),
+        streamDisplay: (requestId, view, title, payload) => dispatch({ type: "streamDisplay", requestId, view, title, payload }),
+        streamOutput: (requestId, outputKind, label, value) => dispatch({
+            type: "streamOutput",
+            requestId,
+            outputKind,
+            label,
+            value: value ?? "",
+        }),
+        streamEnd: (requestId, outcome, error) => dispatch({ type: "streamEnd", requestId, outcome, error }),
+        send: (text, attachments, deliver) => {
+            const state = get();
+            const active = state.activeId;
+            if (!active)
+                return;
+            const trimmed = text.trim();
+            if (trimmed.length === 0 && (attachments?.length ?? 0) === 0)
+                return;
+            if (isConversationStreaming(state, active))
+                return;
+            const message = {
+                id: nextId(`${active}-u`),
+                role: "user",
+                text: trimmed,
+                attachments,
+                timeLabel: clockLabel(),
+                state: "done",
+            };
+            dispatch({ type: "append", id: active, message });
+            dispatch({ type: "draft", id: active, value: "" });
+            void deliver?.(trimmed, attachments);
+        },
+    };
+});
+const EMPTY_MESSAGES = [];
+export const selectActive = (s) => s.conversations.find((c) => c.id === s.activeId) ?? null;
+export const selectActiveMessages = (s) => (s.activeId ? s.messages[s.activeId] : undefined) ?? EMPTY_MESSAGES;
+export const selectActiveMembers = (s) => {
+    const active = selectActive(s);
+    if (!active)
+        return [];
+    return active.memberIds
+        .map((id) => s.agents[id])
+        .filter((a) => a !== undefined);
+};
+export const selectActiveStreaming = (s) => s.activeId ? isConversationStreaming(s, s.activeId) : false;
+export const selectActiveStatus = (s) => selectActiveStreaming(s) ? "streaming" : s.persistError ? "error" : "idle";

package/lib/stores/display-store.d.ts

@@ -0,0 +1,15 @@
+import type { BlockVisibility, BlockVisibilityKey, DensityMode, DisplayConfig, MessageStyleMode, RadiusMode, WidthPreset } from "../types/display";
+export interface DisplayStore extends DisplayConfig {
+    setRadius: (radius: RadiusMode) => void;
+    setDensity: (density: DensityMode) => void;
+    setMessageStyle: (style: MessageStyleMode) => void;
+    setStreamWidth: (width: WidthPreset) => void;
+    setComposerWidth: (width: WidthPreset) => void;
+    setStreamWidthPx: (px: number | null) => void;
+    setComposerWidthPx: (px: number | null) => void;
+    setBlockHidden: (key: BlockVisibilityKey, hidden: boolean) => void;
+    resetDisplay: () => void;
+}
+export declare const useDisplayStore: import("zustand").UseBoundStore<import("zustand").StoreApi<DisplayStore>>;
+export declare function initDisplayStore(): void;
+export type { DisplayConfig, RadiusMode, DensityMode, MessageStyleMode, BlockVisibility, BlockVisibilityKey };

package/lib/stores/display-store.js

@@ -0,0 +1,116 @@
+import { create } from "zustand";
+import { DEFAULT_DISPLAY_CONFIG, WIDTH_MAX, WIDTH_MIN, WIDTH_PRESET_VALUES, } from "../types/display";
+import { LS_KEYS, loadJSON, saveJSON } from "../utils/storage";
+function applyToDom(config) {
+    if (typeof document === "undefined")
+        return;
+    const root = document.documentElement;
+    root.setAttribute("data-radius", config.radius);
+    root.setAttribute("data-density", config.density);
+    root.setAttribute("data-msg-style", config.messageStyle);
+    const streamW = config.streamWidthPx != null
+        ? `${config.streamWidthPx}px`
+        : config.streamWidth === "full"
+            ? "100%"
+            : `${WIDTH_PRESET_VALUES[config.streamWidth]}px`;
+    const composerW = config.composerWidthPx != null
+        ? `${config.composerWidthPx}px`
+        : config.composerWidth === "full"
+            ? "100%"
+            : `${WIDTH_PRESET_VALUES[config.composerWidth]}px`;
+    root.style.setProperty("--ac-stream-width", streamW);
+    root.style.setProperty("--ac-composer-width", composerW);
+    root.setAttribute("data-stream-width", String(config.streamWidth));
+    root.setAttribute("data-composer-width", String(config.composerWidth));
+    const hidden = Object.entries(config.hidden)
+        .filter(([, v]) => v)
+        .map(([k]) => k);
+    if (hidden.length > 0)
+        root.setAttribute("data-hide", hidden.join(" "));
+    else
+        root.removeAttribute("data-hide");
+}
+function persist(config) {
+    saveJSON(LS_KEYS.displayConfig, config);
+    applyToDom(config);
+}
+function mergeHidden(partial) {
+    return { ...DEFAULT_DISPLAY_CONFIG.hidden, ...partial };
+}
+function normalizeWidth(v) {
+    return v === "narrow" || v === "wide" || v === "full" ? v : "standard";
+}
+function clampPx(n) {
+    return Math.max(WIDTH_MIN, Math.min(WIDTH_MAX, Math.round(n)));
+}
+function normalizePx(v) {
+    return typeof v === "number" && Number.isFinite(v) ? clampPx(v) : null;
+}
+const initial = (() => {
+    const saved = loadJSON(LS_KEYS.displayConfig, null);
+    if (!saved || typeof saved !== "object")
+        return DEFAULT_DISPLAY_CONFIG;
+    return {
+        radius: saved.radius === "square" ? "square" : "rounded",
+        density: saved.density === "compact" ? "compact" : "comfortable",
+        messageStyle: saved.messageStyle === "bubble" ? "bubble" : "seamless",
+        streamWidth: normalizeWidth(saved.streamWidth),
+        composerWidth: normalizeWidth(saved.composerWidth),
+        streamWidthPx: normalizePx(saved.streamWidthPx),
+        composerWidthPx: normalizePx(saved.composerWidthPx),
+        hidden: mergeHidden(saved.hidden ?? {}),
+    };
+})();
+export const useDisplayStore = create((set, get) => ({
+    ...initial,
+    setRadius: (radius) => {
+        const next = { ...get(), radius };
+        persist(next);
+        set({ radius });
+    },
+    setDensity: (density) => {
+        const next = { ...get(), density };
+        persist(next);
+        set({ density });
+    },
+    setMessageStyle: (messageStyle) => {
+        const next = { ...get(), messageStyle };
+        persist(next);
+        set({ messageStyle });
+    },
+    setStreamWidth: (streamWidth) => {
+        const next = { ...get(), streamWidth, streamWidthPx: null };
+        persist(next);
+        set({ streamWidth, streamWidthPx: null });
+    },
+    setComposerWidth: (composerWidth) => {
+        const next = { ...get(), composerWidth, composerWidthPx: null };
+        persist(next);
+        set({ composerWidth, composerWidthPx: null });
+    },
+    setStreamWidthPx: (px) => {
+        const streamWidthPx = px == null ? null : clampPx(px);
+        const next = { ...get(), streamWidthPx };
+        persist(next);
+        set({ streamWidthPx });
+    },
+    setComposerWidthPx: (px) => {
+        const composerWidthPx = px == null ? null : clampPx(px);
+        const next = { ...get(), composerWidthPx };
+        persist(next);
+        set({ composerWidthPx });
+    },
+    setBlockHidden: (key, hidden) => {
+        const nextHidden = { ...get().hidden, [key]: hidden };
+        const next = { ...get(), hidden: nextHidden };
+        persist(next);
+        set({ hidden: nextHidden });
+    },
+    resetDisplay: () => {
+        persist(DEFAULT_DISPLAY_CONFIG);
+        set({ ...DEFAULT_DISPLAY_CONFIG, hidden: { ...DEFAULT_DISPLAY_CONFIG.hidden } });
+    },
+}));
+export function initDisplayStore() {
+    applyToDom(useDisplayStore.getState());
+}

package/lib/stores/index.d.ts

@@ -0,0 +1,3 @@
+export { useChatStore, selectActive, selectActiveMessages, selectActiveMembers, selectActiveStreaming, selectActiveStatus, type ChatStore, } from "./chat-store";
+export { useDisplayStore, initDisplayStore, type DisplayStore, } from "./display-store";
+export { useThemeStore, initThemeStore, type ThemeStore, } from "./theme-store";

package/lib/stores/index.js

@@ -0,0 +1,3 @@
+export { useChatStore, selectActive, selectActiveMessages, selectActiveMembers, selectActiveStreaming, selectActiveStatus, } from "./chat-store";
+export { useDisplayStore, initDisplayStore, } from "./display-store";
+export { useThemeStore, initThemeStore, } from "./theme-store";

package/lib/stores/theme-store.d.ts

@@ -0,0 +1,8 @@
+import type { ThemeName } from "../types/theme";
+export interface ThemeStore {
+    theme: ThemeName;
+    setTheme: (theme: ThemeName) => void;
+    toggleTheme: () => void;
+}
+export declare const useThemeStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ThemeStore>>;
+export declare function initThemeStore(): void;

package/lib/stores/theme-store.js

@@ -0,0 +1,29 @@
+import { create } from "zustand";
+import { LS_KEYS, loadJSON, saveJSON } from "../utils/storage";
+const THEME_VALUES = ["dark", "light", "glass"];
+function normalize(value) {
+    return value === "light" || value === "glass" ? value : "dark";
+}
+function applyToDom(theme) {
+    if (typeof document === "undefined")
+        return;
+    document.documentElement.setAttribute("data-theme", theme);
+}
+const initial = normalize(loadJSON(LS_KEYS.theme, "dark"));
+export const useThemeStore = create((set, get) => ({
+    theme: initial,
+    setTheme: (theme) => {
+        const next = normalize(theme);
+        saveJSON(LS_KEYS.theme, next);
+        applyToDom(next);
+        set({ theme: next });
+    },
+    toggleTheme: () => {
+        const idx = THEME_VALUES.indexOf(get().theme);
+        const next = THEME_VALUES[(idx + 1) % THEME_VALUES.length];
+        get().setTheme(next);
+    },
+}));
+export function initThemeStore() {
+    applyToDom(useThemeStore.getState().theme);
+}

package/lib/tokens/index.d.ts

@@ -0,0 +1,21 @@
+import type { ControlScale, DesignTokens, GapScale, RadiusScale, ThemeName, TypeScale, ZIndexScale } from "../types/theme";
+export declare const control: ControlScale;
+export declare const type: TypeScale;
+export declare const gaps: GapScale;
+export declare const radius: RadiusScale;
+export declare const z: ZIndexScale;
+export declare const themeNames: ThemeName[];
+export declare function applyTheme(theme: ThemeName): void;
+export declare function readTheme(): ThemeName;
+export declare function designTokens(theme?: ThemeName): DesignTokens;
+export declare const tokens: {
+    control: ControlScale;
+    type: TypeScale;
+    gaps: GapScale;
+    radius: RadiusScale;
+    z: ZIndexScale;
+    themeNames: ThemeName[];
+    applyTheme: typeof applyTheme;
+    readTheme: typeof readTheme;
+};
+export default tokens;

package/lib/tokens/index.js

@@ -0,0 +1,66 @@
+export const control = {
+    xs: 22,
+    sm: 28,
+    md: 32,
+    lg: 40,
+};
+export const type = {
+    micro: { size: 11, lineHeight: 16 },
+    meta: { size: 12, lineHeight: 18 },
+    body: { size: 13, lineHeight: 20 },
+    label: { size: 13, lineHeight: 20 },
+    title: { size: 14, lineHeight: 22 },
+    heading: { size: 16, lineHeight: 24 },
+};
+export const gaps = {
+    xs: 4,
+    sm: 8,
+    md: 12,
+    lg: 16,
+    xl: 20,
+    xxl: 24,
+    stream: 14,
+    bubbleX: 14,
+    bubbleY: 10,
+};
+export const radius = {
+    sm: "var(--radius-sm)",
+    md: "var(--radius-md)",
+    lg: "var(--radius-lg)",
+    xl: "var(--radius-xl)",
+    pill: "var(--radius-pill)",
+};
+export const z = {
+    underCanvas: 0,
+    sticky: 1,
+    canvasOverlay: 10,
+    panel: 20,
+    tooltip: 40,
+    modal: 50,
+    top: 60,
+};
+export const themeNames = ["dark", "light", "glass"];
+export function applyTheme(theme) {
+    if (typeof document === "undefined")
+        return;
+    document.documentElement.setAttribute("data-theme", theme);
+}
+export function readTheme() {
+    if (typeof document === "undefined")
+        return "dark";
+    const v = document.documentElement.getAttribute("data-theme");
+    return v === "light" || v === "glass" ? v : "dark";
+}
+export function designTokens(theme = "dark") {
+    return {
+        theme,
+        palette: {},
+        control,
+        type,
+        gaps,
+        radius,
+        z,
+    };
+}
+export const tokens = { control, type, gaps, radius, z, themeNames, applyTheme, readTheme };
+export default tokens;

package/lib/types/agent.d.ts

@@ -0,0 +1,62 @@
+import type { AgentId, PermissionMode } from "./conversation";
+export type AgentStatus = "online" | "busy" | "offline";
+export type ToolOrigin = "builtin" | "mcp" | "canvas";
+export interface ToolToggle {
+    id: string;
+    label: string;
+    description: string;
+    origin: ToolOrigin;
+    enabled: boolean;
+    available: boolean;
+    unavailableReason?: string;
+}
+export interface PolicyRule {
+    id: string;
+    label: string;
+    description?: string;
+    enabled: boolean;
+}
+export interface ModelParams {
+    temperature?: number | null;
+    topP?: number | null;
+    maxTokens?: number | null;
+}
+export interface Agent {
+    id: AgentId;
+    name: string;
+    role: string;
+    badge: string;
+    status: AgentStatus;
+    persona: string;
+    model: string;
+    modelId: string | null;
+    contextWindowLabel?: string;
+    maxSteps?: number;
+    tools: ToolToggle[];
+    mcpServers: {
+        name: string;
+        enabled: boolean;
+    }[];
+    memory: {
+        backend: string;
+        entries?: number;
+        autoSummary?: boolean;
+    };
+    sandbox: string;
+    permissionMode?: PermissionMode;
+    policies: PolicyRule[];
+    workPath: string | null;
+    modelParams: ModelParams;
+    disabledSkills: string[];
+}
+export interface AgentIdentity {
+    name: string;
+    role: string;
+    badge?: string;
+    persona: string;
+}
+export interface SenderAttribution {
+    name: string;
+    badge: string;
+    agent?: Agent;
+}

package/lib/types/agent.js

@@ -0,0 +1 @@
+export {};

package/lib/types/callbacks.d.ts

@@ -0,0 +1,55 @@
+import type { AgentId } from "./conversation";
+import type { PendingAsk, QueuedPrompt, SessionSearchHit, ConversationId } from "./conversation";
+import type { Attachment, ChatMessage } from "./message";
+export type OnSend = (text: string, attachments?: Attachment[]) => void;
+export type OnStop = () => void;
+export type OnNotice = (message: string) => void;
+export type OnCopyText = (text: string) => Promise<boolean> | boolean;
+export type OnDeleteMessage = (messageId: string) => void;
+export type OnRetry = (messageId: string) => void;
+export type OnEditMessage = (messageId: string, text: string) => void;
+export type OnQuoteMessage = (text: string) => void;
+export type OnTraceMessage = (messageId: string) => void;
+export type OnOpenAgent = (id: AgentId) => void;
+export type OnRespondPermission = (permissionId: string, approved: boolean, remembered: boolean) => void;
+export type OnAnswerAsk = (callId: string, answer: string) => void;
+export type OnSkipAsk = (callId: string) => void;
+export interface SelectionTarget {
+    text: string;
+    agentId: AgentId | null;
+}
+export type OnFavoriteSelection = (target: SelectionTarget) => void;
+export type OnBatchCopy = () => void;
+export type OnBatchRemove = () => void;
+export type OnSelectConversation = (id: ConversationId) => void;
+export type OnOpenConversationHit = (hit: SessionSearchHit) => void;
+export type { ComposerModelSwitch, PermissionModeSwitch, } from "./composer";
+export interface QueuedPromptsCallbacks {
+    onMoveUp: (id: string) => void;
+    onMoveDown: (id: string) => void;
+    onSendNow: (id: string) => void;
+    onEdit: (id: string) => void;
+    onRemove: (id: string) => void;
+}
+export interface MessageMenuCallbacks {
+    onCopyText?: OnCopyText;
+    onQuote?: OnQuoteMessage;
+    onCopySelection?: OnCopyText;
+    onTrace?: OnTraceMessage;
+    onDelete?: OnDeleteMessage;
+    onMultiSelect?: () => void;
+}
+export interface StreamEventCallbacks {
+    onDelta: (requestId: string, text: string) => void;
+    onReasoning: (requestId: string, text: string) => void;
+    onToolCall: (requestId: string, toolCallId: string, name: string, args: unknown) => void;
+    onToolResult: (requestId: string, toolCallId: string, result: string, isError: boolean) => void;
+    onContextUsage: (requestId: string, inputTokens: number, outputTokens: number, window: number) => void;
+    onMemory: (requestId: string, count: number, excerpt: string) => void;
+    onCompaction: (requestId: string | null, beforeTokens: number, afterTokens: number, reason: string) => void;
+    onEnd: (requestId: string, outcome: "done" | "error", error?: string) => void;
+    onDisplay?: (requestId: string, view: string, title?: string, payload?: unknown) => void;
+    onOutput?: (requestId: string, outputKind: "text" | "file" | "link" | "json", label?: string, value?: string) => void;
+}
+export type DeliverFn = (text: string, attachments?: Attachment[]) => void;
+export type { PendingAsk, QueuedPrompt, ChatMessage };

package/lib/types/callbacks.js

@@ -0,0 +1 @@
+export {};