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

package/lib/types/client/conversation-nodes/command.d.ts

@@ -0,0 +1,53 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { CommandNode, CompactionSummaryNode, ConversationMatch, ConversationNodeDefinition } from '@qilin-agent/client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Ordinary slash-command lifecycle. */
+        command: CommandNode;
+        /** Manual compact command combined with its compaction transaction. */
+        'manual-compaction': ManualCompactionChatData;
+    }
+}
+type CommandId = CommandNode['commandId'];
+interface CommandState {
+    readonly command: CommandNode;
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+interface CompactionEvidence {
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+/**
+ * Read correlation identity from a compaction replacement checkpoint.
+ * @param event - candidate Session event.
+ * @returns correlated compaction and optional command identity.
+ */
+declare function compactSource(event: Parameters<ConversationNodeDefinition['match']>[0]): {
+    compactionId: string;
+    sourceCommandId?: CommandId;
+} | undefined;
+/**
+ * Build the visible summary marker from optional lifecycle evidence.
+ * @param match - compaction/summary Match, when loaded.
+ * @param checkpoint - replacement checkpoint Match.
+ * @returns final compaction summary Node data.
+ */
+declare function compactSummary(match: ConversationMatch | undefined, checkpoint: ConversationMatch): CompactionSummaryNode;
+/**
+ * Fold shared compaction evidence into a Definition-owned State.
+ * @param state - current business State carrying optional compaction evidence.
+ * @param match - next compaction lifecycle Match.
+ * @returns adopted State, preserving reference identity when the Match adds no evidence.
+ */
+export declare function updateCompactionState<State extends CompactionEvidence>(state: State, match: ConversationMatch): State;
+/** Slash-command lifecycle, including integrated manual compaction, Definition. */
+export declare const commandDefinition: ConversationNodeDefinition<CommandState>;
+/**
+ * Register the command lifecycle business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerCommandConversationNode(ctx: Context): void;
+/** Shared structural checkpoint recognizer for automatic compaction. */
+export { compactSource, compactSummary };
+//# sourceMappingURL=command.d.ts.map

package/lib/types/client/conversation-nodes/common.d.ts

@@ -0,0 +1,41 @@
+import type { ConversationLocation, ConversationNodeContext } from '@qilin-agent/client-ui-conversation/client';
+import type { ChatNode, ChatNodeDataMap, ChatNodeKind } from '../contract/chat-nodes.ts';
+/**
+ * Relative positions in one durable event's seq neighborhood: interrupted
+ * Assistant, its follow-up Nodes, then follow-ups to an ordinary final. The
+ * max-tokens notice sits between a closing Assistant and the turn-tail so the
+ * tail stays the turn's last node and keeps its branch action enabled.
+ */
+export declare const CHAT_SYNTHETIC_SEQ_OFFSETS: {
+    readonly interruptedAssistant: -0.9;
+    readonly interruptedFollowup: -0.8;
+    readonly processControl: -0.1;
+    readonly maxTokensNotice: 0.05;
+    readonly finalizedFollowup: 0.1;
+};
+/**
+ * Resolve one Context's best currently loaded event Location.
+ * @param context - assembled business Context.
+ * @returns start or first-match Location, otherwise unresolved.
+ */
+export declare function contextLocation(context: ConversationNodeContext): ConversationLocation;
+/**
+ * Build one final Chat target Node with the engine-owned stable key.
+ * @param context - assembled business Context.
+ * @param kind - Chat renderer dispatch key.
+ * @param anchorSeq - sortable render position.
+ * @param data - renderer-owned payload.
+ * @param options - optional Location and visibility overrides.
+ * @returns final Chat view Node.
+ */
+export declare function chatNode<Kind extends ChatNodeKind>(context: ConversationNodeContext, kind: Kind, anchorSeq: number, data: ChatNodeDataMap[Kind], options?: {
+    readonly location?: ConversationLocation;
+    readonly visibility?: 'visible' | 'hidden';
+}): ChatNode<Kind>;
+/**
+ * Read a finite non-negative integer from a structurally narrowed payload.
+ * @param value - untrusted payload field.
+ * @returns valid coordinate, otherwise undefined.
+ */
+export declare function coordinate(value: unknown): number | undefined;
+//# sourceMappingURL=common.d.ts.map

package/lib/types/client/conversation-nodes/compaction.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { CompactionSummaryNode, ConversationMatch, ConversationNodeDefinition } from '@qilin-agent/client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Automatic compaction checkpoint marker. */
+        compaction: CompactionSummaryNode;
+    }
+}
+interface CompactionState {
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+/** Automatic compaction lifecycle and landed checkpoint Definition. */
+export declare const compactionDefinition: ConversationNodeDefinition<CompactionState>;
+/**
+ * Register the automatic-compaction business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerCompactionConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=compaction.d.ts.map

package/lib/types/client/conversation-nodes/event-projection.d.ts

@@ -0,0 +1,63 @@
+/** Chat-owned conversion from durable Session events to Chat view data. */
+import type { ContentBlock, StreamChunk } from '@qilin-agent/llm/types';
+import type { AssistantBlock, ContextProducerView, KnownContextForm } from '@qilin-agent/client-ui-conversation/client';
+/**
+ * Read the target-supported presentation form from a durable message source.
+ * @param source - Logged `user/message` source.
+ * @returns Supported form, or null for the opaque presentation.
+ */
+export declare function contextForm(source: unknown): KnownContextForm | null;
+/**
+ * Project a durable message source to the Chat row's role and producer label.
+ * @param source - Logged `user/message` source.
+ * @returns Role and label rendered by Chat.
+ */
+export declare function contextProducer(source: unknown): ContextProducerView;
+/**
+ * Read distinct labels cited by a durable cross-session recall source.
+ * @param source - Logged `user/message` source.
+ * @returns Labels in first-seen order.
+ */
+export declare function sessionRecallLabels(source: unknown): string[];
+/**
+ * Read the skill name a durable skill-invocation injection loaded.
+ * @param source - Logged `user/message` source.
+ * @returns The skill name, or null for every other source.
+ */
+export declare function skillInvocationName(source: unknown): string | null;
+/**
+ * Classify finalized Assistant content for Chat rendering.
+ * @param content - Core content blocks.
+ * @returns Chat blocks in source order.
+ */
+export declare function toAssistantBlocks(content: readonly ContentBlock[]): AssistantBlock[];
+/**
+ * Classify one finalized Assistant block for Chat rendering.
+ * @param block - Core content block.
+ * @returns Chat block.
+ */
+export declare function toAssistantBlock(block: ContentBlock): AssistantBlock;
+/**
+ * Create the initial Chat block for one streamed Assistant block kind.
+ * @param blockType - Wire block kind.
+ * @returns Empty block ready to receive deltas.
+ */
+export declare function emptyAssistantBlock(blockType: string): AssistantBlock;
+/** Display-safe failure fields retained by Chat projections. */
+export interface DisplayFailure {
+    readonly code?: string;
+    readonly message: string;
+}
+/**
+ * Convert a durable failure to locale-independent fields safe for Chat.
+ * @param failure - Failure preserved by a Session event.
+ * @returns Sanitized message and optional stable provider code.
+ */
+export declare function displayFailure(failure: unknown): DisplayFailure;
+/**
+ * Whether a stream chunk carries visible model output for Chat timing.
+ * @param chunk - Stream chunk to inspect.
+ * @returns true for a non-empty text, reasoning, or Tool-call delta.
+ */
+export declare function isTokenDelta(chunk: StreamChunk): boolean;
+//# sourceMappingURL=event-projection.d.ts.map

package/lib/types/client/conversation-nodes/fallback.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationNodeDefinition, UnknownSurfaceNode } from '@qilin-agent/client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Generic presentation of an unclaimed append-surface event. */
+        unknown: UnknownSurfaceNode;
+    }
+}
+/** Unclaimed append-surface fallback Definition. */
+export declare const unknownFallbackDefinition: ConversationNodeDefinition<UnknownSurfaceNode>;
+/**
+ * Register the unmatched append-surface fallback contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerUnknownConversationFallback(ctx: Context): void;
+//# sourceMappingURL=fallback.d.ts.map

package/lib/types/client/conversation-nodes/inbox.d.ts

@@ -0,0 +1,40 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationNodeDefinition } from '@qilin-agent/client-ui-conversation/client';
+interface InboxIdentity {
+    readonly id: string;
+    readonly source: {
+        readonly kind: string;
+    };
+}
+interface PendingSnapshot {
+    readonly kind: 'snapshot';
+    readonly ids: readonly InboxIdentity[];
+}
+interface PendingSplice {
+    readonly kind: 'splice';
+    readonly previous: PendingState;
+    readonly start: number;
+    readonly removedCount: number;
+    readonly inserted: readonly InboxIdentity[];
+}
+type PendingState = PendingSnapshot | PendingSplice;
+/** Persistent Inbox state after one durable Inbox splice. */
+export interface InboxState {
+    /** Persistent splice chain materialized only when a batch is claimed. */
+    readonly pending: PendingState;
+    /** Message ids in the current claim, shared until the next claim. */
+    readonly currentClaimed: ReadonlySet<string>;
+    readonly claimSeq: number;
+    readonly claimedHuman: boolean;
+}
+/** Persistent next-step claims identify messages admitted into a running Turn. */
+export declare const nextStepInboxDefinition: ConversationNodeDefinition<InboxState>;
+/** Persistent next-turn claims identify messages that wake a new Turn. */
+export declare const nextTurnInboxDefinition: ConversationNodeDefinition<InboxState>;
+/**
+ * Register the Inbox state used by Chat message classification.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerInboxConversationNodes(ctx: Context): void;
+export {};
+//# sourceMappingURL=inbox.d.ts.map

package/lib/types/client/conversation-nodes/message.d.ts

@@ -0,0 +1,42 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ContextMessageNode, ConversationNodeDefinition, SteeringMessageNode, UserMessageNode } from '@qilin-agent/client-ui-conversation/client';
+interface ReferencedUserMessageNode extends UserMessageNode {
+    /** Labels cited by the immediately following session-reference context. */
+    readonly referenceLabels?: readonly string[];
+    /** Skill names the same step's `skill-invocation` injections loaded. */
+    readonly skillNames?: readonly string[];
+}
+interface ReferencedSteeringMessageNode extends SteeringMessageNode {
+    /** Labels cited by the immediately following session-reference context. */
+    readonly referenceLabels?: readonly string[];
+    /** Skill names the same step's `skill-invocation` injections loaded. */
+    readonly skillNames?: readonly string[];
+}
+type MessageNode = ReferencedUserMessageNode | ReferencedSteeringMessageNode | (ContextMessageNode & {
+    readonly waking?: boolean;
+});
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Ordinary turn-opening user message. */
+        user: ReferencedUserMessageNode;
+        /** User message admitted into an active turn. */
+        steering: ReferencedSteeringMessageNode;
+        /** Non-user context injected into model history. */
+        context: ContextMessageNode;
+        /** Developer history: context presentation over a developer-role event. */
+        'developer-message': ContextMessageNode;
+        /** Non-human input that starts a Turn. */
+        'turn-trigger': ContextMessageNode;
+    }
+}
+/** User, steering, and injected-context message classification Definition. */
+export declare const messageDefinition: ConversationNodeDefinition<MessageNode>;
+/** Developer history uses the input-message lifecycle and context presentation. */
+export declare const developerMessageDefinition: ConversationNodeDefinition<MessageNode>;
+/**
+ * Register the user, steering, injected-context, and developer message contributions.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerMessageConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=message.d.ts.map

package/lib/types/client/conversation-nodes/process-activity.d.ts

@@ -0,0 +1,9 @@
+import type { ProcessActivitySummary } from '../contract/process-groups.ts';
+import type { ChatNode } from '../contract/chat-nodes.ts';
+/**
+ * Rank categories by distinct call count, breaking ties by first appearance.
+ * @param nodes - process members, including recursive tools.
+ * @returns all ranked categories and the latest running tool category and bounded task detail.
+ */
+export declare function processActivity(nodes: readonly ChatNode[]): ProcessActivitySummary;
+//# sourceMappingURL=process-activity.d.ts.map

