@parallelworks/ui 0.18.0 → 0.19.0

package/dist/ai/adapter/types.d.ts

@@ -0,0 +1,131 @@
+import type { Allocation, ApprovalPart, AttachmentRef, ChatModel, Conversation, ConversationSummary, ProviderInfo, ShareGroup, SharePermission, SharePermissionLevel, TodoItem, ToolCall, UnreachableSession } from '../types.js';
+import type { CompletionMessage } from './openai/wire.js';
+export declare class ChatAdapterError extends Error {
+    status?: number | undefined;
+    constructor(message: string, options?: {
+        status?: number;
+        cause?: unknown;
+    });
+}
+export interface ModelsList {
+    models: ChatModel[];
+    unreachableSessions: UnreachableSession[];
+}
+export interface StreamRequest {
+    model: string;
+    messages: CompletionMessage[];
+    conversationId: string;
+    parentMessageId?: string | null;
+    userMessageId: string;
+    allocation?: string | null;
+    useResponses?: boolean;
+}
+export interface StreamHandlers {
+    onContent: (content: string) => void;
+    onReasoning?: (reasoning: string) => void;
+    onMessageId?: (messageId: string) => void;
+    onPart?: (delta: PartDelta) => void;
+}
+export type PartDelta = {
+    type: 'tool_start';
+    id: string;
+    name: string;
+    args: string;
+    startLine?: number;
+} | {
+    type: 'tool_update';
+    id: string;
+    args: string;
+} | {
+    type: 'tool_end';
+    id: string;
+    result: string;
+    isError?: boolean;
+} | {
+    type: 'subagent_start';
+    id: string;
+    agentType?: string;
+    color?: string;
+    background?: boolean;
+    description?: string;
+} | {
+    type: 'subagent_action';
+    id: string;
+    action: string;
+} | {
+    type: 'subagent_end';
+    id: string;
+    ok: boolean;
+    summary?: string;
+    report?: string;
+} | {
+    type: 'approval_request';
+    approval: ApprovalPart;
+} | {
+    type: 'approval_resolved';
+    id: string;
+    answer?: string;
+} | {
+    type: 'notice' | 'warning';
+    text: string;
+} | {
+    type: 'todo_snapshot';
+    todos: TodoItem[];
+};
+export interface StreamResult {
+    content: string;
+    messageId: string;
+    toolCalls: ToolCall[];
+    finishReason: string | null;
+    model: string | null;
+    reasoning: string;
+    responsesOutput: unknown[];
+}
+export type StreamCompletion = (req: StreamRequest, handlers: StreamHandlers, signal?: AbortSignal) => Promise<StreamResult>;
+export interface ConversationsAdapter {
+    list(): Promise<ConversationSummary[]>;
+    get(id: string): Promise<Conversation>;
+    create(title?: string): Promise<ConversationSummary>;
+    rename(id: string, title: string): Promise<void>;
+    remove(id: string): Promise<void>;
+}
+export interface ProvidersAdapter {
+    list(): Promise<ProviderInfo[]>;
+}
+export interface AttachmentPage {
+    attachments: AttachmentRef[];
+    total: number;
+    nextCursor?: string;
+    hasMore: boolean;
+}
+export interface AttachmentsAdapter {
+    list(opts: {
+        limit: number;
+        cursor?: string;
+    }): Promise<AttachmentPage>;
+    upload(file: File, conversationId?: string): Promise<AttachmentRef>;
+    remove(id: string): Promise<void>;
+    downloadUrl(id: string): string;
+    onOpen?(attachment: AttachmentRef): void;
+}
+export interface SharingAdapter {
+    listPermissions(conversationId: string): Promise<SharePermission[]>;
+    listGroups(): Promise<ShareGroup[]>;
+    addPermission(conversationId: string, permission: Omit<SharePermission, 'id' | 'teamName'>): Promise<void>;
+    updatePermission(conversationId: string, permissionId: string, permission: SharePermissionLevel): Promise<void>;
+    removePermission(conversationId: string, permissionId: string): Promise<void>;
+}
+export interface AllocationsAdapter {
+    list(): Promise<Allocation[]>;
+}
+export interface ChatAdapter {
+    conversations: ConversationsAdapter;
+    models: {
+        list(): Promise<ModelsList>;
+    };
+    streamCompletion: StreamCompletion;
+    providers?: ProvidersAdapter;
+    attachments?: AttachmentsAdapter;
+    sharing?: SharingAdapter;
+    allocations?: AllocationsAdapter;
+}

