@vertesia/ui 0.60.0 → 0.62.0

package/lib/types/core/components/FormItem.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+interface FormItemProps {
+    label: any;
+    children: ReactNode;
+    className?: string;
+    description?: ReactNode;
+    required?: boolean;
+    direction?: "row" | "column";
+}
+export declare function FormItem({ description, required, label, className, direction, children }: FormItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/index.d.ts

@@ -5,12 +5,11 @@ export * from "./ComboBox.js";
 export * from "./ConfirmModal.js";
 export * from "./DeleteModal.js";
 export * from "./Divider.js";
-export * from "./SidePanel.js";
 export * from "./Dropdown.js";
 export * from "./DropdownList.js";
 export * from "./EmptyCollection.js";
 export * from "./FileUpload.js";
-export * from "./Input.js";
+export * from "./FormItem.js";
 export * from "./InputList.js";
 export * from "./Link.js";
 export * from "./MenuList.js";
@@ -23,6 +22,8 @@ export * from "./RadioGroup.js";
 export * from "./SelectBox.js";
 export * from "./SelectList.js";
 export * from "./SelectStack.js";
+export * from "./shadcn/index.js";
+export * from "./SidePanel.js";
 export * from "./Spinner.js";
 export * from "./styles.js";
 export * from "./Switch.js";
@@ -30,7 +31,6 @@ export * from "./table/index.js";
 export * from "./tabs/index.js";
 export * from "./Textarea.js";
 export * from "./toast/index.js";
-export * from "./shadcn/index.js";
 export type HeroIcon = React.ForwardRefExoticComponent<Omit<React.SVGProps<SVGSVGElement>, "ref"> & {
     title?: string | undefined;
     titleId?: string | undefined;

package/lib/types/core/components/shadcn/button.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "secondary" | "destructive" | "outline" | "ghost" | "primary" | "soft" | "unstyled" | null | undefined;
+    variant?: "link" | "secondary" | "destructive" | "outline" | "ghost" | "primary" | "unstyled" | null | undefined;
     size?: "xs" | "sm" | "md" | "lg" | "xl" | "icon" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
@@ -12,4 +12,15 @@ export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElemen
     isLoading?: boolean;
 }
 declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
-export { Button, buttonVariants };
+interface CopyButtonProps {
+    content: string;
+    alt?: string;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "icon";
+    toast?: {
+        toast: any;
+        message: string;
+    };
+    className?: string;
+}
+declare const CopyButton: React.ForwardRefExoticComponent<CopyButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, CopyButton, buttonVariants };

package/lib/types/core/components/shadcn/calendar.d.ts

@@ -1,9 +1,9 @@
 import * as React from "react";