package/lib/types/client/conversation-nodes/process-groups.d.ts

@@ -0,0 +1,27 @@
+import type { ConversationGroupDefinition, ConversationGroupInput, GroupUpdate } from '@qilin-agent/client-ui-conversation/client';
+import type { ChatConversationViewNode } from '../contract/chat-nodes.ts';
+import type { ProcessGroupData } from '../contract/process-groups.ts';
+type ProcessInput = ConversationGroupInput<ChatConversationViewNode>;
+/** Session-local Turn results; ordinary updates never read other Turns' Node contents. */
+export declare class ProcessState {
+    private turns;
+    private order;
+    private pending;
+    /**
+     * Consume one synchronous Builder input without retaining its readers.
+     * @param input - projected Node changes, indexed positions, and Turn lifecycle.
+     */
+    accept(input: ProcessInput): void;
+    private rootEntries;
+    /**
+     * Read pending output without advancing State.
+     * @returns the repeatable update for the last input batch.
+     */
+    output(): GroupUpdate<ProcessGroupData> | null;
+}
+/** Chat's registered business grouping; presentation modes never enter its State. */
+export declare const processGroupDefinition: ConversationGroupDefinition<ChatConversationViewNode, ProcessState, ProcessGroupData> & {
+    readonly target: 'chat';
+};
+export {};
+//# sourceMappingURL=process-groups.d.ts.map

