@qilin-agent/client-ui-chat 0.0.0-stage → 3.1.3

package/lib/index.js

@@ -0,0 +1,54 @@
+import z from "@qilin-agent/schemastery";
+//#region lib/types/chat-settings.js
+/** Chat display preferences stored in the Host user-settings document. */
+/** Settings namespace owned by the Chat target. */
+const CHAT_SETTINGS_NAMESPACE = "ui-chat";
+/** Field carrying the work-details presentation mode. */
+const TRANSCRIPT_VIEW_FIELD = "transcriptView";
+/** Work-details presentation modes a user can choose. */
+const TRANSCRIPT_VIEW_MODES = [
+	"compact",
+	"standard",
+	"detailed",
+	"verbose"
+];
+/**
+* Saved value from the two-mode generation of this setting. Read as `standard`;
+* never offered as a choice and never written back.
+*/
+const LEGACY_TRANSCRIPT_VIEW_MODE = "normal";
+/** Saved `expanded` values read as `detailed`, without being offered or written back. */
+const LEGACY_EXPANDED_TRANSCRIPT_VIEW_MODE = "expanded";
+/** Every value the durable field accepts: current modes plus legacy saved values. */
+const TRANSCRIPT_VIEW_SETTING_VALUES = [
+	...TRANSCRIPT_VIEW_MODES,
+	LEGACY_TRANSCRIPT_VIEW_MODE,
+	LEGACY_EXPANDED_TRANSCRIPT_VIEW_MODE
+];
+/** Standard process summaries for users without an explicit preference. */
+const DEFAULT_TRANSCRIPT_VIEW_MODE = "detailed";
+/** Performance and usage detail levels accepted by user settings. */
+const PERFORMANCE_USAGE_MODES = ["compact", "detailed"];
+/** Preserve detailed accounting for users without an explicit preference. */
+const DEFAULT_PERFORMANCE_USAGE = "detailed";
+/** Preserve the built-in browser for users without an explicit preference. */
+const DEFAULT_LINK_OPENING = "sidebar";
+/** Durable Chat schema; also the wire envelope the browser scope validates against. */
+const ChatSettingsFields = {
+	linkOpening: z.union(["sidebar", "new-tab"]).default(DEFAULT_LINK_OPENING),
+	performanceUsage: z.union([...PERFORMANCE_USAGE_MODES]).default(DEFAULT_PERFORMANCE_USAGE),
+	[TRANSCRIPT_VIEW_FIELD]: z.union([...TRANSCRIPT_VIEW_SETTING_VALUES]).default(DEFAULT_TRANSCRIPT_VIEW_MODE).loose()
+};
+/** Schema for shared configuration values. */
+const ChatSettingsSchema = z.object(ChatSettingsFields);
+//#endregion
+//#region lib/types/index.js
+/** Host registration for browser Chat preferences. */
+/** Register the durable Chat settings section when a provider exists. */
+function apply(ctx) {
+	ctx.inject(["settings"], (settingsCtx) => {
+		settingsCtx.settings.register(CHAT_SETTINGS_NAMESPACE, ChatSettingsSchema);
+	});
+}
+//#endregion
+export { CHAT_SETTINGS_NAMESPACE, ChatSettingsFields, DEFAULT_LINK_OPENING, DEFAULT_PERFORMANCE_USAGE, DEFAULT_TRANSCRIPT_VIEW_MODE, LEGACY_EXPANDED_TRANSCRIPT_VIEW_MODE, LEGACY_TRANSCRIPT_VIEW_MODE, PERFORMANCE_USAGE_MODES, TRANSCRIPT_VIEW_FIELD, TRANSCRIPT_VIEW_MODES, apply };

package/lib/types/chat-settings.d.ts