package/dist/ai/agent/classifier.d.ts

@@ -0,0 +1,2 @@
+import type { PseudoUserKind } from '../types.js';
+export declare function classifyPseudoUserMessage(role: string, content: string | null | undefined): PseudoUserKind | null;

package/dist/ai/agent/diff.d.ts

@@ -0,0 +1,35 @@
+export declare const MAX_EDIT_DIFF_LINES = 100;
+export declare const MAX_WRITE_DIFF_LINES = 50;
+export declare const DIFF_CONTEXT = 3;
+export interface EditToolArgs {
+    path?: string;
+    old_string?: string;
+    new_string?: string;
+    content?: string;
+    replace_all?: boolean;
+}
+export declare function isEditDiffTool(name: string): boolean;
+export declare function parseEditArgs(argsJSON: string): EditToolArgs | null;
+export declare function wordEmphasisRanges(oldLine: string, newLine: string): Array<[number, number]> | null;
+export declare function lineDelta(oldLines: string[], newLines: string[]): [number, number];
+export interface DiffRow {
+    kind: 'add' | 'del' | 'ctx' | 'gap';
+    oldNo?: number;
+    newNo?: number;
+    text: string;
+    emphasis?: Array<[number, number]>;
+}
+export interface EditDiffModel {
+    rows: DiffRow[];
+    added: number;
+    removed: number;
+    truncated: boolean;
+}
+export declare function computeEditDiff(oldString: string, newString: string, startLine?: number): EditDiffModel;
+export interface WriteModel {
+    rows: DiffRow[];
+    total: number;
+    truncated: boolean;
+}
+export declare function computeWriteRows(content: string): WriteModel;
+export declare function editSummary(toolName: string, argsJSON: string): string;

package/dist/ai/agent/diffHighlight.d.ts

@@ -0,0 +1,6 @@
+export interface DiffToken {
+    content: string;
+    color?: string;
+}
+export declare function languageForPath(path: string | undefined): string | null;
+export declare function tokenizeDiffLines(lines: string[], lang: string, isDark: boolean): Promise<DiffToken[][] | null>;

package/dist/ai/agent/index.d.ts

@@ -0,0 +1,6 @@
+export { classifyPseudoUserMessage } from './classifier.js';
+export { computeEditDiff, computeWriteRows, type DiffRow, type EditDiffModel, type EditToolArgs, editSummary, isEditDiffTool, lineDelta, MAX_EDIT_DIFF_LINES, MAX_WRITE_DIFF_LINES, parseEditArgs, type WriteModel, wordEmphasisRanges, } from './diff.js';
+export { type DiffToken, languageForPath, tokenizeDiffLines, } from './diffHighlight.js';
+export { clampPermissionMode, DEFAULT_PERMISSION_MODE, isNamedPermissionMode, NAMED_PERMISSION_MODES, type NamedPermissionMode, type PermissionMode, permissionModesUpTo, } from './permissions.js';
+export { AGENT_COLOR_NAMES, agentColorHex, bashExitCode, clip, fullToolArgs, isGroupableTool, plural, resultFailed, rollupSentence, sanitizeLabel, sanitizePanelText, summarizeToolArgs, type ToolHeader, toolHeaderFor, toolSummary, } from './toolfmt.js';
+export { agentTypeLabel, askQuestionFromArgs, firstNonEmptyLine, hiddenTranscriptTool, INTERRUPTED_NOTICE, interruptionNotice, parseSubagentNotice, planFromArgs, type SubagentNotice, subagentDeliveryLine, taskCallFromArgs, thinkingHeading, } from './transcript.js';