package/lib/types/client/conversation-nodes/register.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@qilin-agent/kylin';
+/**
+ * Register the Chat business Definitions and target builder contributed by this package.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerConversationNodes(ctx: Context): void;
+//# sourceMappingURL=register.d.ts.map

package/lib/types/client/conversation-nodes/request-prompt.d.ts

@@ -0,0 +1,44 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationNodeDefinition, RequestPromptInspector, SystemPromptState, SystemPromptInspector } from '@qilin-agent/client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Complete system prompt rendered for one model request, or an in-history prompt update at its own position. */
+        'system-prompt': {
+            readonly text: string;
+            readonly update?: true;
+        };
+    }
+}
+interface RequestPromptState extends ReturnType<RequestPromptInspector> {
+    readonly anchorSeq: number;
+    readonly showsPrompt: boolean;
+    readonly turn?: number;
+    readonly step?: number;
+}
+/**
+ * System-prompt surface node Definition for the Chat target. It owns every
+ * `system/message` event on the Chat target so the unknown-surface fallback
+ * never renders the prompt as a transcript row. Each nonempty append owns a
+ * prompt card, even without a loaded request header. Initial cards precede
+ * their step's input; in-history updates stay at their own positions. The
+ * request-prompt Definition owns replacement and later-series cards. Positional
+ * replacements advance the effective prompt without changing historical cards.
+ * @param inspect - Pure surface interpretation supplied by uiConversation.
+ * @returns The Chat system-prompt Definition.
+ */
+export declare function systemMessageDefinition(inspect: SystemPromptInspector): ConversationNodeDefinition<SystemPromptState>;
+/**
+ * Request-header prompt Definition for the Chat target. Resume and explicit
+ * series starts retain a prompt card even when the system text is unchanged.
+ * @param inspect - the shared prompt interpretation, supplied by the
+ * uiConversation service (a client bundle cannot value-import it).
+ * @returns the Chat request-prompt Definition.
+ */
+export declare function requestPromptDefinition(inspect: RequestPromptInspector): ConversationNodeDefinition<RequestPromptState>;
+/**
+ * Register the system-prompt surface node and the model-request prompt card in the Chat flow.
+ * @param ctx - Owning UI Conversation context.
+ */
+export declare function registerRequestPromptConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=request-prompt.d.ts.map