@@ -0,0 +1,47 @@
+/** Chat display preferences stored in the Host user-settings document. */
+import z from '@qilin-agent/schemastery';
+/** Settings namespace owned by the Chat target. */
+export declare const CHAT_SETTINGS_NAMESPACE = "ui-chat";
+/** Field carrying the work-details presentation mode. */
+export declare const TRANSCRIPT_VIEW_FIELD = "transcriptView";
+/** Work-details presentation modes a user can choose. */
+export declare const TRANSCRIPT_VIEW_MODES: readonly ["compact", "standard", "detailed", "verbose"];
+/** Work-details presentation mode. */
+export type TranscriptViewMode = typeof TRANSCRIPT_VIEW_MODES[number];
+/**
+ * Saved value from the two-mode generation of this setting. Read as `standard`;
+ * never offered as a choice and never written back.
+ */
+export declare const LEGACY_TRANSCRIPT_VIEW_MODE = "normal";
+/** Saved `expanded` values read as `detailed`, without being offered or written back. */
+export declare const LEGACY_EXPANDED_TRANSCRIPT_VIEW_MODE = "expanded";
+/** Standard process summaries for users without an explicit preference. */
+export declare const DEFAULT_TRANSCRIPT_VIEW_MODE: TranscriptViewMode;
+/** Performance and usage detail levels accepted by user settings. */
+export declare const PERFORMANCE_USAGE_MODES: readonly ["compact", "detailed"];
+/** Performance and usage presentation. */
+export type PerformanceUsageMode = typeof PERFORMANCE_USAGE_MODES[number];
+/** Preserve detailed accounting for users without an explicit preference. */
+export declare const DEFAULT_PERFORMANCE_USAGE: PerformanceUsageMode;
+/** Destinations for ordinary clicks on Chat HTTP(S) links. */
+export type LinkOpening = 'sidebar' | 'new-tab';
+/** Preserve the built-in browser for users without an explicit preference. */
+export declare const DEFAULT_LINK_OPENING: LinkOpening;
+/** Durable Chat section shared by the Host schema and browser scope. */
+export interface ChatSettings {
+    /** Work-details preference; legacy values are accepted only from existing saved settings. */
+    transcriptView: TranscriptViewMode | typeof LEGACY_TRANSCRIPT_VIEW_MODE | typeof LEGACY_EXPANDED_TRANSCRIPT_VIEW_MODE;
+    /** Detail level for composer statistics and completed-Turn usage. */
+    performanceUsage: PerformanceUsageMode;
+    /** Default destination for Chat HTTP(S) links. */
+    linkOpening: LinkOpening;
+}
+/** Durable Chat schema; also the wire envelope the browser scope validates against. */
+export declare const ChatSettingsFields: {
+    linkOpening: z<"sidebar" | "new-tab", "sidebar" | "new-tab", "defined">;
+    performanceUsage: z<"compact" | "detailed", "compact" | "detailed", "defined">;
+    transcriptView: z<"compact" | "standard" | "detailed" | "verbose" | "normal" | "expanded", "compact" | "standard" | "detailed" | "verbose" | "normal" | "expanded", "defined">;
+};
+/** Schema for shared configuration values. */
+export declare const ChatSettingsSchema: z<ChatSettings>;
+//# sourceMappingURL=chat-settings.d.ts.map

package/lib/types/client/apply.d.ts

@@ -0,0 +1,10 @@
+/** Register the Chat Conversation target, renderers, stats, and details surface. */
+import type { Context } from '@qilin-agent/kylin';
+/** Services required by the Chat target and its presentation registrations. */
+export declare const inject: string[];
+/**
+ * Mount all Chat-owned contributions.
+ * @param ctx - Client root context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=apply.d.ts.map

package/lib/types/client/chat/ApprovalCommand.d.ts

@@ -0,0 +1,20 @@
+/** Chat-owned approval detail resolving a correlated Tool call's command. */
+import type { PropsRuntime } from '@qilin-agent/client-ui-slots';
+interface ApprovalToolCall {
+    readonly callId: string;
+    readonly argsRaw: string;
+}
+/**
+ * Extract a shell command from a correlated Tool call when its arguments carry one.
+ * @param call - Tool call arguments, when a correlated call exists.
+ * @returns command text, or undefined for absent, malformed, or unrelated arguments.
+ */
+export declare function commandOf(call: ApprovalToolCall | undefined): string | undefined;
+/**
+ * Render the command of the Chat Tool node correlated with an approval.
+ * @param props - Approval identity and Session-standard Chat selector hook.
+ * @returns command text when the correlated call carries one.
+ */
+export declare function ApprovalCommand({ callId, useChat }: PropsRuntime<'conversation.approval.detail'>): string | null;
+export {};
+//# sourceMappingURL=ApprovalCommand.d.ts.map

package/lib/types/client/chat/AssistantMarkdown.d.ts

