@ash-cloud/ash-ui 0.1.0 → 0.2.0

package/dist/types.d.ts

@@ -287,20 +287,6 @@ interface NormalizedEntry {
     entryType: NormalizedEntryType;
     /** Text content for display (plain text or markdown) */
     content: string;
-    /**
-     * Rich content segments (structured approach - preferred over regex transformers).
-     * When provided, this takes precedence over `content` for rendering.
-     *
-     * @example
-     * ```ts
-     * richContent: [
-     *   { type: 'text', content: 'Analyzing ' },
-     *   { type: 'mention', name: 'Scene1', color: '#ff0' },
-     *   { type: 'text', content: ' for transitions.' },
-     * ]
-     * ```
-     */
-    richContent?: RichContent;
 }
 declare function isCommandRunAction(action: ActionType): action is CommandRunAction;
 declare function isFileReadAction(action: ActionType): action is FileReadAction;
@@ -384,134 +370,224 @@ interface FileAttachment {
     base64: string;
 }
 /**
- * Display mode for tool calls in the chat interface
+ * Message visual style variant
  *
- * - 'inline': Each tool call rendered inline as expandable cards (current behavior)
- * - 'compact': Single animated status line that updates with each tool call,
- *   with accordion to expand and see execution details. Text streams unbroken.
- * - 'accordion': Simpler step-based accordion list that accumulates tool calls
- *   with icons, labels, and durations (like Vidra's ThinkingIndicator).
- */
-type ToolDisplayMode = 'inline' | 'compact' | 'accordion';
-/**
- * Configuration for tool display behavior
- */
-interface ToolDisplayConfig {
-    /**
-     * Display mode for tool calls
-     * @default 'inline'
-     */
-    mode: ToolDisplayMode;
-    /**
-     * For 'compact' mode: break into a new group every N tool calls
-     * Set to 0 or undefined to never break (all tool calls in single group)
-     * @default 0
-     */
-    breakEveryNToolCalls?: number;
-    /**
-     * Whether tool call groups start expanded
-     * @default false
-     */
-    defaultExpanded?: boolean;
-    /**
-     * Animation duration for status line transitions (ms)
-     * @default 300
-     */
-    animationDuration?: number;
-}
-/**
- * Default display configuration
- */
-declare const DEFAULT_DISPLAY_CONFIG: ToolDisplayConfig;
-/**
- * A text segment within rich content
- */
-interface RichTextSegment {
-    type: 'text';
-    /** Plain text or markdown content */
-    content: string;
-}
+ * - 'bubble': Rounded card with padding and background (default for user messages)
+ * - 'plain': No background, just text with subtle styling
+ * - 'minimal': Bare text, no decoration
+ */
+type MessageVariant = 'bubble' | 'plain' | 'minimal';
 /**
- * A mention/reference segment within rich content
+ * Typography scale/density preset
+ *
+ * - 'dense': Minimal spacing, smallest fonts (12px base) - for maximum information density
+ * - 'compact': Tighter spacing, smaller fonts (13px base)
+ * - 'default': Standard sizing (14px base)
+ * - 'comfortable': More generous spacing (15px base)
  */
-interface RichMentionSegment {
-    type: 'mention';
-    /** The mentioned entity name */
-    name: string;
-    /** Optional identifier for the entity */
-    id?: string;
-    /** Optional color for styling */
-    color?: string;
-    /** Optional additional data */
-    data?: Record<string, unknown>;
-}
+type TypographyScale = 'dense' | 'compact' | 'default' | 'comfortable';
 /**
- * A custom component segment within rich content
+ * Message role for data attribute targeting
  */