package/lib/types/client/conversation-nodes/retry.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationNodeDefinition, ModelRetryNode } from '@qilin-agent/client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Producer-correlated model retry chain. */
+        'model-retry': RetryChatData;
+    }
+}
+/** Accumulated retry attempts sharing one producer-owned RetryId. */
+export interface RetryState {
+    readonly turn: number;
+    readonly step: number;
+    readonly attempts: readonly ModelRetryNode[];
+}
+/** Producer-correlated model retry chain Definition. */
+export declare const retryDefinition: ConversationNodeDefinition<RetryState>;
+/**
+ * Register the correlated model-retry business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerRetryConversationNode(ctx: Context): void;
+//# sourceMappingURL=retry.d.ts.map

package/lib/types/client/conversation-nodes/tool.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationNodeDefinition, ToolCallBlock } from '@qilin-agent/client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Root Tool lifecycle with recursively nested subcalls. */
+        'tool-call': ToolChatData;
+    }
+}
+interface ToolState {
+    /** Absent until a named delta or `tool/call` identifies the call. */
+    readonly root: ToolCallBlock | undefined;
+    readonly children: ReadonlyMap<string, readonly ToolCallBlock[]>;
+    readonly parents: ReadonlyMap<string, string>;
+}
+/** Root Tool preparation, dispatch, result, and nested PTC calls. */
+export declare const toolDefinition: ConversationNodeDefinition<ToolState>;
+/**
+ * Register the root Tool lifecycle and nested-subcall contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerToolConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=tool.d.ts.map

package/lib/types/client/conversation-nodes/turn-error.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationNodeDefinition, TurnErrorNode } from '@qilin-agent/client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Terminal turn failure recorded on the turn's end reason. */
+        'turn-error': TurnErrorNode;
+    }
+}
+interface TurnErrorState {
+    readonly turn: number;
+    readonly failure?: {
+        readonly seq: number;
+        readonly time: number;
+        readonly message: string;
+        readonly code?: string;
+    };
+}
+/**
+ * Terminal turn failure Definition. Retries run inside the failing turn, so the
+ * turn's `llm/retry` history never suppresses this terminal row; the model-retry
+ * node renders that history separately.
+ */
+export declare const turnErrorDefinition: ConversationNodeDefinition<TurnErrorState>;
+/**
+ * Register the terminal Turn-error business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnErrorConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-error.d.ts.map

package/lib/types/client/conversation-nodes/turn-max-tokens.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationNodeDefinition, TurnMaxTokensNode } from '@qilin-agent/client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Turn ended by the per-request output-token cap. */
+        'turn-max-tokens': TurnMaxTokensNode;
+    }
+}
+interface TurnMaxTokensState {
+    readonly turn: number;
+    readonly seq: number;
+    readonly time: number;
+}
+/** Notice Definition for a turn the provider ended at its output-token cap. */
+export declare const turnMaxTokensDefinition: ConversationNodeDefinition<TurnMaxTokensState>;
+/**
+ * Register the max-tokens turn-end notice contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnMaxTokensConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-max-tokens.d.ts.map

package/lib/types/client/conversation-nodes/turn-navigation.d.ts

@@ -0,0 +1,17 @@
+import type { ChatLocationNodeIndex, ChatNodeStore, TurnNavigationItem } from '../contract/snapshot.ts';
+/**
+ * Whether two items carry the same rail state, so the reader can keep its array.
+ * @param left - previously published item, when the Turn had one.
+ * @param right - freshly derived item, when the Turn still has one.
+ * @returns whether both sides describe the same mark.
+ */
+export declare function sameTurnNavigationItem(left: TurnNavigationItem | undefined, right: TurnNavigationItem | undefined): boolean;
+/**
+ * Project one loaded Turn into its rail item.
+ * @param turn - Turn number the item addresses.
+ * @param locations - live Location index supplying the Turn's node keys.
+ * @param nodes - live Chat node store.
+ * @returns the item, or undefined when the Turn has no visible loaded node.
+ */
+export declare function turnNavigationItem(turn: number, locations: ChatLocationNodeIndex, nodes: ChatNodeStore): TurnNavigationItem | undefined;
+//# sourceMappingURL=turn-navigation.d.ts.map