@@ -0,0 +1,47 @@
+import type { MarkdownFileMentions } from '@qilin-agent/client-ui-primitives';
+import type { ChatNodeOwnerProps, ChatViewSlotProps, UsePresentation } from '../contract/slots.ts';
+import type { AssistantBlock } from '../contract/snapshot.ts';
+/**
+ * Standalone fallback for image destinations (query/fragment suffixes are ignored).
+ * Chat fileImages resolves decoded file references against cwd; pathImages also
+ * serves this component outside that provider and accepts legacy image URL suffixes.
+ * Map one authored media destination to the same-origin workspace-file URL.
+ * @param protocol - `window.location.protocol` at render time.
+ * @param origin - `window.location.origin` at render time.
+ * @param value - The authored markdown destination, exactly as written; URL escapes are decoded once.
+ * @returns The API URL for an absolute local path on an HTTP(S) page, or
+ * undefined when the destination cannot be a Host-served local file
+ * (non-HTTP transport such as Electron `file://`, protocol-relative or
+ * relative destinations).
+ */
+export declare function localPathMediaUrl(protocol: string, origin: string, value: string): string | undefined;
+export interface AssistantMarkdownProps {
+    /**
+     * Business portion this seat renders: the enclosing process group renders a
+     * step's `reasoning` blocks, the Turn's answer seat renders the rest. Absent
+     * renders every block, for a step that owns its own seat.
+     */
+    groupPart?: string | undefined;
+    blocks: readonly AssistantBlock[];
+    streaming: boolean;
+    /** Frozen partial of an aborted turn: rendered with a stopped marker. */
+    interrupted?: boolean | undefined;
+    /** Render consecutive image blocks through the attachment slot. */
+    renderMessageImages: ChatNodeOwnerProps['renderMessageImages'];
+    /** Hide reasoning that belongs to the Turn-level process disclosure. */
+    reasoningHidden?: boolean | undefined;
+    /** Reveal the owning Turn-level process disclosure. */
+    revealProcess?: (() => void) | undefined;
+    /** Resolved prose file mentions for this Assistant's closing turn. */
+    mentions?: MarkdownFileMentions | undefined;
+    /**
+     * Live display-policy selector for the reasoning rows. Absent in detached
+     * compositions previews every settled reasoning summary (the Standard mode).
+     */
+    usePresentation?: UsePresentation | undefined;
+    /** The owning view's locale seat, passed down as a plain prop. */
+    t: ChatViewSlotProps['t'];
+}
+/** Reasoning block as the Think variant summary row (figma 39:28304). */
+export declare const AssistantMarkdown: import("react").MemoExoticComponent<({ groupPart, blocks, streaming, interrupted, renderMessageImages, reasoningHidden, revealProcess, mentions, usePresentation, t, }: AssistantMarkdownProps) => import("react").JSX.Element | null>;
+//# sourceMappingURL=AssistantMarkdown.d.ts.map

package/lib/types/client/chat/AssistantNodeView.d.ts

@@ -0,0 +1,7 @@
+import type { InjectFace } from '@qilin-agent/client-ui-slots';
+import type { ChatNodeViewProps, PresentationInjected } from '../contract/slots.ts';
+type AssistantNodeViewProps = ChatNodeViewProps<'assistant-step'> & InjectFace<PresentationInjected>;
+/** Streaming, settled, and interrupted Assistant states share one keyed renderer instance. */
+export declare const AssistantNodeView: import("react").MemoExoticComponent<({ node, groupPart, useTurnData, turnProcess, openFile, renderMessageImages, fileMentions, usePresentation, t, }: AssistantNodeViewProps) => import("react").JSX.Element>;
+export {};
+//# sourceMappingURL=AssistantNodeView.d.ts.map

package/lib/types/client/chat/ChatGroupSeat.d.ts

@@ -0,0 +1,14 @@
+/** Stable process container; display policy changes visibility, never member parents. */
+import { type ComponentProps } from 'react';
+import type { GroupKey } from '@qilin-agent/client-ui-conversation/client';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import { ChatNodeSeat } from './ChatNodeSeat.tsx';
+type SeatProps = Omit<ComponentProps<typeof ChatNodeSeat>, 'nodeKey' | 'groupPart'>;
+type ChatGroupSeatProps = SeatProps & {
+    readonly groupKey: GroupKey;
+    readonly useChatGroup: ChatViewSlotProps['useChatGroup'];
+};
+/** Render a process group with local disclosure and the existing outer-Turn visibility. */
+export declare const ChatGroupSeat: import("react").MemoExoticComponent<({ groupKey, useChatGroup, ...props }: ChatGroupSeatProps) => import("react").JSX.Element | null>;
+export {};
+//# sourceMappingURL=ChatGroupSeat.d.ts.map