package/dist/ai/agent/permissions.d.ts

@@ -0,0 +1,11 @@
+declare const REQUESTABLE_PERMISSION_MODES: readonly ['read-only', 'accept-edits', 'bypass-permissions'];
+export declare const NAMED_PERMISSION_MODES: readonly ["read-only", "accept-edits", "bypass-permissions", "plan"];
+export type PermissionMode = (typeof REQUESTABLE_PERMISSION_MODES)[number];
+export type NamedPermissionMode = (typeof NAMED_PERMISSION_MODES)[number];
+export declare const DEFAULT_PERMISSION_MODE: PermissionMode;
+export declare function isNamedPermissionMode(mode: string | undefined): mode is NamedPermissionMode;
+/** The daemon clamps a remote request to its owner's remoteMaxPermissionMode,
+ *  so a menu offers only what that machine will honour. */
+export declare function permissionModesUpTo(ceiling: string | undefined): PermissionMode[];
+export declare function clampPermissionMode(mode: PermissionMode, ceiling: string | undefined): PermissionMode;
+export {};

package/dist/ai/agent/toolfmt.d.ts

@@ -0,0 +1,18 @@
+export interface ToolHeader {
+    label: string;
+    arg?: string;
+}
+export declare function toolHeaderFor(name: string): ToolHeader;
+export declare function clip(s: string, max: number): string;
+export declare function sanitizeLabel(s: string): string;
+export declare function sanitizePanelText(s: string): string;
+export declare function summarizeToolArgs(primary: string | undefined, argsJSON: string): string;
+export declare function fullToolArgs(primary: string | undefined, argsJSON: string): string;
+export declare function plural(n: number, noun: string): string;
+export declare function resultFailed(name: string, result: string): boolean;
+export declare function bashExitCode(body: string): [string, number, boolean];
+export declare function toolSummary(name: string, args: string, result: string, isError: boolean, editSummaryFn?: (toolName: string, argsJSON: string) => string): string;
+export declare function isGroupableTool(name: string): boolean;
+export declare function rollupSentence(names: string[]): string;
+export declare const AGENT_COLOR_NAMES: readonly ['blue', 'green', 'yellow', 'purple', 'cyan', 'orange', 'pink', 'red'];
+export declare function agentColorHex(name: string | undefined): string | null;

package/dist/ai/agent/transcript.d.ts

@@ -0,0 +1,38 @@
+export declare function hiddenTranscriptTool(name: string): boolean;
+export declare function askQuestionFromArgs(argsJSON: string): string;
+export declare function planFromArgs(argsJSON: string): string;
+/** A Task call's display label the way the tool itself picks it: the
+ *  description, else the clipped prompt, plus its custom agent type. */
+export declare function taskCallFromArgs(argsJSON: string): {
+    description: string;
+    agentType: string;
+};
+/** The built-in "default" type is the same general-purpose agent an untyped
+ *  Task spawns, so naming it would only add noise. */
+export declare function agentTypeLabel(t: string): string;
+/** The first line when the model wrote it as a heading ("# Title" or
+ *  "**Title**"), the way reasoning summaries open, so a folded thought says
+ *  what it was about. Prose gets no label of its own. */
+export declare function thinkingHeading(raw: string): string;
+/** How a turn cut short reads, whether replayed or watched live. */
+export declare const INTERRUPTED_NOTICE: string;
+/** The line the daemon files as the assistant's when a turn is cut short;
+ *  it is a status, not something the model said. */
+export declare function interruptionNotice(text: string): string | null;
+export declare function firstNonEmptyLine(text: string, max: number): string;
+export interface SubagentNotice {
+    id: string;
+    description: string;
+    preview: string;
+    /** The report itself, without the closing line addressed to the model. */
+    body: string;
+    interim: boolean;
+    /** The interrupted form is written for the model alone; the child's own
+     *  block already reads interrupted, so no line is drawn for it. */
+    silent: boolean;
+}
+/** Reads a "[Background subagent <id> (<desc>) completed]" header; null for
+ *  any other notice, which keeps its full text. */
+export declare function parseSubagentNotice(text: string): SubagentNotice | null;
+/** The line that marks a child's report entering the main conversation. */
+export declare function subagentDeliveryLine(n: SubagentNotice): string;