package/lib/types/client/conversation-nodes/turn-process-presentation.d.ts

@@ -0,0 +1,30 @@
+import type { ChatNode } from '../contract/chat-nodes.ts';
+import type { ChatLocationNodeIndex, ChatNodeStore, ChatTurnProcessPresentation } from '../contract/snapshot.ts';
+/** Mutable projection of cross-Node process layout facts by Turn. */
+export declare class ChatTurnProcessProjector {
+    private presentations;
+    /**
+     * Read the retained process presentation for a Node's Turn.
+     * @param node - Current Chat Node.
+     * @returns The Turn's process presentation, when present.
+     */
+    get(node: ChatNode | undefined): ChatTurnProcessPresentation | undefined;
+    /**
+     * Replace every projected Turn.
+     * @param order - visible Chat Node order.
+     * @param locations - current Chat Location index.
+     * @param nodes - current Chat Node store.
+     * @returns Turns whose process presentation changed.
+     */
+    replace(order: readonly string[], locations: ChatLocationNodeIndex, nodes: ChatNodeStore): ReadonlySet<number>;
+    /**
+     * Recompute selected Turns after incremental Node changes.
+     * @param turns - affected Turn numbers.
+     * @param locations - current Chat Location index.
+     * @param nodes - current Chat Node store.
+     * @returns Turns whose process presentation changed.
+     */
+    update(turns: ReadonlySet<number>, locations: ChatLocationNodeIndex, nodes: ChatNodeStore): ReadonlySet<number>;
+    private set;
+}
+//# sourceMappingURL=turn-process-presentation.d.ts.map