package/lib/types/client/chat/ChatNodeSeat.d.ts

@@ -0,0 +1,22 @@
+import type { ChatNodeOwnerProps, ChatViewSlotProps, UsePresentation } from '../contract/slots.ts';
+import type { ChatNodeStore } from '../contract/snapshot.ts';
+interface ChatNodeSeatProps extends ChatNodeOwnerProps {
+    readonly nodeKey: string;
+    /** A replaced Builder must rebind keyed hooks even when references and keys survive. */
+    readonly nodeStore: ChatNodeStore;
+    readonly useChatNode: ChatViewSlotProps['useChatNode'];
+    readonly useChatNodeProcess: ChatViewSlotProps['useChatNodeProcess'];
+    readonly usePresentation: UsePresentation;
+    readonly useStore: ChatViewSlotProps['useStore'];
+    readonly actions: ChatViewSlotProps['actions'];
+    readonly renderSlot: ChatViewSlotProps['renderSlot'];
+    readonly t: ChatViewSlotProps['t'];
+}
+/**
+ * Subscribe, apply Turn-process visibility, and dispatch one stable Context key.
+ * Policy reads select this seat's own conclusion, so a mode change re-renders
+ * only seats whose visibility actually changes.
+ */
+export declare const ChatNodeSeat: import("react").MemoExoticComponent<({ nodeKey, groupPart, useChatNode, useChatNodeProcess, usePresentation, cwd, openFile, openSkill, inspectCall, forkAt, editUserMessage, loadImage, renderMessageImages, fileMentions, useStore, actions, renderSlot, t, }: ChatNodeSeatProps) => import("react").JSX.Element | null>;
+export {};
+//# sourceMappingURL=ChatNodeSeat.d.ts.map

package/lib/types/client/chat/ChatView.d.ts

@@ -0,0 +1,7 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+/**
+ * The chat view slot entry: pure component over the composed props; each
+ * ordered business Node crosses the keyed renderer seat.
+ */
+export declare function ChatView({ useSession, useChat, useChatNode, useChatNodeProcess, useChatGroup, useConversation, useSessions, useStore, actions, renderSlot, sessionId, openFile, openSkill, openExternalLink, loadOlder, loadThrough, loadImage, openTrajectory, chatScroll, forkAt, editUserMessage, fileMentions, usePresentation, useProjection, t, }: ChatViewSlotProps): import("react").JSX.Element;
+//# sourceMappingURL=ChatView.d.ts.map

package/lib/types/client/chat/CommandNodeView.d.ts

@@ -0,0 +1,9 @@
+import type { PropsRenderSlots } from '@qilin-agent/client-ui-slots';
+import type { ChatNodeViewProps } from '../contract/slots.ts';
+type CommandNodeViewProps = ChatNodeViewProps<'command'> & PropsRenderSlots<'conversation.chat.commandview'>;
+/** Ordinary command lifecycle renderer with command-name keyed specialization. */
+export declare const CommandNodeView: import("react").MemoExoticComponent<({ node, renderSlot, t }: CommandNodeViewProps) => import("react").JSX.Element>;
+/** One integrated `/compact` command and compaction transaction renderer. */
+export declare const ManualCompactionNodeView: import("react").MemoExoticComponent<({ node, t, }: ChatNodeViewProps<"manual-compaction">) => import("react").JSX.Element>;
+export {};
+//# sourceMappingURL=CommandNodeView.d.ts.map

package/lib/types/client/chat/CompactionCommandCard.d.ts

