@qilin-agent/client-ui-user-questions 0.0.0-stage → 3.1.3

package/lib/index.js

@@ -0,0 +1,13 @@
+//#region lib/types/index.js
+/**
+* Web question plugin, node half.
+*
+* Mounting `ask_user_question` in the tools registry's global layer expands
+* every agent's tool list regardless of its preset. Rendering a question is
+* a host UI capability; the model-facing tool belongs to the presets that
+* include it and to the TUI composition, which has no presets.
+*/
+/** Host plugin body — the model-facing tool is composed per preset, not here. */
+function apply() {}
+//#endregion
+export { apply };

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

@@ -0,0 +1,14 @@
+import type { PendingQuestion, PlanReview, QuestionComposerProps } from './contract/slots.ts';
+/** The panel's own props: the question domain face, the narrowed review, and the locale seat. */
+export type PlanReviewPanelProps = {
+    pending: PendingQuestion;
+    review: PlanReview;
+} & Pick<QuestionComposerProps, 't' | 'renderSlot'>;
+/**
+ * Render plan review controls; the submitted document opens in the sidebar.
+ *
+ * @param props - the question domain face, the narrowed plan review, and `t`.
+ * @returns The plan-review takeover for this request.
+ */
+export declare function PlanReviewPanel({ pending, review, t, renderSlot }: PlanReviewPanelProps): import("react").JSX.Element;
+//# sourceMappingURL=PlanReviewPanel.d.ts.map

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