package/dist/ai/ai.css

@@ -0,0 +1,325 @@
+/* Chat-specific styles: markdown rendering (streamdown output) and the
+ * streaming/thinking animations. */
+
+/* Answers are read at length, so their ink sits further from the page than
+ * the theme's UI text: pulled toward black on a light scheme and toward white
+ * on a dark one, from whatever ink the theme (or an org palette) supplies. */
+.chat-ink {
+  --chat-ink: light-dark(
+    color-mix(in oklab, var(--theme-panel, #000) 60%, black),
+    color-mix(in oklab, var(--theme-panel, #fff) 75%, white)
+  );
+  color: var(--chat-ink);
+  --tw-prose-body: var(--chat-ink);
+  --tw-prose-headings: var(--chat-ink);
+  --tw-prose-bold: var(--chat-ink);
+  --tw-prose-code: var(--chat-ink);
+}
+
+/* Links */
+.markdown a {
+  color: var(--theme-link, #428bca);
+  text-decoration: none;
+}
+.markdown a:hover {
+  text-decoration: underline;
+}
+
+/* Lists hang their markers in the gutter so a wrapped line lines up with the
+ * text above it, not with the number. Streamdown sets them inside. */
+.markdown ol,
+.markdown ul {
+  list-style-position: outside;
+  padding-left: 1.625em;
+}
+.markdown li {
+  padding-left: 0.25em;
+}
+
+/* Horizontal rules */
+.markdown hr {
+  display: block;
+  height: 0;
+  border: 0;
+  border-top: 1px solid var(--theme-border, #e5e7eb);
+  margin: 1.5em 0;
+  padding: 0;
+}
+
+/* Inline code — code blocks are styled by Streamdown. A tint of the ink and
+ * no border: a hard outline turns every identifier into a keycap. */
+.markdown code {
+  /* rem, not em: a table cell or list already sized down would size it twice. */
+  font-size: 0.875rem;
+  font-family: var(--font-mono, ui-monospace, monospace);
+  padding: 0.125em 0.375em;
+  background-color: color-mix(in oklab, var(--theme-panel, #000) 8%, transparent);
+  border-radius: 0.25rem;
+  /* Identifiers carry a colour of their own so they read as code at a glance
+   * without the weight the plugin gives them: the theme's link blue, which
+   * every palette already keeps legible on its surfaces. */
+  color: var(--theme-link, #2f6fa8);
+  font-weight: 400;
+}
+/* Reset inline code styles when inside a pre (code block) */
+.markdown pre code {
+  padding: 0;
+  background-color: transparent;
+  border: none;
+  border-radius: 0;
+  font-size: inherit;
+  color: inherit;
+}
+
+/* KaTeX overrides */
+.katex-display {
+  margin: 1em 0;
+  overflow-x: auto;
+  overflow-y: hidden;
+}
+.katex {
+  font-size: 1.1em;
+}
+
+/* Subscript and superscript */
+.markdown sub,
+.markdown sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+.markdown sup {
+  top: -0.5em;
+}
+.markdown sub {
+  bottom: -0.25em;
+}
+
+/* Images */
+.markdown img {
+  border: 0;
+  max-width: 100%;
+  height: auto;
+  vertical-align: middle;
+  border-radius: 0.5rem;
+}
+
+/* Streamdown tables: the body's own type,
+ * hairlines at a tenth of the ink, a header on a five-percent tint, and the
+ * copy/download controls only while the pointer is over the table. */
+.markdown [data-streamdown="table-wrapper"] {
+  --table-line: color-mix(in oklab, var(--theme-panel, #000) 10%, transparent);
+  position: relative;
+  display: block;
+  background: transparent;
+  border: none;
+  padding: 0;
+  margin: 0.75rem 0;
+}
+.markdown [data-streamdown="table-wrapper"] > div:first-child {
+  position: absolute;
+  top: 0.375rem;
+  right: 0.375rem;
+  z-index: 1;
+  gap: 0.125rem;
+  padding: 0.125rem;
+  border-radius: 0.375rem;
+  background: var(--theme-panel-bg, #fff);
+  border: 1px solid var(--table-line);
+  opacity: 0;
+  transition: opacity 150ms ease-out;
+}
+.markdown [data-streamdown="table-wrapper"]:hover > div:first-child,
+.markdown [data-streamdown="table-wrapper"]:focus-within > div:first-child {
+  opacity: 1;
+}
+.markdown [data-streamdown="table-wrapper"] > div:last-child {
+  padding: 0;
+  border: 1px solid var(--table-line);
+  border-radius: 0.5rem;
+  background: transparent;
+}
+.markdown [data-streamdown="table-wrapper"] table {
+  margin: 0;
+  font-size: 1rem;
+  line-height: 1.5;
+}
+.markdown [data-streamdown="table"] th {
+  padding: 0.4375rem 0.75rem;
+  font-size: 1rem;
+  font-weight: 500;
+  color: inherit;
+  background: color-mix(in oklab, var(--theme-panel, #000) 5%, transparent);
+  border-bottom: 1px solid var(--table-line);
+}
+.markdown [data-streamdown="table"] td {
+  padding: 0.4375rem 0.75rem;
+  /* Streamdown sizes cells down with its own class; the table is body type. */
+  font-size: 1rem;
+  line-height: 1.5;
+  vertical-align: top;
+  color: inherit;
+  /* A prose column keeps enough room to read; a wide table scrolls instead. */
+  min-width: 9rem;
+}
+.markdown [data-streamdown="table"] tbody tr {
+  border-bottom: 1px solid var(--table-line);
+}
+.markdown [data-streamdown="table"] tbody tr:last-child {
+  border-bottom: 0;
+}
+@media (prefers-reduced-motion: reduce) {
+  .markdown [data-streamdown="table-wrapper"] > div:first-child {
+    transition: none;
+  }
+}
+
+/* Streamdown code blocks — tighten spacing, remove inner double-border */
+.markdown [data-streamdown="code-block"] {
+  padding: 0.375rem 0.5rem 0;
+  margin: 0.5em 0;
+  gap: 0;
+}
+.markdown [data-streamdown="code-block-header"] {
+  padding: 0.25rem 0.25rem;
+}
+.markdown [data-streamdown="code-block-body"] {
+  border: none;
+  border-radius: 0 0 0.5rem 0.5rem;
+  padding: 0;
+}
+/* Remove prose pre margin and code block body inner pre margin */
+.markdown [data-streamdown="code-block-body"] pre {
+  margin: 0;
+  padding: 0.75rem 1rem;
+  overflow-x: auto;
+  /* Code reads looser than prose; Streamdown's text-sm line is too tight. */
+  line-height: 1.6;
+}
+
+/* Shiki dual-theme color overrides (standard Shiki approach).
+   Streamdown uses Tailwind dark: arbitrary-value classes for theme switching,
+   but Tailwind v4's source scanner can misparse them from minified JS —
+   generating broken selectors that apply dark bg unconditionally while
+   missing the text color classes entirely. Override both light and dark
+   explicitly to ensure correct colors in all modes.
+   See: https://shiki.style/guide/dual-themes#class-based-dark-mode */
+
+/* Light mode: use the primary Shiki theme (--sdm-bg/--sdm-c) */
+.markdown [data-streamdown="code-block-body"] pre {
+  background-color: var(--sdm-bg, inherit) !important;
+  color: var(--sdm-fg, inherit);
+}
+.markdown [data-streamdown="code-block-body"] pre code > span > span {
+  color: var(--sdm-c, inherit);
+}
+
+/* Dark mode: switch to --shiki-dark variants */
+.dark .markdown [data-streamdown="code-block-body"] pre {
+  background-color: var(--shiki-dark-bg, var(--sdm-bg, inherit)) !important;
+  color: var(--shiki-dark, var(--sdm-fg, inherit));
+}
+.dark .markdown [data-streamdown="code-block-body"] pre code > span > span {
+  color: var(--shiki-dark, inherit);
+  font-style: var(--shiki-dark-font-style, inherit);
+  font-weight: var(--shiki-dark-font-weight, inherit);
+  text-decoration: var(--shiki-dark-text-decoration, inherit);
+}
+.dark .markdown [data-streamdown="code-block-body"] pre code > span > span[style*="--sdm-tbg"] {
+  background-color: var(--shiki-dark-bg, var(--sdm-tbg));
+}
+
+/* Remove prose backtick pseudo-elements on inline code */
+.markdown code::before,
+.markdown code::after {
+  content: none !important;
+}
+
+/* Task lists (checkboxes) */
+.markdown input[type="checkbox"] {
+  margin-right: 0.5em;
+  vertical-align: middle;
+}
+.markdown li:has(> input[type="checkbox"]) {
+  list-style: none;
+  margin-left: -1.5em;
+}
+
+/* Touch device: always show chat actions */
+@media (hover: none) {
+  .chat-actions,
+  .chat-meta {
+    opacity: 1 !important;
+    pointer-events: auto !important;
+  }
+}
+
+/* Long finished replies clamp with a bottom fade; mask keeps the fade
+ * background-agnostic across themes. */
+.chat-message-clamp {
+  max-height: 600px;
+  overflow: hidden;
+  mask-image: linear-gradient(to bottom, black calc(100% - 96px), transparent);
+  -webkit-mask-image: linear-gradient(to bottom, black calc(100% - 96px), transparent);
+}
+
+/* Theme-aware input styling (matches the host app's .theme-input; defined
+ * here too so the edit textarea is styled in standalone use) */
+.theme-input {
+  background-color: var(--theme-input-bg, #f9fafb);
+  border-color: var(--theme-border, #d1d5db);
+  color: var(--theme-app, #374151);
+}
+
+.theme-input:focus {
+  border-color: var(--theme-element, #3b82f6);
+  outline: none;
+  box-shadow: 0 0 0 1px var(--theme-element, #3b82f6);
+}
+
+@keyframes shimmer {
+  0% {
+    background-position: 200% 0;
+  }
+  100% {
+    background-position: -200% 0;
+  }
+}
+
+@utility animate-shimmer {
+  animation: shimmer 1.75s linear infinite;
+  background-size: 200% 100%;
+}
+
+@utility text-shimmer {
+  background-image: linear-gradient(
+    90deg,
+    var(--theme-muted-text-color, #6a7282) 0%,
+    var(--theme-app, #d1d5db) 20%,
+    var(--theme-muted-text-color, #6a7282) 40%
+  );
+  -webkit-background-clip: text;
+  background-clip: text;
+  color: transparent;
+}
+
+/* Entrance animation for chat messages (CSS replacement for a JS motion lib).
+ * Only `from` is defined so elements settle at their natural styles (queued
+ * messages render at reduced opacity). */
+@keyframes chat-fade-in-up {
+  from {
+    opacity: 0;
+    transform: translateY(8px);
+  }
+}
+
+@utility animate-chat-enter {
+  animation: chat-fade-in-up 0.25s ease-out;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .animate-chat-enter {
+    animation: none;
+  }
+}

package/dist/ai/components/AllocationSelector.d.ts

@@ -0,0 +1,4 @@
+export default function AllocationSelector({ variant, }?: {
+    /** 'bare' drops the border, for a toolbar that reads as text. */
+    variant?: 'default' | 'bare';
+}): import("react").JSX.Element | null;

package/dist/ai/components/AttachmentManager.d.ts

@@ -0,0 +1 @@
+export default function AttachmentManager(): import("react").JSX.Element | null;

package/dist/ai/components/AttachmentUpload.d.ts

@@ -0,0 +1,24 @@
+export interface AttachmentUploadHandle {
+    addFiles: (files: FileList | File[]) => void;
+}
+export interface Attachment {
+    id?: string;
+    file?: File;
+    filename: string;
+    mimeType: string;
+    size: number;
+    uploading?: boolean;
+    uploaded?: boolean;
+    error?: string;
+    url?: string;
+}
+interface AttachmentUploadProps {
+    conversationId?: string | undefined;
+    attachments: Attachment[];
+    onAttachmentsChange: (attachments: Attachment[]) => void;
+    disabled?: boolean;
+    maxFiles?: number;
+    maxFileSize?: number;
+}
+declare const AttachmentUpload: import("react").ForwardRefExoticComponent<AttachmentUploadProps & import("react").RefAttributes<AttachmentUploadHandle>>;
+export default AttachmentUpload;

package/dist/ai/components/BlockedGroupBanner.d.ts

@@ -0,0 +1 @@
+export default function BlockedGroupBanner(): import("react").JSX.Element | null;

package/dist/ai/components/BranchNavigator.d.ts

@@ -0,0 +1,8 @@
+import type { ChatMessage as Message } from '../types.js';
+interface BranchNavigatorProps {
+    messages: Message[];
+    currentMessageId: string;
+    onNavigate: (messageId: string) => void;
+}
+export default function BranchNavigator({ messages, currentMessageId, onNavigate, }: BranchNavigatorProps): import("react").JSX.Element | null;
+export {};

package/dist/ai/components/ChatEmptyState.d.ts

@@ -0,0 +1,3 @@
+export default function ChatEmptyState({ targetSession, }: {
+    targetSession?: string | null | undefined;
+}): import("react").JSX.Element;

package/dist/ai/components/ChatInput.d.ts

@@ -0,0 +1,45 @@
+import { type ReactNode } from 'react';
+import { type SlashMenuConfig } from './SlashMenu.js';
+interface ChatInputProps {
+    onSend: (content: string, attachmentIds?: string[], attachmentMeta?: Record<string, {
+        filename: string;
+        contentType: string;
+        size: number;
+    }>) => void;
+    disabled?: boolean;
+    placeholder?: string | undefined;
+    conversationId?: string;
+    onEditLastMessage?: () => void;
+    /** Only the box: no page padding, width cap, or settings row, for a host
+     *  that lays out its own controls around it. */
+    flush?: boolean;
+    /** Send with nothing typed, for a surface where the text is optional. */
+    allowEmpty?: boolean;
+    /** Attach, paste, and drop files. Off for a target that takes text only. */
+    attachments?: boolean;
+    /** Hold sending until the provider's selected model is one it can serve.
+     *  Off when the target picks its own model. */
+    requireModel?: boolean;
+    inputLabel?: string;
+    sendLabel?: string;
+    sendTestId?: string;
+    /** Offers the host's slash commands as the input starts with /. */
+    slash?: SlashMenuConfig | undefined;
+    /** Pills naming where the turn runs, rendered above the input. */
+    context?: ReactNode;
+    settingsLeft?: ReactNode;
+    settingsRight?: ReactNode;
+    /** A turn the chat provider does not run, such as an agent session's: it
+     *  drives the Stop button in place of the provider's stream and queue. */
+    turn?: {
+        running: boolean;
+        onStop: () => void;
+        stopping?: boolean;
+    };
+}
+export interface ChatInputHandle {
+    addFiles: (files: FileList | File[]) => void;
+    focus: () => void;
+}
+declare const ChatInput: import("react").ForwardRefExoticComponent<ChatInputProps & import("react").RefAttributes<ChatInputHandle>>;
+export default ChatInput;

package/dist/ai/components/ChatLayout.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from 'react';
+export default function ChatLayout({ children, sidebarActions, }: {
+    children: ReactNode;
+    sidebarActions?: boolean;
+}): import("react").JSX.Element;