@@ -0,0 +1,8 @@
+import type { ChatViewSlotProps, CommandRowOwnerProps } from '../contract/slots.ts';
+interface CompactionCommandCardProps extends CommandRowOwnerProps {
+    t: ChatViewSlotProps['t'];
+}
+/** Render one manual compaction lifecycle without duplicating its checkpoint marker. */
+export declare function CompactionCommandCard({ node, compaction, t }: CompactionCommandCardProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=CompactionCommandCard.d.ts.map

package/lib/types/client/chat/CompactionItem.d.ts

@@ -0,0 +1,19 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { CompactionSummaryNode } from '../contract/snapshot.ts';
+interface CompactionItemProps {
+    node: CompactionSummaryNode;
+    /** Optional command title for a manual compaction folded into this marker. */
+    title?: string;
+    /** Command settlement text used when structured compaction counts are unavailable. */
+    fallbackSummary?: string | null;
+    /** The owning view's locale seat. */
+    t: ChatViewSlotProps['t'];
+}
+/**
+ * Renders the model-history compaction marker.
+ * @param props - the marker node off the snapshot cache.
+ * @returns the marker row, with the summary disclosure when one is available.
+ */
+export declare const CompactionItem: import("react").MemoExoticComponent<({ node, title, fallbackSummary, t, }: CompactionItemProps) => import("react").JSX.Element>;
+export {};
+//# sourceMappingURL=CompactionItem.d.ts.map

package/lib/types/client/chat/ContextBody.d.ts

@@ -0,0 +1,131 @@
+import type { ReactNode } from 'react';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { ContextMessageNode } from '../contract/snapshot.ts';
+import type { KnownContextForm } from '@qilin-agent/client-ui-conversation/client';
+type Translate = ChatViewSlotProps['t'];
+/**
+ * Default presentation: the model-facing text as text, with its real line
+ * breaks, and the remaining source fields beneath it. This is what every form
+ * this UI version does not recognize renders as.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The opaque context body.
+ */
+export declare function OpaqueBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `instructions` form: the files this context reconciled, then their text.
+ *
+ * The text keeps its `<system-reminder>` framing verbatim — the framing is part
+ * of what the model read, so hiding it would misreport the request.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The instructions context body, or the opaque body when the change
+ * list is unreadable.
+ */
+export declare function InstructionsBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `catalog` form: the published entries as a list, read from the source rather
+ * than re-parsed out of the model-facing prose.
+ *
+ * A catalog whose source carries no usable entries falls through to the opaque
+ * body, so an older or hand-edited log still shows its text.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The catalog context body, or the opaque body when the entry list is
+ * unreadable.
+ */
+export declare function CatalogBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `snapshot` form: the named contributions this snapshot assembled, in order.
+ *
+ * The sections are the same bytes the model read, split at the boundaries the
+ * producer assembled them on, so a reader sees which subsystem contributed
+ * which state instead of one undifferentiated wall.
+ *
+ * One sentence of the model-facing text is NOT in any section: the producer's
+ * framing line declaring that this snapshot supersedes earlier ones. Unlike the
+ * `<system-reminder>` wrapper an instruction context carries — which wraps
+ * content and cannot be separated from it — that line states the form's own
+ * semantics, so the body states them as a caption instead of reprinting the
+ * joined prose beside the sections it was split from.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The snapshot context body, or the opaque body when unreadable.
+ */
+export declare function SnapshotBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `notice` form: what just happened, with the model-facing text beneath it.
+ *
+ * The one-line account also rides the collapsed row ({@link contextBody}), so a
+ * notice is usually readable without expanding at all.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The notice context body.
+ */
+export declare function NoticeBody({ content, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `relay` form: which agent sent this, then what it said.
+ *
+ * The sender is an opaque session id; it is shown as a field rather than a
+ * label, because this client cannot resolve it to a title.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The relay context body.
+ */
+export declare function RelayBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `recall` form: which sessions this material came from and how much of each
+ * survived the read, then the material itself.
+ *
+ * Completeness is the fact a reader needs first: recalled context is bounded on
+ * the way in, so a card that hid the omitted count would overstate what the
+ * model received.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The recall context body, or the opaque body when unreadable.
+ */
+export declare function RecallBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * Choose the body for one context node.
+ *
+ * Returns the form the body actually rendered as, which is not always the
+ * declared one: a declared form whose fields are unreadable falls back to
+ * opaque, and the caller labels the row with what it really shows.
+ * `summary` is the collapsed row's one-line account, which only a `notice`
+ * records: its whole point is being readable without expanding.
+ * @param form - the producer-declared form projected onto the node.
+ * @param props - durable content, its source, and the locale seat.
+ * @returns the rendered form (null for opaque), its collapsed summary, and its body.
+ */
+export declare function contextBody(form: ContextMessageNode['form'], props: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): {
+    rendered: KnownContextForm | null;
+    summary: string | null;
+    body: ReactNode;
+};
+export {};
+//# sourceMappingURL=ContextBody.d.ts.map

package/lib/types/client/chat/ContextInjectionRow.d.ts

@@ -0,0 +1,26 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { ContextMessageNode } from '../contract/snapshot.ts';
+/** Props for the logged non-user message presentation. */
+export interface ContextInjectionRowProps {
+    content: ContextMessageNode['content'];
+    source: ContextMessageNode['source'];
+    /** Role and producer name projected from the durable source. */
+    producer: ContextMessageNode['producer'];
+    /** Producer-declared information form; null renders the opaque body. */
+    form: ContextMessageNode['form'];
+    /** The owning view's locale seat, passed down as a plain prop. */
+    t: ChatViewSlotProps['t'];
+}
+/**
+ * Render logged context with the Tool calls disclosure chrome from Figma.
+ *
+ * The header names the role the context plays and, beside it, the producer the
+ * durable source identifies, so a reader can tell an injected skill catalog
+ * from a workspace instruction file or a recalled session without expanding.
+ * The expanded body follows the producer-declared form; an absent or unknown
+ * form renders the opaque body.
+ * @param props - Durable content, its projected producer role/name and form, and the locale seat.
+ * @returns A collapsed context row with a bounded, form-specific body.
+ */
+export declare function ContextInjectionRow({ content, source, producer, form, t }: ContextInjectionRowProps): import("react").JSX.Element;
+//# sourceMappingURL=ContextInjectionRow.d.ts.map

package/lib/types/client/chat/GenericCommandCard.d.ts

@@ -0,0 +1,9 @@
+import type { ChatViewSlotProps, CommandRowOwnerProps } from '../contract/slots.ts';
+/** Card props: the owner payload plus the render site's locale seat (plain prop). */
+export interface GenericCommandCardProps extends CommandRowOwnerProps {
+    t: ChatViewSlotProps['t'];
+    /** Command-specific running copy; absent uses the generic command label. */
+    runningSummary?: string | undefined;
+}
+export declare function GenericCommandCard({ node, t, runningSummary }: GenericCommandCardProps): import("react").JSX.Element;
+//# sourceMappingURL=GenericCommandCard.d.ts.map

package/lib/types/client/chat/MessageIconActions.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from 'react';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+export interface MessageIconActionsProps {
+    /** Plain text the copy action writes. */
+    text: string;
+    /** Unix epoch ms for the clock label; omitted for transient messages. */
+    time?: number | undefined;
+    /** Clock before icons (user) or after (assistant). */
+    clock: 'start' | 'end';
+    /** Fork the session at this message; omission hides the branch action. */
+    onBranch?: (() => void) | undefined;
+    /** Revise this message: replace the composer draft with its text; omission hides the edit action. */
+    onEdit?: (() => void) | undefined;
+    /** The message is not a completed transcript tail, so branch stays visible but unavailable. */
+    branchUnavailable?: boolean | undefined;
+    /** Parent layout class composed onto the actions row. */
+    className?: string | undefined;
+    /**
+     * Slot-rendered actions owned by independent plugins, placed between the
+     * built-in copy and branch controls.
+     */
+    extraActions?: ReactNode;
+    /**
+     * Icon-row Turn-usage trigger (the TurnUsagePanel pill), seated after the
+     * branch control at the end of the icon cluster.
+     */
+    usageAction?: ReactNode;
+    /** The owning view's locale seat, passed down as a plain prop. */
+    t: ChatViewSlotProps['t'];
+}
+/**
+ * Copy / branch (/ clock) IconActions row shared by user and assistant chrome.
+ * @param props - Copy text, event time, clock side, branch callback, className.
+ * @returns The actions row element.
+ */
+export declare function MessageIconActions({ text, time, clock, onBranch, onEdit, branchUnavailable, className, extraActions, usageAction, t, }: MessageIconActionsProps): import("react").JSX.Element;
+//# sourceMappingURL=MessageIconActions.d.ts.map

package/lib/types/client/chat/MessageItem.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+import type { PendingSubmission } from '@qilin-agent/api-session-controller/client';
+import type { ChatNodeOwnerProps, ChatNodeViewProps, ChatViewSlotProps } from '../contract/slots.ts';
+/**
+ * Render one Host-authoritative pending steering item with the same visual
+ * language as its eventual durable transcript node.
+ * @param props - Pending message content and conversation translator.
+ * @returns the pending steering bubble.
+ */
+export declare function PendingSteeringBubble({ content, renderMessageImages, t }: {
+    content: readonly unknown[];
+    renderMessageImages: ChatNodeOwnerProps['renderMessageImages'];
+    t: ChatViewSlotProps['t'];
+}): ReactNode;
+/**
+ * Render one local transcript or steering submission echo with the same
+ * visual language and surface marker as the Host occurrence that replaces
+ * it: draft text plus object-URL previews, visible from the submit click
+ * until the durable `user/message` or steering occurrence renders.
+ * @param props - the session snapshot's pending submission and render seats.
+ * @returns the echoed user bubble.
+ */
+export declare function PendingSubmissionBubble({ submission, renderMessageImages, t }: {
+    submission: PendingSubmission;
+    renderMessageImages: ChatNodeOwnerProps['renderMessageImages'];
+    t: ChatViewSlotProps['t'];
+}): ReactNode;
+/** User and admitted-steering keyed Chat renderer. */
+export declare const UserMessageNodeView: import("react").MemoExoticComponent<({ node, editUserMessage, renderMessageImages, openFile, openSkill, t, }: ChatNodeViewProps<"user" | "steering">) => import("react").JSX.Element>;
+/** Injected-context keyed Chat renderer. */
+export declare const ContextMessageNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"context">) => import("react").JSX.Element>;
+/** Automatic compaction keyed Chat renderer. */
+export declare const CompactionNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"compaction">) => import("react").JSX.Element>;
+/** Correlated retry-chain keyed Chat renderer. */
+export declare const RetryNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"model-retry">) => import("react").JSX.Element>;
+/** Terminal turn-error keyed Chat renderer. */
+export declare const TurnErrorNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"turn-error">) => import("react").JSX.Element>;
+/** Max-tokens turn-end notice keyed Chat renderer. */
+export declare const TurnMaxTokensNodeView: import("react").MemoExoticComponent<({ t }: ChatNodeViewProps<"turn-max-tokens">) => import("react").JSX.Element>;
+/** Explicit unknown-surface keyed Chat renderer. */
+export declare const UnknownNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"unknown">) => import("react").JSX.Element>;
+//# sourceMappingURL=MessageItem.d.ts.map