-interface RichComponentSegment {
-    type: 'component';
-    /** Component type identifier (consumer handles rendering) */
-    componentType: string;
-    /** Props to pass to the component */
-    props: Record<string, unknown>;
+type MessageRole = 'user' | 'assistant' | 'thinking' | 'tool' | 'error' | 'widget';
+/**
+ * Metadata to display with a message
+ */
+interface MessageMetadata {
+    /** Timestamp to display */
+    timestamp?: string;
+    /** Model name/info to display */
+    model?: string;
+    /** Custom label */
+    label?: string;
+    /** Any additional metadata */
+    extra?: Record<string, unknown>;
 }
 /**
- * Union of all rich content segment types
+ * Function to render custom message metadata
  */
-type RichContentSegment = RichTextSegment | RichMentionSegment | RichComponentSegment;
+type RenderMetadataFunction = (props: {
+    entry: NormalizedEntry;
+    metadata?: MessageMetadata;
+}) => ReactNode;
 /**
- * Rich content array - the preferred way to send structured content
+ * Custom markdown component overrides
  *
  * @example
- * ```ts
- * const content: RichContent = [
- *   { type: 'text', content: 'Looking at ' },
- *   { type: 'mention', name: 'Scene1', color: '#ff0', id: 'seq-1' },
- *   { type: 'text', content: ' timeline for the transition.' },
- * ];
+ * ```tsx
+ * const components: MarkdownComponents = {
+ *   h2: ({ children }) => <h2 className="custom-h2">{children}</h2>,
+ *   code: ({ children, className }) => <CustomCode className={className}>{children}</CustomCode>,
+ * };
  * ```
  */
-type RichContent = RichContentSegment[];
+interface MarkdownComponents {
+    h1?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    h2?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    h3?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    h4?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    h5?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    h6?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    p?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    a?: React.ComponentType<{
+        children?: ReactNode;
+        href?: string;
+    }>;
+    ul?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    ol?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    li?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    code?: React.ComponentType<{
+        children?: ReactNode;
+        className?: string;
+    }>;
+    pre?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    blockquote?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    strong?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    em?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    hr?: React.ComponentType<Record<string, never>>;
+    img?: React.ComponentType<{
+        src?: string;
+        alt?: string;
+    }>;
+    table?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    thead?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    tbody?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    tr?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    th?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+    td?: React.ComponentType<{
+        children?: ReactNode;
+    }>;
+}
+/**
+ * Style configuration for message display
+ */
+interface MessageStyleConfig {
+    /** Variant for user messages */
+    userVariant?: MessageVariant;
+    /** Variant for assistant messages */
+    assistantVariant?: MessageVariant;
+    /** Typography/density scale */
+    scale?: TypographyScale;
+    /** Show timestamps with messages */
+    showTimestamp?: boolean;
+    /** Show avatars */
+    showAvatars?: boolean;
+    /** Custom class name for messages */
+    messageClassName?: string;
+}
+/**
+ * Default style configuration
+ */
+declare const DEFAULT_STYLE_CONFIG: MessageStyleConfig;
+/**
+ * Tool invocation status - matches AI SDK ToolInvocation
+ */
+type ToolInvocationState = 'partial-call' | 'call' | 'result';
+/**
+ * Tool invocation - matches AI SDK ToolInvocation type
+ */
+interface ToolInvocation {
+    /** Tool invocation state */
+    state: ToolInvocationState;
+    /** Unique tool call ID */
+    toolCallId: string;
+    /** Tool name */
+    toolName: string;
+    /** Arguments passed to the tool (parsed JSON) */
+    args: Record<string, unknown>;
+    /** Result from tool execution (only present when state is 'result') */
+    result?: unknown;
+}
+/**
+ * AI SDK message role - matches AI SDK Message role
+ */
+type AIMessageRole = 'user' | 'assistant' | 'system' | 'data';
 /**
- * Props for rendering a mention segment
+ * AI SDK compatible message type
+ * This is the primary type used by the new useChat hook
  */
-interface MentionRenderProps {
-    segment: RichMentionSegment;
+interface Message {
+    /** Unique message ID */
+    id: string;
+    /** Message role */
+    role: AIMessageRole;
+    /** Message content (text) */
+    content: string;
+    /** Tool invocations for this message */
+    toolInvocations?: ToolInvocation[];
+    /** When the message was created */
+    createdAt?: Date;
+    /** Optional reasoning/thinking content */
+    reasoning?: string;
+    /** Experimental attachments (for file uploads) */
+    experimental_attachments?: MessageAttachment[];
 }
 /**
- * Props for rendering a custom component segment
+ * Message attachment for file uploads
  */
-interface ComponentRenderProps {
-    segment: RichComponentSegment;
+interface MessageAttachment {
+    /** Attachment name */
+    name: string;
+    /** MIME type */
+    contentType: string;
+    /** URL to the attachment */
+    url: string;
 }
 /**
- * Custom render functions for rich content segments
+ * Convert a NormalizedEntry to an AI SDK Message
  */
-interface RichContentRenderers {
-    /**
-     * Render a mention segment. If not provided, renders as styled badge.
-     */
-    renderMention?: (props: MentionRenderProps) => ReactNode;
-    /**
-     * Render a custom component segment.
-     */
-    renderComponent?: (props: ComponentRenderProps) => ReactNode;
-}
+declare function normalizedEntryToMessage(entry: NormalizedEntry): Message | null;
 /**
- * A group of consecutive tool calls that are displayed together
- * in compact mode. Text content before/after flows around the group.
+ * Convert an AI SDK Message to a NormalizedEntry
  */
-interface ToolExecutionGroup {
-    /** Unique ID for the group */
-    id: string;
-    /** Tool calls in this group (in order) */
-    toolCalls: NormalizedToolCall[];
-    /** Index of the currently active/latest tool call for status display */
-    activeIndex: number;
-    /** Whether all tool calls in this group have completed */
-    isComplete: boolean;
-    /** Overall status of the group */
-    status: 'pending' | 'success' | 'partial_failure' | 'failed';
-}
+declare function messageToNormalizedEntry(message: Message): NormalizedEntry;
+/**
+ * Convert an array of NormalizedEntry to AI SDK Messages
+ * Merges consecutive assistant entries (text + tool calls) into single messages
+ */
+declare function normalizedEntriesToMessages(entries: NormalizedEntry[]): Message[];
+/**
+ * Convert AI SDK Messages back to NormalizedEntry array
+ * Expands tool invocations into separate entries
+ */
+declare function messagesToNormalizedEntries(messages: Message[]): NormalizedEntry[];
 
-export { type ActionType, type AgentToolAction, type AssistantMessageEntry, type CommandRunAction, type CommandRunResult, type ComponentRenderProps, DEFAULT_DISPLAY_CONFIG, type ErrorEntry, type FileAttachment, type FileEditAction, type FileReadAction, type FileWriteAction, type GenericToolAction, type GlobAction, type LogCategory, type LogEntry, type LogLevel, type McpToolAction, type MentionRenderProps, type NormalizedEntry, type NormalizedEntryType, type NormalizedToolCall, type RichComponentSegment, type RichContent, type RichContentRenderers, type RichContentSegment, type RichMentionSegment, type RichTextSegment, type SearchAction, type ThinkingEntry, type TodoItem, type TodoStatus, type TodoWriteAction, type ToolCallEntry, type ToolDisplayConfig, type ToolDisplayMode, type ToolExecutionGroup, type ToolResult, type ToolStatus, type UserMessageEntry, type WebFetchAction, type WebSearchAction, type WidgetAction, type WidgetEntry, type WidgetRenderFunction, type WidgetRenderProps, isAgentToolAction, isCommandRunAction, isErrorEntry, isFileEditAction, isFileReadAction, isFileWriteAction, isGenericToolAction, isGlobAction, isMcpToolAction, isSearchAction, isTodoWriteAction, isToolCallEntry, isWebFetchAction, isWebSearchAction, isWidgetEntry };
+export { type AIMessageRole, type ActionType, type AgentToolAction, type AssistantMessageEntry, type CommandRunAction, type CommandRunResult, DEFAULT_STYLE_CONFIG, type ErrorEntry, type FileAttachment, type FileEditAction, type FileReadAction, type FileWriteAction, type GenericToolAction, type GlobAction, type LogCategory, type LogEntry, type LogLevel, type MarkdownComponents, type McpToolAction, type Message, type MessageAttachment, type MessageMetadata, type MessageRole, type MessageStyleConfig, type MessageVariant, type NormalizedEntry, type NormalizedEntryType, type NormalizedToolCall, type RenderMetadataFunction, type SearchAction, type ThinkingEntry, type TodoItem, type TodoStatus, type TodoWriteAction, type ToolCallEntry, type ToolInvocation, type ToolInvocationState, type ToolResult, type ToolStatus, type TypographyScale, type UserMessageEntry, type WebFetchAction, type WebSearchAction, type WidgetAction, type WidgetEntry, type WidgetRenderFunction, type WidgetRenderProps, isAgentToolAction, isCommandRunAction, isErrorEntry, isFileEditAction, isFileReadAction, isFileWriteAction, isGenericToolAction, isGlobAction, isMcpToolAction, isSearchAction, isTodoWriteAction, isToolCallEntry, isWebFetchAction, isWebSearchAction, isWidgetEntry, messageToNormalizedEntry, messagesToNormalizedEntries, normalizedEntriesToMessages, normalizedEntryToMessage };

package/dist/types.js

@@ -44,13 +44,246 @@ function isErrorEntry(entry) {
 function isWidgetEntry(entry) {
   return entry.type === "widget";
 }
-var DEFAULT_DISPLAY_CONFIG = {
-  mode: "inline",
-  breakEveryNToolCalls: 0,
-  defaultExpanded: false,
-  animationDuration: 300
+var DEFAULT_STYLE_CONFIG = {
+  userVariant: "bubble",
+  assistantVariant: "bubble",
+  scale: "compact",
+  showTimestamp: true,
+  showAvatars: true
 };
+function normalizedEntryToMessage(entry) {
+  const { id, entryType, content, timestamp } = entry;
+  const createdAt = timestamp ? new Date(timestamp) : void 0;
+  switch (entryType.type) {
+    case "user_message":
+      return {
+        id,
+        role: "user",
+        content,
+        createdAt
+      };
+    case "assistant_message":
+      return {
+        id,
+        role: "assistant",
+        content,
+        createdAt
+      };
+    case "thinking":
+      return {
+        id,
+        role: "assistant",
+        content: "",
+        reasoning: content,
+        createdAt
+      };
+    case "tool_call": {
+      const { toolCall } = entryType;
+      const toolInvocation = {
+        state: toolCall.status === "pending" ? "call" : "result",
+        toolCallId: toolCall.id,
+        toolName: toolCall.toolName,
+        args: toolCall.input || {},
+        result: toolCall.output
+      };
+      return {
+        id,
+        role: "assistant",
+        content: "",
+        toolInvocations: [toolInvocation],
+        createdAt
+      };
+    }
+    case "error":
+      return {
+        id,
+        role: "system",
+        content: `Error: ${entryType.message}${entryType.code ? ` (${entryType.code})` : ""}`,
+        createdAt
+      };
+    case "widget":
+      return {
+        id,
+        role: "data",
+        content: JSON.stringify({
+          widgetType: entryType.widgetType,
+          widgetData: entryType.widgetData
+        }),
+        createdAt
+      };
+    default:
+      return null;
+  }
+}
+function messageToNormalizedEntry(message) {
+  const { id, role, content, createdAt, toolInvocations, reasoning } = message;
+  const timestamp = createdAt?.toISOString();
+  if (toolInvocations && toolInvocations.length > 0) {
+    const inv = toolInvocations[0];
+    const toolCall = {
+      id: inv.toolCallId,
+      toolName: inv.toolName,
+      actionType: {
+        action: "generic_tool",
+        toolName: inv.toolName,
+        arguments: inv.args,
+        result: inv.result ? { type: "json", value: inv.result } : void 0
+      },
+      status: inv.state === "result" ? "success" : "pending",
+      summary: `${inv.toolName}(${Object.keys(inv.args).join(", ")})`,
+      input: inv.args,
+      output: inv.result
+    };
+    return {
+      id,
+      timestamp,
+      entryType: { type: "tool_call", toolCall },
+      content: toolCall.summary
+    };
+  }
+  if (reasoning) {
+    return {
+      id,
+      timestamp,
+      entryType: { type: "thinking" },
+      content: reasoning
+    };
+  }
+  if (role === "user") {
+    return {
+      id,
+      timestamp,
+      entryType: { type: "user_message" },
+      content
+    };
+  }
+  if (role === "assistant") {
+    return {
+      id,
+      timestamp,
+      entryType: { type: "assistant_message" },
+      content
+    };
+  }
+  if (role === "system") {
+    if (content.startsWith("Error:")) {
+      return {
+        id,
+        timestamp,
+        entryType: { type: "error", message: content.replace("Error: ", "") },
+        content
+      };
+    }
+    return {
+      id,
+      timestamp,
+      entryType: { type: "assistant_message" },
+      content
+    };
+  }
+  if (role === "data") {
+    try {
+      const data = JSON.parse(content);
+      if (data.widgetType) {
+        return {
+          id,
+          timestamp,
+          entryType: {
+            type: "widget",
+            widgetType: data.widgetType,
+            widgetData: data.widgetData
+          },
+          content: ""
+        };
+      }
+    } catch {
+    }
+    return {
+      id,
+      timestamp,
+      entryType: { type: "assistant_message" },
+      content
+    };
+  }
+  return {
+    id,
+    timestamp,
+    entryType: { type: "assistant_message" },
+    content
+  };
+}
+function normalizedEntriesToMessages(entries) {
+  const messages = [];
+  let currentAssistantMessage = null;
+  for (const entry of entries) {
+    const message = normalizedEntryToMessage(entry);
+    if (!message) continue;
+    if (message.role === "assistant") {
+      if (currentAssistantMessage) {
+        if (message.toolInvocations) {
+          currentAssistantMessage.toolInvocations = [
+            ...currentAssistantMessage.toolInvocations || [],
+            ...message.toolInvocations
+          ];
+        }
+        if (message.content) {
+          currentAssistantMessage.content = currentAssistantMessage.content ? `${currentAssistantMessage.content}
+${message.content}` : message.content;
+        }
+        if (message.reasoning) {
+          currentAssistantMessage.reasoning = currentAssistantMessage.reasoning ? `${currentAssistantMessage.reasoning}
+${message.reasoning}` : message.reasoning;
+        }
+      } else {
+        currentAssistantMessage = { ...message };
+      }
+    } else {
+      if (currentAssistantMessage) {
+        messages.push(currentAssistantMessage);
+        currentAssistantMessage = null;
+      }
+      messages.push(message);
+    }
+  }
+  if (currentAssistantMessage) {
+    messages.push(currentAssistantMessage);
+  }
+  return messages;
+}
+function messagesToNormalizedEntries(messages) {
+  const entries = [];
+  for (const message of messages) {
+    if (message.reasoning) {
+      entries.push({
+        id: `${message.id}-thinking`,
+        timestamp: message.createdAt?.toISOString(),
+        entryType: { type: "thinking" },
+        content: message.reasoning
+      });
+    }
+    if (message.content || !message.toolInvocations?.length) {
+      entries.push(messageToNormalizedEntry({
+        ...message,
+        toolInvocations: void 0,
+        reasoning: void 0
+      }));
+    }
+    if (message.toolInvocations) {
+      for (const inv of message.toolInvocations) {
+        const toolMessage = {
+          id: inv.toolCallId,
+          role: "assistant",
+          content: "",
+          toolInvocations: [inv],
+          createdAt: message.createdAt
+        };
+        entries.push(messageToNormalizedEntry(toolMessage));
+      }
+    }
+  }
+  return entries;
+}
 
-export { DEFAULT_DISPLAY_CONFIG, isAgentToolAction, isCommandRunAction, isErrorEntry, isFileEditAction, isFileReadAction, isFileWriteAction, isGenericToolAction, isGlobAction, isMcpToolAction, isSearchAction, isTodoWriteAction, isToolCallEntry, isWebFetchAction, isWebSearchAction, isWidgetEntry };
+export { DEFAULT_STYLE_CONFIG, isAgentToolAction, isCommandRunAction, isErrorEntry, isFileEditAction, isFileReadAction, isFileWriteAction, isGenericToolAction, isGlobAction, isMcpToolAction, isSearchAction, isTodoWriteAction, isToolCallEntry, isWebFetchAction, isWebSearchAction, isWidgetEntry, messageToNormalizedEntry, messagesToNormalizedEntries, normalizedEntriesToMessages, normalizedEntryToMessage };
 //# sourceMappingURL=types.js.map
 //# sourceMappingURL=types.js.map