@@ -0,0 +1,26 @@
+import { type QuestionComposerProps } from './contract/slots.ts';
+/**
+ * Split the conventional recommendation suffix without changing the answer value.
+ * @param label - Original option label returned if selected.
+ * @returns Display label plus recommendation state.
+ */
+export declare function parseRecommendedLabel(label: string): {
+    label: string;
+    recommended: boolean;
+};
+/**
+ * Composer takeover router. Generic-question drafts live in this entry's
+ * Session-scoped Slot store, keyed by the pending carrier, so a strict Session
+ * entry remount restores the same request without exposing it to another one.
+ *
+ * One takeover, two presentations: a request that declares a presentation intent this
+ * package renders uses that presentation (a plan review is one decision over one
+ * plan, not a question set), and every other request takes the generic flow.
+ * The routing lives here, at the one entry that owns the composer seat, so
+ * neither presentation can claim a request the other is already rendering.
+ *
+ * @param props - the selector-matched pending question carrier plus the framework standard kit.
+ * @returns The question flow, or the intent's own surface, for this request.
+ */
+export declare function QuestionComposer(props: QuestionComposerProps): import("react").JSX.Element;
+//# sourceMappingURL=QuestionComposer.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { QuestionReplyData } from './question-reply.ts';
+type QuestionReplyViewProps = PropsRuntime<'conversation.chat.node', 'question-reply'> & PropsLocale<'question'>;
+/**
+ * Right-aligned late-reply bubble: a label naming the earlier pending
+ * questions, then one question and answer pair per question. A payload the
+ * Client cannot read falls back to the model-facing text.
+ */
+export declare const QuestionReplyView: import("react").MemoExoticComponent<({ node, t }: QuestionReplyViewProps) => import("react").JSX.Element>;
+/**
+ * Render one settled question reply as a compact transcript bubble.
+ * @param props - Reply data and the question locale translator.
+ * @returns The expandable reply bubble.
+ */
+export declare function QuestionReplyBubble({ data, t }: {
+    data: QuestionReplyData;
+    t: PropsLocale<'question'>['t'];
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=QuestionReplyView.d.ts.map

package/lib/types/client/contract/slots.d.ts

@@ -0,0 +1,276 @@
+/** Question composer props and one pending Remote waterfall response. */
+import type { InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore } from '@qilin-agent/client-ui-slots';
+import type { ToolCallId } from '@qilin-agent/llm/brand';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { AskUserQuestionAnswer, AskUserQuestionAnswerItem, AskUserQuestionItem, UserQuestionState } from '@qilin-agent/user-questions/types';
+import type { createQuestionDraftStore } from '../draft-store.ts';
+declare module '@qilin-agent/client-ui-session/client' {
+    interface SessionPendingInteractionMap {
+        /** Pending question or plan-review request. */
+        question: PendingQuestion;
+    }
+}
+declare module '@qilin-agent/client-ui-slots' {
+    interface SlotMap {
+        /** Actions for the exact plan under review; approval remains with the question composer. */
+        'conversation.plan-review.actions': {
+            kind: 'list';
+            scope: 'session';
+            owner: {
+                review: PlanReview;
+                requestKey: PendingQuestion['key'];
+            };
+        };
+    }
+}
+/** One structured answer batch covering every question of the request. */
+export type QuestionAnswer = AskUserQuestionAnswer;
+/** One question of the request. */
+type QuestionItem = AskUserQuestionItem;
+/** One option the asker offered on a question. */
+type QuestionOption = NonNullable<QuestionItem['options']>[number];
+/**
+ * A request narrowed to the `plan-review` presentation intent: everything the
+ * decision card renders and answers with, so the panel never re-reads the
+ * request fields. `approve` and `decline` are the asker's own options — an
+ * answer must carry one of those labels verbatim — and `plan` is the markdown
+ * body under review.
+ */
+export interface PlanReview {
+    /** The reviewed question's id, echoed in the answer. */
+    id: string;
+    /** The question text, kept as the card's accessible name. */
+    question: string;
+    /** The plan markdown under review. */
+    plan: string;
+    /** Logged tool invocation used to reopen this plan. */
+    callId?: ToolCallId;
+    /** The option that approves the plan. */
+    approve: QuestionOption;
+    /** The option that declines it; absent when the asker offered no other option. */
+    decline?: QuestionOption;
+}
+/**
+ * Narrow a request to a renderable plan review, or return undefined to leave it
+ * to the generic question flow.
+ *
+ * The card offers approval and a return to the composer for change requests.
+ * It accepts one question carrying the plan as detail and the named approve
+ * option, with at most one alternative and no multi-select. Larger choices
+ * remain in the generic question flow.
+ *
+ * @param questions - the request's whole question batch.
+ * @returns The narrowed review, or undefined when the generic flow owns it.
+ */
+export declare function planReviewOf(questions: readonly QuestionItem[]): PlanReview | undefined;
+/** Rejection codes a Client returns through the waterfall; the wire preserves `name` and `code`. */
+export type QuestionRejectionCode = 'ASK_ABORTED' | 'ASK_CANCELLED' | 'ASK_TIMED_OUT';
+/** One live Host waterfall attached to a card; it settles once and then detaches. */
+export interface QuestionWaterfallChannel {
+    /** Client-clock deadline in epoch milliseconds; absent for a blocking question. */
+    readonly deadline: number | undefined;
+    /** Resolve the Host waterfall with the whole answer batch. */
+    resolve(answer: QuestionAnswer): void;
+    /** Reject the Host waterfall with a wire-preserved code. */
+    reject(code: Exclude<QuestionRejectionCode, 'ASK_ABORTED'>): void;
+    /** Hand the request to the next waterfall listener. */
+    delegate(): void;
+}
+/** The Remote answer path of a continued question. */
+export interface QuestionRpcChannel {
+    /** Steer the answer into the agent; false when the question is no longer continued. Rejects when a reply is already queued. */
+    answer(answer: QuestionAnswer): Promise<boolean>;
+}
+/** The composer seat a card occupies while it is visible. */
+export interface QuestionSeat {
+    /** Withdraw the card from the pending-interaction registry without ending the request. */
+    hide(): void;
+}
+/** One waterfall request as the Remote Event listener awaits it. */
+export interface QuestionWaterfallRequest {
+    readonly channel: QuestionWaterfallChannel;
+    /** Outcome returned to the Host: the answer, or a wire-preserved rejection. */
+    readonly result: Promise<QuestionAnswer>;
+    /**
+     * Test whether a rejection asks the listener to call `next()`.
+     * @param reason - rejection received from {@link QuestionWaterfallRequest.result}.
+     * @returns whether {@link QuestionWaterfallChannel.delegate} produced it.
+     */
+    isDelegation(reason: unknown): boolean;
+}
+/**
+ * Create the deferred one Remote Event listener settles through a card.
+ * The request signal ends the channel with `ASK_ABORTED`; the Host ignores that
+ * outcome for an event it already finished, so a cancel frame loses nothing.
+ * @param deadline - Client-clock deadline in epoch milliseconds derived from the business claim's remaining duration.
+ * @param signal - Delivery lifetime of the forwarded request.
+ * @param onSettle - Called once with the channel when it settles or aborts.
+ * @returns The channel to attach and the promise the listener awaits.
+ */
+export declare function createWaterfallRequest(deadline: number | undefined, signal: AbortSignal | undefined, onSettle: (channel: QuestionWaterfallChannel) => void): QuestionWaterfallRequest;
+/** Reactive card state read by every mounted presentation of one question. */
+export interface QuestionCardSnapshot {
+    /** Mirrors the projection row; `open` until the projection says otherwise. */
+    readonly state: UserQuestionState;
+    /** User-visible foreground wait presentation. */
+    readonly waitState: 'counting' | 'focused' | 'editing' | 'waiting' | 'continued';
+    /**
+     * Foreground countdown presentation, absent for a request that carried no
+     * deadline. The card owns the ticking, so a hidden panel keeps counting and
+     * still times out; `running` is false while a hold or an edit froze it.
+     */
+    readonly countdown: {
+        readonly remainingMs: number;
+        readonly running: boolean;
+    } | undefined;
+    /** Channel a submission would use right now. */
+    readonly channel: 'waterfall' | 'rpc' | 'none';
+    /** Set once the card left the registry; the mounted composer clears its draft on this. */
+    readonly closed: boolean;
+}
+/**
+ * One answerable Client card. A card keyed by tool call is created by whichever
+ * source arrives first, the forwarded waterfall or the Session projection, and
+ * removed only when the projection no longer lists the call.
+ */
+export declare class PendingQuestion {
+    #private;
+    /** Presentation discriminator used by Session pending-interaction consumers. */
+    readonly kind: 'question' | 'plan-review';
+    /** Render identity and request key for the Session-scoped draft store. */
+    readonly key: string;
+    /** Agent/Session identity owning the request. */
+    readonly sessionId: SessionId;
+    /** The request's question list. */
+    readonly questions: readonly AskUserQuestionItem[];
+    /** Tool call identity; absent for a blocking request that carried no `wait`. */
+    readonly callId: ToolCallId | undefined;
+    /**
+     * Recorded answers of a call that already settled. Present only on a
+     * read-only review card, which the tool call row builds from its own
+     * transcript so a finished question can be read back in the panel that
+     * asked it. Such a card has no answer channel and no countdown.
+     */
+    readonly review: readonly AskUserQuestionAnswerItem[] | undefined;
+    /**
+     * What closing the panel does. A card keyed by tool call stays reachable
+     * from its tool call row, so closing only withdraws the panel (`hide`) and
+     * persists nothing. A card the Host never named has no way back, so closing
+     * it ends the request (`cancel`).
+     */
+    readonly dismissal: 'hide' | 'cancel';
+    /**
+     * @param sessionId - Agent/Session identity owning the request.
+     * @param questions - complete question batch.
+     * @param callId - tool call identity when the Host named one.
+     * @param siblings - keys of every card currently registered for the Session, for draft pruning.
+     * @param review - recorded answers of a settled call, making this a read-only card.
+     */
+    constructor(sessionId: SessionId, questions: readonly AskUserQuestionItem[], callId?: ToolCallId, siblings?: () => readonly string[], review?: readonly AskUserQuestionAnswerItem[]);
+    /**
+     * Card key of a tool call, shared by every source that names one. The Host
+     * request and the Session projection carry the branded `ToolCallId`; a
+     * transcript row carries the same wire value as a plain string.
+     * @param sessionId - owning Session.
+     * @param callId - tool call identity, branded or as a transcript spells it.
+     * @returns the render identity and draft key.
+     */
+    static keyOf(sessionId: SessionId, callId: string): string;
+    /**
+     * Draft keys that are still live in this Session, this card included.
+     * @returns keys the draft store must keep; everything else is stale.
+     */
+    liveKeys(): readonly string[];
+    /** Subscribe to card state changes. */
+    readonly subscribe: (listener: () => void) => (() => void);
+    /** Read the stable current card state. */
+    readonly snapshot: () => QuestionCardSnapshot;
+    /** Observable snapshot read by the renderer's keyed Hook. */
+    readonly getSnapshot: () => QuestionCardSnapshot;
+    private createSnapshot;
+    private publish;
+    /**
+     * Attach the live waterfall of a forwarded request.
+     * @param channel - request channel created by {@link createWaterfallRequest}.
+     */
+    attachWaterfall(channel: QuestionWaterfallChannel): void;
+    /**
+     * Drop a waterfall channel that settled or was cancelled; the card stays.
+     * @param channel - the channel that ended.
+     */
+    detachWaterfall(channel: QuestionWaterfallChannel): void;
+    /**
+     * Whether a live waterfall is attached.
+     * @returns whether the pending Host request still accepts settlement.
+     */
+    hasWaterfall(): boolean;
+    /**
+     * Attach the Remote answer path used once the question is continued.
+     * @param channel - Remote calls bound to this Session and call.
+     */
+    attachRpc(channel: QuestionRpcChannel): void;
+    /**
+     * Attach the composer seat this card is published into.
+     * @param seat - withdrawal of the published panel, owned by the card registry.
+     */
+    attachSeat(seat: QuestionSeat): void;
+    /**
+     * Copy the projection row state.
+     * @param state - `open` or `continued`.
+     */
+    setState(state: UserQuestionState): void;
+    /** Stop this Client's countdown indefinitely; the waterfall then waits like a blocking question. */
+    takeTime(): void;
+    /**
+     * Record focus even before the request arrives, freezing a pristine countdown once attached.
+     * @param now - current Client epoch time.
+     */
+    holdFocus(now?: number): void;
+    /**
+     * Resume a pristine countdown after the answer surface loses focus.
+     * @param now - current Client epoch time.
+     */
+    releaseFocus(now?: number): void;
+    /**
+     * Keep the first edited draft answerable without a foreground deadline.
+     * @param now - current Client epoch time used to preserve the remaining duration.
+     */
+    engage(now?: number): void;
+    /** Local countdown reached zero: settle the waterfall with `ASK_TIMED_OUT`, keep the card. */
+    timeout(): void;
+    /** Hand a live waterfall to the next listener when this presentation domain unloads. */
+    delegate(): void;
+    /** Mark the card removed from the registry; the mounted composer clears its draft. */
+    close(): void;
+    /**
+     * Submit the whole answer batch through the live waterfall, or through the
+     * Remote path once the question is continued.
+     * @param answer - complete structured answer batch.
+     */
+    answer(answer: QuestionAnswer): Promise<void>;
+    /**
+     * Close the panel. A tool-call-keyed card only leaves the composer seat: the
+     * request stands, the countdown keeps running here, and the tool call row
+     * reopens it. A card the Host never named ends its request instead, because
+     * nothing could bring it back.
+     */
+    dismiss(): Promise<void>;
+}
+/** Pending value returned by the composer-chain selector. */
+export type QuestionWait = PendingQuestion;
+/**
+ * Full component props: the framework runtime share (chain currency +
+ * session/global standard kit) plus the chain `matched` share — the entry's
+ * selector result, already narrowed to the question carrier — plus the
+ * standard locale seat; the carrier plus the domain face above carry the
+ * whole behavior surface.
+ */
+export type QuestionComposerProps = PropsRuntime<'conversation.composer'> & PropsStore<ReturnType<typeof createQuestionDraftStore>> & PropsRenderSlots<'conversation.plan-review.actions'> & InjectFace<{
+    keyedHooks: {
+        questionCard: (key: string) => PendingQuestion | undefined;
+    };
+}> & {
+    matched: QuestionWait;
+} & PropsLocale<'question'>;
+export {};
+//# sourceMappingURL=slots.d.ts.map

package/lib/types/client/draft-store.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Session-scoped draft state for the generic question composer. The Slot
+ * registry owns store instances; this module exports only the factory so a
+ * plugin reload cannot reuse a module-global handle.
+ */
+import { type EngineStoreHandle } from '@qilin-agent/client-store';
+/** One in-progress answer, including an explicit skip. */
+export interface QuestionDraftAnswer {
+    /** Offered labels currently selected. */
+    selected: string[];
+    /** Human-authored alternative or additional answer. */
+    custom: string;
+    /** Whether the user explicitly skipped this question. */
+    skipped: boolean;
+}
+/** Navigation and answer drafts for one pending request. */
+export interface QuestionDraftProgress {
+    /** Current question index. */
+    index: number;
+    /** One draft per question, in request order. */
+    drafts: QuestionDraftAnswer[];
+    /** Local indefinite-wait choice restored with the draft. */
+    wait?: 'editing' | 'waiting';
+}
+interface QuestionDraftState {
+    progressByRequest: Record<string, QuestionDraftProgress>;
+}
+type QuestionDraftActions = {
+    replace: (draft: QuestionDraftState, requestKey: string, progress: QuestionDraftProgress) => void;
+    clear: (draft: QuestionDraftState, requestKey: string) => void;
+    prune: (draft: QuestionDraftState, keep: readonly string[]) => void;
+};
+/**
+ * Declare the question composer's Session store. Drafts persist per Session so
+ * leaving the Session or restarting the Client does not erase an unfinished answer.
+ * @returns a persisted store handle whose instance is owned by the Slot registry.
+ */
+export declare function createQuestionDraftStore(): EngineStoreHandle<QuestionDraftState, QuestionDraftActions>;
+export {};
+//# sourceMappingURL=draft-store.d.ts.map

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

@@ -0,0 +1,33 @@
+/**
+ * Web question plugin, browser half: QuestionComposer registered as a
+ * selector-routed entry of the conversation-declared composer chain, plus the
+ * `question` dictionaries. The selector narrows the owner's currency to the
+ * question carrier (matched prop), and the whole behavior surface rides the
+ * carrier (domain encoding in contract/slots.ts PendingQuestion); copy rides
+ * the standard locale seat. Export discipline: packages/client/AGENTS.md.
+ *
+ * One entry, two presentations: the composer renders a request with a
+ * `plan-review` intent as the plan decision card and every other request as
+ * the generic question flow. Both use the same carrier and composer seat.
+ */
+import type { Context as ClientContext } from '@qilin-agent/kylin';
+import { type QuestionKey } from './locales.ts';
+export type { PendingQuestion, PlanReview, QuestionAnswer, QuestionComposerProps, QuestionWait, } from './contract/slots.ts';
+export type { QuestionKey } from './locales.ts';
+declare module '@qilin-agent/client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The question composer's copy. */
+        question: QuestionKey;
+    }
+}
+/** Required services: Agent scopes, Remote Events, Session UI, Slot registry, conversation nodes, and copy. */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the `question` dictionaries, the question
+ * composer into the composer chain, and the late-reply conversation node.
+ * Zero business face — data and verbs live on the matched carrier; t rides
+ * the standard locale seat.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,72 @@
+/** `question` namespace dictionaries. */
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    'error.incomplete': string;
+    'error.unanswered': string;
+    'error.unavailable': string;
+    'error.resubmit': string;
+    'status.sent': string;
+    'wait.takeTime': string;
+    'wait.countdown': string;
+    'wait.paused': string;
+    'wait.held': string;
+    'wait.continued': string;
+    'review.status': string;
+    'review.skipped': string;
+    'reply.label': string;
+    'reply.open': string;
+    'reply.close': string;
+    'reply.answerLabel': string;
+    'reply.skipped': string;
+    'nav.prev': string;
+    'nav.next': string;
+    'nav.minimize': string;
+    'nav.maximize': string;
+    'nav.cancel': string;
+    'nav.close': string;
+    'option.recommended': string;
+    'custom.placeholder': string;
+    'action.skip': string;
+    'action.next': string;
+    'plan.header': string;
+    'plan.approve': string;
+    'plan.decline': string;
+    'plan.discuss': string;
+};
+/** The question namespace key union. */
+export type QuestionKey = keyof typeof zh;
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: {
+    'error.incomplete': string;
+    'error.unanswered': string;
+    'error.unavailable': string;
+    'error.resubmit': string;
+    'status.sent': string;
+    'wait.takeTime': string;
+    'wait.countdown': string;
+    'wait.paused': string;
+    'wait.held': string;
+    'wait.continued': string;
+    'review.status': string;
+    'review.skipped': string;
+    'reply.label': string;
+    'reply.open': string;
+    'reply.close': string;
+    'reply.answerLabel': string;
+    'reply.skipped': string;
+    'nav.prev': string;
+    'nav.next': string;
+    'nav.minimize': string;
+    'nav.maximize': string;
+    'nav.cancel': string;
+    'nav.close': string;
+    'option.recommended': string;
+    'custom.placeholder': string;
+    'action.skip': string;
+    'action.next': string;
+    'plan.header': string;
+    'plan.approve': string;
+    'plan.decline': string;
+    'plan.discuss': string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/question-reply.d.ts

@@ -0,0 +1,67 @@
+import type { ConversationNodeDefinition } from '@qilin-agent/client-ui-conversation/client';
+import type { PropsLocale } from '@qilin-agent/client-ui-slots';
+/** One asked question as echoed in the reply payload. */
+export interface QuestionReplyQuestion {
+    readonly id: string;
+    readonly question: string;
+    readonly detail?: string;
+    readonly header?: string;
+    readonly options?: readonly {
+        readonly label: string;
+        readonly description?: string;
+    }[];
+    readonly multiSelect?: boolean;
+}
+/** One structured answer as echoed in the reply payload. */
+export interface QuestionReplyAnswer {
+    readonly id: string;
+    readonly selected: readonly string[];
+    readonly custom?: string;
+}
+/** Presentation data of one late reply. */
+export interface QuestionReplyData {
+    readonly callId: string;
+    /** A late answer to the pending questions. */
+    readonly outcome: 'answered';
+    readonly questions: readonly QuestionReplyQuestion[];
+    readonly answers: readonly QuestionReplyAnswer[];
+    /** Model-facing text, shown when the payload is unreadable. */
+    readonly text: string;
+    readonly time: number;
+}
+declare module '@qilin-agent/client-ui-chat/client' {
+    interface ChatNodeDataMap {
+        /** Late answer to a continued question. */
+        'question-reply': QuestionReplyData;
+    }
+}
+interface QuestionReplyState extends QuestionReplyData {
+    readonly seq: number;
+}
+/**
+ * Read the question and answer pairs out of the reply text at the conversation boundary.
+ * @param text - Model-facing JSON payload of the steered message.
+ * @returns The pairs, or empty lists when the payload is unreadable.
+ */
+export declare function replyPairsOf(text: string): Pick<QuestionReplyData, 'questions' | 'answers'>;
+/**
+ * Answer values of one question in display order: the selected option labels
+ * followed by a non-blank custom answer.
+ * @param data - Projected reply holding the recorded answers.
+ * @param id - Question id to read.
+ * @returns The values, empty when the user skipped that question.
+ */
+export declare function replyAnswerValues(data: QuestionReplyData, id: string): string[];
+/**
+ * Clipboard text of one late reply: every question with the answer the user
+ * gave, in the layout the open bubble shows, without the options nobody chose.
+ * The text does not depend on whether the bubble is open.
+ * @param data - Projected reply to copy.
+ * @param t - Bound `question` namespace translator owning the answer labels.
+ * @returns One block per question, or the model-facing text when the payload was unreadable.
+ */
+export declare function replyClipboardText(data: QuestionReplyData, t: PropsLocale<'question'>['t']): string;
+/** Late-reply projection owned by the questions UI. */
+export declare const questionReplyDefinition: ConversationNodeDefinition<QuestionReplyState>;
+export {};
+//# sourceMappingURL=question-reply.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Web question plugin, node half.
+ *
+ * Mounting `ask_user_question` in the tools registry's global layer expands
+ * every agent's tool list regardless of its preset. Rendering a question is
+ * a host UI capability; the model-facing tool belongs to the presets that
+ * include it and to the TUI composition, which has no presets.
+ */
+/** Host plugin body — the model-facing tool is composed per preset, not here. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@qilin-agent/client-ui-user-questions",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Web ask_user_question composer takeover and plan-review presentation UI",
+  "version": "3.1.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/client/ui-user-questions"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "qilin": {
+    "client": {
+      "inject": [
+        "@qilin-agent/api-remotes",
+        "@qilin-agent/api-session-controller",
+        "@qilin-agent/client-locale",
+        "@qilin-agent/client-ui-conversation",
+        "@qilin-agent/client-ui-renderer",
+        "@qilin-agent/client-ui-session"
+      ],
+      "platform": "web"
+    }
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@qilin-agent/kylin": "~4.0.3"
+  },
+  "devDependencies": {
+    "@types/react": "~18.3.1",
+    "clsx": "^2.0.0",
+    "react": "^18.2.0",
+    "@qilin-agent/agent": "3.1.3",
+    "@qilin-agent/api-session-controller": "3.1.3",
+    "@qilin-agent/client-connection": "3.1.3",
+    "@qilin-agent/api-remotes": "3.1.3",
+    "@qilin-agent/client-locale": "3.1.3",
+    "@qilin-agent/client-store": "3.1.3",
+    "@qilin-agent/client-ui-chat": "3.1.3",
+    "@qilin-agent/client-ui-conversation": "3.1.3",
+    "@qilin-agent/client-ui-renderer": "3.1.3",
+    "@qilin-agent/client-ui-slots": "3.1.3",
+    "@qilin-agent/client-ui-primitives": "3.1.3",
+    "@qilin-agent/client-ui-session": "3.1.3",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/llm": "3.1.3",
+    "@qilin-agent/session": "3.1.3",
+    "@qilin-agent/system-prompt": "3.1.3",
+    "@qilin-agent/tools": "3.1.3",
+    "@qilin-agent/typert-protocol": "3.1.3",
+    "@qilin-agent/user-questions": "3.1.3",
+    "@qilin-agent/client-ui-tool": "3.1.3",
+    "@qilin-agent/brand": "3.1.3"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  }
 }