package/lib/types/client/chat/ReasoningRow.d.ts

@@ -0,0 +1,20 @@
+import type { ChatViewSlotProps, UsePresentation } from '../contract/slots.ts';
+/**
+ * Render one assistant reasoning block collapsed until the reader opens it. The
+ * collapsed summary omits double-asterisk markers; expanded content renders
+ * the complete Markdown with secondary typography. A streaming row always
+ * previews its latest line; a settled row previews its first line only when
+ * the work-details mode allows it.
+ * @param props.text - complete or streaming reasoning text.
+ * @param props.running - whether this block is the streaming tail.
+ * @param props.usePresentation - live display-policy selector for this reasoning row.
+ * @param props.t - conversation locale seat for status and Markdown actions.
+ * @returns the reasoning disclosure.
+ */
+export declare function ReasoningRow({ text, running, usePresentation, t }: {
+    text: string;
+    running: boolean;
+    usePresentation?: UsePresentation | undefined;
+    t: ChatViewSlotProps['t'];
+}): import("react").JSX.Element;
+//# sourceMappingURL=ReasoningRow.d.ts.map

package/lib/types/client/chat/RunningSeal.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Render the decorative running icon.
+ * @returns the seal svg breathing at the running label's left.
+ */
+export declare function RunningSeal(): import("react").JSX.Element;
+//# sourceMappingURL=RunningSeal.d.ts.map

package/lib/types/client/chat/RunningStatus.d.ts

@@ -0,0 +1,13 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+interface RunningStatusProps {
+    readonly startTime: number | undefined;
+    readonly t: ChatViewSlotProps['t'];
+}
+/**
+ * Show live elapsed time after the current Turn's content without announcing ticks.
+ * @param props - Current Turn start time and localized copy.
+ * @returns the blue running indicator; mount only while the Session is running.
+ */
+export declare const RunningStatus: import("react").MemoExoticComponent<({ startTime, t }: RunningStatusProps) => import("react").JSX.Element>;
+export {};
+//# sourceMappingURL=RunningStatus.d.ts.map