package/lib/types/client/conversation-nodes/turn-process.d.ts

@@ -0,0 +1,34 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationNodeDefinition } from '@qilin-agent/client-ui-conversation/client';
+import { type TurnProcessSpec } from '../contract/turn-process.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Turn-level disclosure controlling process rows before the finalized answer. */
+        'turn-process': import('../contract/chat-nodes.ts').TurnProcessChatData;
+    }
+}
+declare module '@qilin-agent/client-ui-conversation/client' {
+    interface ConversationTurnDataMap {
+        /** Process range and finalized answer boundary for this Turn. */
+        'turn-process': TurnProcessSpec;
+    }
+}
+interface TurnProcessState {
+    readonly turn: number;
+    readonly assistantStartByStep: ReadonlyMap<number, number>;
+    readonly messageCountByStep: ReadonlyMap<number, number>;
+    readonly otherStartSeq?: number;
+    readonly controlAnchorSeq?: number;
+    readonly messageCount: number;
+    readonly toolCallCount: number;
+    readonly subagentCount: number;
+}
+/** Turn-scoped process range and answer-boundary Definition. */
+export declare const turnProcessDefinition: ConversationNodeDefinition<TurnProcessState>;
+/**
+ * Register the Turn-scoped process disclosure projection.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnProcess(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-process.d.ts.map

package/lib/types/client/conversation-nodes/turn-tail.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ConversationMatch, ConversationNodeDefinition } from '@qilin-agent/client-ui-conversation/client';
+import type { TurnTailChatData } from '../contract/chat-nodes.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Completed-turn actions and extension tail. */
+        'turn-tail': TurnTailChatData;
+    }
+}
+declare module '@qilin-agent/client-ui-conversation/client' {
+    interface ConversationTurnDataMap {
+        /** Closing Assistant and footer facts derived for this completed Turn. */
+        'turn-tail': TurnTailChatData;
+    }
+}
+interface TurnTailState {
+    readonly turn: number;
+    readonly end?: ConversationMatch;
+}
+/** Completed-turn footer Definition independent of any Assistant row. */
+export declare const turnTailDefinition: ConversationNodeDefinition<TurnTailState>;
+/**
+ * Register completed-Turn footer data and its Chat node contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnTailConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-tail.d.ts.map

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

@@ -0,0 +1,38 @@
+/** Browser Chat target plugin. */
+export { apply, inject } from './apply.ts';
+export type {} from './conversation-nodes/assistant.ts';
+export type {} from './conversation-nodes/command.ts';
+export type {} from './conversation-nodes/compaction.ts';
+export type {} from './conversation-nodes/fallback.ts';
+export type {} from './conversation-nodes/message.ts';
+export type {} from './conversation-nodes/request-prompt.ts';
+export type {} from './conversation-nodes/retry.ts';
+export type {} from './conversation-nodes/tool.ts';
+export type {} from './conversation-nodes/turn-error.ts';
+export type {} from './conversation-nodes/turn-max-tokens.ts';
+export type {} from './conversation-nodes/turn-process.ts';
+export type {} from './conversation-nodes/turn-tail.ts';
+export type { AssistantBlock, AssistantMessageNode, AssistantProviderMetadataView, AssistantRequestConfig, AssistantTiming, ChatLocationNodeIndex, ChatNodeProcessSource, ChatNodeSource, ChatNodeStore, ChatSnapshot, ChatTurnNavigationIndex, ChatTurnProcessPresentation, CommandNode, CompactionSummaryNode, ContextMessageNode, ConversationNode, LegacyConversationSlice, ModelRetryNode, PartialAssistant, PreparingToolCall, RunningToolCall, StartedToolCall, SteeringMessageNode, ToolArgs, ToolCallBlock, ToolResultNode, TurnErrorNode, TurnMaxTokensNode, TurnNavigationItem, UnknownSurfaceNode, UserMessageNode, } from './contract/snapshot.ts';
+export type { AssistantChatData, ChatConversationViewNode, ChatNode, ChatNodeKind, FinalAssistantChatData, ManualCompactionChatData, RetryChatData, ToolChatData, TurnProcessChatData, TurnTailChatData, } from './contract/chat-nodes.ts';
+export type { ChatStoreState, ToolCallId, TurnProcessViewEntry } from './contract/store.ts';
+export type { TranscriptViewRowInjected, TranscriptViewRowProps } from './settings/TranscriptViewRow.tsx';
+export type { TranscriptViewMode } from '../chat-settings.ts';
+export type { ChatPresentationPolicy } from './presentation-policy.ts';
+export type { AssistantActionOwnerProps, ChatFileMentions, ChatNodeHookContext, ChatNodeInjected, ChatNodeOwnerProps, ChatNodeViewProps, ChatScrollPosition, ChatStore, ChatViewInjected, ChatViewSlotProps, ChatFlowDataInjected, ChatFlowHookContext, ChatFlowInjected, ChatFlowOwnerProps, ChatFlowSlotProps, UseGroupHeaderAction, ReasoningBodyOwnerProps, ReasoningContentInput, CommandRowOwnerProps, CommandRowProps, MessageImagesProps, OpenFileOptions, PerformanceUsageInjected, PresentationInjected, TurnProcessOwnerProps, TurnTailOwnerProps, UseChat, UseChatNodeTurnData, UseDisclosure, UsePresentation, UseGroupAction, } from './contract/slots.ts';
+export type { ProcessActivity, ProcessActivitySummary, ProcessGroupData, } from './contract/process-groups.ts';
+export type { TurnProcessSpec, } from './contract/turn-process.ts';
+export type { ChatKey } from './locale.ts';
+export type { ConversationContext, ConversationContextOriginKind } from './model/conversation-context.ts';
+export type { ContextProducerView, ContextRole, KnownContextForm, } from '@qilin-agent/client-ui-conversation/client';
+export type { ConversationPromptSnapshot, RequestInspectionSnapshot, RequestPromptChange, RequestView, } from '@qilin-agent/client-ui-conversation/client';
+export { isRunningTool, isSettledTool } from './contract/chat-nodes.ts';
+export { EMPTY_CHAT_SNAPSHOT } from './contract/snapshot.ts';
+/** Public merge surface for Chat renderer payloads contributed by other plugins. */
+export interface ChatNodeDataMap {
+}
+type PublicChatNodeDataMap = ChatNodeDataMap;
+declare module './contract/chat-nodes.ts' {
+    interface ChatNodeDataMap extends PublicChatNodeDataMap {
+    }
+}
+//# sourceMappingURL=index.d.ts.map