-import { DayPicker } from "react-day-picker";
-export type CalendarProps = React.ComponentProps<typeof DayPicker> & {
+import DatePicker from "react-date-picker";
+export type CalendarProps = React.ComponentProps<typeof DatePicker> & {
     size?: "sm" | "md" | "lg";
 };
-declare function Calendar({ className, classNames, showOutsideDays, size, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare function Calendar({ className, size, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Calendar {
     var displayName: string;
 }

package/lib/types/core/components/shadcn/command.d.ts

@@ -6,7 +6,7 @@ declare const Command: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     label?: string;
     shouldFilter?: boolean;
     filter?: (value: string, search: string, keywords?: string[]) => number;
@@ -22,7 +22,7 @@ declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<
     ref?: React.Ref<HTMLInputElement>;
 } & {
     asChild?: boolean;
-}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "value" | "onChange" | "type"> & {
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "value" | "type"> & {
     value?: string;
     onValueChange?: (search: string) => void;
 } & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
@@ -32,7 +32,7 @@ declare const CommandList: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     label?: string;
 } & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
@@ -41,14 +41,14 @@ declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
     children?: React.ReactNode;
 } & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "heading"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "heading" | "value"> & {
     heading?: React.ReactNode;
     value?: string;
     forceMount?: boolean;
@@ -57,7 +57,7 @@ declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<R
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     alwaysRender?: boolean;
 } & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
@@ -66,7 +66,7 @@ declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "onSelect" | "disabled"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "onSelect" | "value" | "disabled"> & {
     disabled?: boolean;
     onSelect?: (value: string) => void;
     value?: string;

package/lib/types/core/components/shadcn/filters/DynamicLabel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface DynamicLabelProps {
+    value: string;
+    labelRenderer?: (value: string) => React.ReactNode | Promise<React.ReactNode>;
+    fallbackLabel?: React.ReactNode;
+}
+export declare function DynamicLabel({ value, labelRenderer, fallbackLabel }: DynamicLabelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/shadcn/filters/comboBox.d.ts

@@ -1,16 +1,16 @@
-import { FilterOption } from "./types";
-export declare const SelectionCombobox: ({ filterType, filterValues, setFilterValues, options, }: {
+import { FilterGroupOption, FilterOption } from "./types";
+export declare const SelectionCombobox: ({ filterType, filterValues, setFilterValues, options, labelRenderer, }: {
     filterType: string;
     filterValues: FilterOption[];
     setFilterValues: (filterValues: FilterOption[]) => void;
-    options: FilterOption[];
+    options: FilterGroupOption[];
+    labelRenderer?: (value: string) => React.ReactNode | Promise<React.ReactNode>;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const DateCombobox: ({ filterValues, setFilterValues, }: {
-    filterType: string;
     filterValues: string[];
     setFilterValues: (values: string[]) => void;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const TextCombobox: ({ filterValue, setFilterValue, }: {
+export declare const TextCombobox: ({ filterType, filterValue, setFilterValue, }: {
     filterType: string;
     filterValue: string;
     setFilterValue: (value: string) => void;

package/lib/types/core/components/shadcn/filters/dateFilter.d.ts

@@ -1,14 +1,13 @@
 import React from "react";
-import { DateRange } from "react-day-picker";
 import { Filter, FilterGroup } from "./types";
 interface DateFilterProps {
     selectedView: string | null;
-    dateRange: DateRange | undefined;
-    setDateRange: React.Dispatch<React.SetStateAction<DateRange | undefined>>;
+    selectedDate: Date | undefined;
+    setSelectedDate: React.Dispatch<React.SetStateAction<Date | undefined>>;
     setFilters: React.Dispatch<React.SetStateAction<Filter[]>>;
     filters: Filter[];
     handleClose: () => void;
     filterGroups: FilterGroup[];
 }
-export default function DateFilter({ selectedView, dateRange, setDateRange, setFilters, filters, handleClose, filterGroups, }: DateFilterProps): import("react/jsx-runtime").JSX.Element;
+export default function DateFilter({ selectedView, selectedDate, setSelectedDate, setFilters, filters, handleClose, filterGroups, }: DateFilterProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/lib/types/core/components/shadcn/filters/types.d.ts

@@ -2,13 +2,19 @@ export interface FilterOption {
     label?: React.ReactNode;
     value?: string;
 }
+export interface FilterGroupOption {
+    label?: React.ReactNode;
+    value?: string;
+    labelRenderer?: (value: string) => React.ReactNode | Promise<React.ReactNode>;
+}
 export interface FilterGroup {
     name: string;
     placeholder?: string;
     type?: "select" | "date" | "text";
-    options?: FilterOption[];
+    options?: FilterGroupOption[];
     allowCreate?: boolean;
     filterBy?: (value: string, searchText: string) => boolean;
+    labelRenderer?: (value: string) => React.ReactNode | Promise<React.ReactNode>;
 }
 export interface Filter {
     name: string;

package/lib/types/core/components/shadcn/input.d.ts

@@ -2,15 +2,15 @@ import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const variants: (props?: ({
     size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
-    variant?: "default" | "legacy" | "unstyled" | "noPadding" | null | undefined;
+    variant?: "default" | "unstyled" | "noPadding" | "legacy" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 type InputVariant = "default" | "unstyled" | "noPadding" | "legacy";
-export interface VInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'onChange'> {
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'onChange'> {
     size?: VariantProps<typeof variants>["size"];
     variant?: InputVariant;
     clearable?: boolean;
     value?: string;
     onChange?: (value: string) => void;
 }
-declare const VInput: React.ForwardRefExoticComponent<VInputProps & React.RefAttributes<HTMLInputElement>>;
-export { VInput, };
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input, };

package/lib/types/core/components/shadcn/selectBox.d.ts

@@ -1,8 +1,6 @@
-interface VSelectBoxProps<T> {
+interface VSelectBoxBaseProps<T> {
     options: T[] | undefined;
-    value?: T;
     optionLabel?: (option: T) => React.ReactNode;
-    onChange: (option: T) => void;
     onBlur?: () => void;
     onKeyDown?: (e: React.KeyboardEvent, isOpen: boolean) => void;
     label?: string;
@@ -17,5 +15,16 @@ interface VSelectBoxProps<T> {
     isClearable?: boolean;
     border?: boolean;
 }
-export declare function VSelectBox<T = any>({ options, optionLabel, value, onChange, addNew, addNewLabel, disabled, filterBy, label, placeholder, className, popupClass, isClearable, border }: Readonly<VSelectBoxProps<T>>): import("react/jsx-runtime").JSX.Element;
+interface VSelectBoxSingleProps<T> extends VSelectBoxBaseProps<T> {
+    multiple?: false;
+    value?: T;
+    onChange: (option: T) => void;
+}
+interface VSelectBoxMultipleProps<T> extends VSelectBoxBaseProps<T> {
+    multiple: true;
+    value?: T[];
+    onChange: (options: T[]) => void;
+}
+type VSelectBoxProps<T> = VSelectBoxSingleProps<T> | VSelectBoxMultipleProps<T>;
+export declare function VSelectBox<T = any>({ options, optionLabel, value, onChange, addNew, addNewLabel, disabled, filterBy, label, placeholder, className, popupClass, isClearable, border, multiple, by }: Readonly<VSelectBoxProps<T>>): import("react/jsx-runtime").JSX.Element;
 export {};

package/lib/types/core/components/table/index.d.ts

@@ -10,4 +10,5 @@ interface TBodySkeletonProps {
     children: React.ReactNode;
 }
 export declare function TBody({ isLoading, columns, rows, children }: TBodySkeletonProps): import("react/jsx-runtime").JSX.Element;
+export declare function TR({ className, children, ...others }: React.HTMLProps<HTMLTableRowElement>): import("react/jsx-runtime").JSX.Element;
 export {};

package/lib/types/core/index.d.ts

@@ -1,2 +1,3 @@
-export * from "./hooks/index.js";
 export * from "./components/index.js";
+export * from "./hooks/index.js";
+export * from "./utils/index.js";

package/lib/types/core/utils/cn.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/lib/types/core/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./cn.js";

package/lib/types/features/agent/PayloadBuilder.d.ts

@@ -0,0 +1,53 @@
+import { AsyncExecutionResult, VertesiaClient } from "@vertesia/client";
+import { ExecutionEnvironmentRef, Interaction, JSONSchema } from "@vertesia/common";
+import { JSONObject } from "@vertesia/json";
+import React from "react";
+export interface ConversationWorkflowPayload {
+    interaction?: Interaction | undefined;
+    environment?: ExecutionEnvironmentRef | undefined;
+    model?: string;
+    prompt_data?: JSONObject | undefined;
+    tools: string[];
+}
+export declare class PayloadBuilder implements ConversationWorkflowPayload {
+    vertesia: VertesiaClient;
+    updateState: (data: PayloadBuilder) => void;
+    _interactive: boolean;
+    _start: boolean;
+    payload: ConversationWorkflowPayload;
+    interactionParamsSchema?: JSONSchema | null;
+    private _inputValidator?;
+    constructor(vertesia: VertesiaClient, updateState: (data: PayloadBuilder) => void);
+    onStateChanged(): void;
+    clone(): PayloadBuilder;
+    get interactive(): boolean;
+    set interactive(interactive: boolean);
+    get interaction(): Interaction | undefined;
+    set interaction(interaction: Interaction | undefined);
+    get environment(): ExecutionEnvironmentRef | undefined;
+    set environment(environment: ExecutionEnvironmentRef | undefined);
+    get model(): string | undefined;
+    set model(model: string | undefined);
+    get tools(): string[];
+    set tools(tools: string[]);
+    get prompt_data(): JSONObject | undefined;
+    set prompt_data(prompt_data: JSONObject);
+    set run(run: AsyncExecutionResult | {
+        workflow_id: string;
+        run_id: string;
+    });
+    set start(value: boolean);
+    get start(): boolean;
+    reset(): void;
+    validateInput(): {
+        isValid: boolean;
+        errorMessage?: string;
+    };
+}
+export declare const PayloadContext: React.Context<PayloadBuilder | undefined>;
+interface PayloadProviderProps {
+    children: React.ReactNode;
+}
+export declare function PayloadBuilderProvider({ children }: PayloadProviderProps): import("react/jsx-runtime").JSX.Element | undefined;
+export declare function usePayloadBuilder(): PayloadBuilder;
+export {};

package/lib/types/features/agent/chat/AnimatedThinkingDots.d.ts

@@ -0,0 +1,37 @@
+interface AnimatedThinkingDotsProps {
+    className?: string;
+    inline?: boolean;
+    color?: 'blue' | 'purple' | 'teal' | 'green' | 'amber';
+}
+export declare function AnimatedThinkingDots({ className, inline, color }: AnimatedThinkingDotsProps): import("react/jsx-runtime").JSX.Element;
+interface PulsatingCircleProps {
+    className?: string;
+    size?: 'sm' | 'md' | 'lg';
+    color?: 'blue' | 'purple' | 'teal' | 'green' | 'amber';
+}
+export declare function PulsatingCircle({ className, size, color }: PulsatingCircleProps): import("react/jsx-runtime").JSX.Element;
+interface TypedDotsProps {
+    className?: string;
+    color?: 'blue' | 'purple' | 'teal' | 'green' | 'amber';
+}
+export declare function TypedDots({ className, color }: TypedDotsProps): import("react/jsx-runtime").JSX.Element;
+interface PulsingMessageLoaderProps {
+    message: string;
+    className?: string;
+    color?: 'blue' | 'purple' | 'teal' | 'green' | 'amber';
+}
+export declare function PulsingMessageLoader({ message, className, color }: PulsingMessageLoaderProps): import("react/jsx-runtime").JSX.Element;
+interface ThinkingBarProps {
+    className?: string;
+    color?: 'blue' | 'purple' | 'teal' | 'green' | 'amber';
+    width?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    message?: string;
+}
+export declare function ThinkingBar({ className, color, width, message }: ThinkingBarProps): import("react/jsx-runtime").JSX.Element;
+interface WavyThinkingProps {
+    className?: string;
+    color?: 'blue' | 'purple' | 'teal' | 'green' | 'amber';
+    size?: 'sm' | 'md' | 'lg';
+}
+export declare function WavyThinking({ className, color, size }: WavyThinkingProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/JumpingDots.d.ts

@@ -0,0 +1,6 @@
+interface JumpingDotsProps {
+    className?: string;
+    inline?: boolean;
+}
+export declare function JumpingDots({ className, inline }: JumpingDotsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/ModernAgentConversation.d.ts

@@ -0,0 +1,24 @@
+import { AsyncExecutionResult, VertesiaClient } from "@vertesia/client";
+type StartWorkflowFn = (initialMessage?: string) => Promise<{
+    run_id: string;
+    workflow_id: string;
+} | undefined>;
+interface ModernAgentConversationProps {
+    run?: AsyncExecutionResult | {
+        workflow_id: string;
+        run_id: string;
+    };
+    title?: string;
+    interactive?: boolean;
+    onClose?: () => void;
+    isModal?: boolean;
+    initialMessage?: string;
+    startWorkflow?: StartWorkflowFn;
+    startButtonText?: string;
+    placeholder?: string;
+    hideUserInput?: boolean;
+    resetWorkflow?: () => void;
+}
+export declare function ModernAgentConversation(props: ModernAgentConversationProps): import("react/jsx-runtime").JSX.Element;
+export declare function getConversationUrl(vertesia: VertesiaClient, workflowRunId: string): Promise<string>;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/AllMessagesMixed.d.ts

@@ -0,0 +1,21 @@
+import { AgentMessage, Plan } from "@vertesia/common";
+import React from "react";
+interface AllMessagesMixedProps {
+    messages: AgentMessage[];
+    bottomRef: React.RefObject<HTMLDivElement>;
+    viewMode?: 'stacked' | 'sliding';
+    isCompleted?: boolean;
+    plan?: Plan;
+    workstreamStatus?: Map<string, 'pending' | 'in_progress' | 'completed'>;
+    showPlanPanel?: boolean;
+    onTogglePlanPanel?: () => void;
+    plans?: Array<{
+        plan: Plan;
+        timestamp: number;
+    }>;
+    activePlanIndex?: number;
+    onChangePlan?: (index: number) => void;
+    taskLabels?: Map<string, string>;
+}
+export default function AllMessagesMixed({ messages, bottomRef, viewMode, isCompleted, plan, workstreamStatus, showPlanPanel, onTogglePlanPanel, plans, activePlanIndex, onChangePlan, }: AllMessagesMixedProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/Header.d.ts

@@ -0,0 +1,18 @@
+import { AsyncExecutionResult } from "@vertesia/client";
+interface HeaderProps {
+    title: string;
+    isCompleted: boolean;
+    onClose?: () => void;
+    isModal: boolean;
+    run: AsyncExecutionResult;
+    viewMode: "stacked" | "sliding";
+    onViewModeChange: (mode: "stacked" | "sliding") => void;
+    showPlanPanel: boolean;
+    hasPlan?: boolean;
+    onTogglePlanPanel: () => void;
+    onDownload?: () => void;
+    onCopyRunId?: () => void;
+    resetWorkflow?: () => void;
+}
+export default function Header({ title, onClose, isModal, run, viewMode, onViewModeChange, showPlanPanel, hasPlan, onTogglePlanPanel, onDownload, onCopyRunId, resetWorkflow }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/InlineSlideInPanel.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface InlineSlideInPanelProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    children: React.ReactNode;
+    width?: string;
+}
+export default function InlineSlideInPanel({ isOpen, onClose, title, children, width }: InlineSlideInPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/InlineSlidingPlanPanel.d.ts

@@ -0,0 +1,15 @@
+import { Plan } from "@vertesia/common";
+interface InlinePlanPanelProps {
+    plan: Plan;
+    workstreamStatus: Map<string, "pending" | "in_progress" | "completed">;
+    isOpen: boolean;
+    onClose: () => void;
+    plans?: Array<{
+        plan: Plan;
+        timestamp: number;
+    }>;
+    activePlanIndex?: number;
+    onChangePlan?: (index: number) => void;
+}
+export default function InlineSlidingPlanPanel({ plan, workstreamStatus, isOpen, onClose, plans, activePlanIndex, onChangePlan, }: InlinePlanPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/MessageInput.d.ts

@@ -0,0 +1,12 @@
+interface MessageInputProps {
+    value: string;
+    onChange: (v: string) => void;
+    onSend: () => void;
+    disabled?: boolean;
+    isSending?: boolean;
+    isCompleted?: boolean;
+    activeTaskCount?: number;
+    placeholder?: string;
+}
+export default function MessageInput({ value, onChange, onSend, disabled, isSending, isCompleted, activeTaskCount, placeholder }: MessageInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/MessageItem.d.ts

@@ -0,0 +1,7 @@
+import { AgentMessage } from "@vertesia/common";
+interface MessageItemProps {
+    message: AgentMessage;
+    showPulsatingCircle?: boolean;
+}
+export default function MessageItem({ message, showPulsatingCircle }: MessageItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/MessagesContainer.d.ts

@@ -0,0 +1,9 @@
+import { AgentMessage } from "@vertesia/common";
+import React from "react";
+interface MessagesContainerProps {
+    messages: AgentMessage[];
+    isCompleted: boolean;
+    bottomRef: React.RefObject<HTMLDivElement>;
+}
+export default function MessagesContainer({ messages, bottomRef }: MessagesContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/PlanPanel.d.ts

@@ -0,0 +1,8 @@
+import { Plan } from "@vertesia/common";
+interface PlanPanelProps {
+    plan: Plan;
+    workstreamStatus: Map<string, "pending" | "in_progress" | "completed">;
+    isVisible: boolean;
+}
+export default function PlanPanel({ plan, workstreamStatus, isVisible }: PlanPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/SlideInPanel.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface SlideInPanelProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    children: React.ReactNode;
+    width?: string;
+}
+export default function SlideInPanel({ isOpen, onClose, title, children, width }: SlideInPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/SlidingMessages.d.ts

@@ -0,0 +1,7 @@
+import { AgentMessage } from "@vertesia/common";
+interface SlidingMessagesProps {
+    messages: AgentMessage[];
+    isCompleted: boolean;
+}
+export default function SlidingMessages({ messages, isCompleted }: SlidingMessagesProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/SlidingPlanPanel.d.ts

@@ -0,0 +1,9 @@
+import { Plan } from "@vertesia/common";
+interface PlanPanelProps {
+    plan?: Plan;
+    workstreamStatus: Map<string, "pending" | "in_progress" | "completed">;
+    isOpen: boolean;
+    onClose: () => void;
+}
+export default function SlidingPlanPanel({ plan, workstreamStatus, isOpen, onClose }: PlanPanelProps): import("react/jsx-runtime").JSX.Element | undefined;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/StackedMessages.d.ts

@@ -0,0 +1,7 @@
+import { AgentMessage } from "@vertesia/common";
+interface StackedMessagesProps {
+    messages: AgentMessage[];
+    isCompleted: boolean;
+}
+export default function StackedMessages({ messages }: StackedMessagesProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/WorkstreamTabs.d.ts

@@ -0,0 +1,21 @@
+import { AgentMessage } from "@vertesia/common";
+interface WorkstreamTabsProps {
+    workstreams: Map<string, string>;
+    activeWorkstream: string;
+    onSelectWorkstream: (id: string) => void;
+    count?: Map<string, number>;
+    completionStatus?: Map<string, boolean>;
+}
+/**
+ * Component that displays tabs for different workstreams
+ */
+export default function WorkstreamTabs({ workstreams, activeWorkstream, onSelectWorkstream, count, completionStatus, }: WorkstreamTabsProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Helper function to extract workstream information from messages
+ */
+export declare function extractWorkstreams(messages: AgentMessage[]): Map<string, string>;
+/**
+ * Filter messages by workstream
+ */
+export declare function filterMessagesByWorkstream(messages: AgentMessage[], workstreamId: string): AgentMessage[];
+export {};

package/lib/types/features/agent/chat/ModernAgentOutput/utils.d.ts

@@ -0,0 +1,23 @@
+import { AgentMessage } from "@vertesia/common";
+import { VertesiaClient } from "@vertesia/client";
+export declare function insertMessageInTimeline(arr: AgentMessage[], m: AgentMessage): void;
+/**
+ * Check if a conversation is still in progress
+ * This function checks the main workstream status to determine if the conversation is complete
+ * For multi-workstream scenarios, we keep streaming until the main workstream is complete
+ */
+export declare function isInProgress(messages: AgentMessage[]): boolean;
+export declare const formatRelative: (ts: number | string) => string;
+/**
+ * Extract the workstream ID from a message
+ * @param message The agent message to analyze
+ * @returns The workstream ID (defaults to 'main' if none found)
+ */
+export declare function getWorkstreamId(message: AgentMessage): string;
+/**
+ * Get a map of workstream IDs to their completion status
+ * @param messages List of agent messages
+ * @returns Map of workstream IDs to completion status ('pending', 'in_progress', or 'completed')
+ */
+export declare function getWorkstreamStatusMap(messages: AgentMessage[]): Map<string, "pending" | "in_progress" | "completed">;
+export declare function getConversationUrl(vertesia: VertesiaClient, workflowRunId: string): Promise<string>;

package/lib/types/features/agent/chat/SlidingThinkingIndicator.d.ts

@@ -0,0 +1,17 @@
+import { AgentMessage } from "@vertesia/common";
+import React from "react";
+interface SlidingThinkingIndicatorProps {
+    messages: AgentMessage[];
+    isCompleted: boolean;
+    thinkingMessageIndex: number;
+    className?: string;
+    renderMessage?: (message: AgentMessage) => React.ReactNode;
+    showDetails?: boolean;
+    onShowDetailsChange?: (show: boolean) => void;
+}
+export declare function SlidingThinkingIndicator({ messages, isCompleted, thinkingMessageIndex, className, renderMessage, showDetails: externalShowDetails, onShowDetailsChange, }: SlidingThinkingIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function isThinkingMessage(message: AgentMessage): boolean;
+export declare function isPermanentMessage(message: AgentMessage): boolean;
+export declare function getThinkingMessages(messages: AgentMessage[]): AgentMessage[];
+export declare function getPermanentMessages(messages: AgentMessage[]): AgentMessage[];
+export {};

package/lib/types/features/agent/chat/WaitingMessages.d.ts

@@ -0,0 +1 @@
+export declare const ThinkingMessages: string[];