@hasna-internal/kai-user-questions 0.1.1-rc.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/interaction/user-questions/README.md
+README.md: 53459c39c75d5d3907b002239c83db5f82e024f5
+README.zh.md: 3a1f016aef6efa0a2167523fd4e1a938fa53eb71

package/README.md

@@ -0,0 +1,46 @@
+# @hasna-internal/kai-user-questions
+
+English | [中文](README.zh.md)
+
+User-interaction Service Definition. It owns `ctx.userQuestions`, the service a model-facing tool or permission plugin uses when it needs to pause work and ask the human for a decision.
+
+## Service: `UserQuestionService` (ctx key: `userQuestions`)
+
+### Public API
+
+- `ctx.userQuestions.registerProvider(provider): () => void` Register the UI-side provider. Only one provider may be active in a context; disposal unregisters it.
+- `ctx.userQuestions.ask(request): Promise<AskUserQuestionAnswer>` Ask the active provider and wait for the answer.
+
+### Key Types
+
+- `AskUserQuestionRequest` — `{ questions: [{ id, question, detail?, header?, options?, multiSelect?, intent? }], agent?, signal? }`; `detail` supplies supporting text that providers render with the question without turning it into an option label. When present, `agent` must be the registry's exact live runtime root.
+- `AskUserQuestionOption` — `{ label, description? }`.
+- `AskUserQuestionIntent` — `{ kind: 'plan-review', approve }`; the tagged presentation intent below.
+- `AskUserQuestionAnswer` — `{ answers: [{ id, selected, custom? }] }`.
+- `UserQuestionProvider` — UI implementation with `ask(request)`.
+- `UserQuestionError` — `HarnessError` subclass with codes such as `EMPTY_QUESTIONS`, `BAD_INTENT`, `NO_PROVIDER`, `DUPLICATE_PROVIDER`, `ASK_ABORTED`, `CALLER_NOT_LIVE`, and `DELEGATED_CALLER`.
+
+For a single-select question, `custom` overrides the selected choice and `selected` is empty. For a multi-select question, `custom` may supplement the labels in `selected`. A UI may preserve a skipped item as `{ id, selected: [] }`, keeping the existing answer shape while retaining other answers in the batch.
+
+When a request carries an agent, `ask()` authenticates its exact identity through the live `AgentRegistry` and admits only a runtime root. Durable lineage is not authority: a session with historical delegation depth may ask after it is resumed as a new runtime root, while a live child owned by another agent is rejected even if its durable depth is zero. Agentless programmatic requests retain the existing provider path.
+
+### Presentation intent
+
+`intent` declares that a question IS a known kind of decision, so a UI that recognises the tag may present it as such — `plan-review` says `detail` is a plan under review, and `dsh-plan-mode` sets it on the `exit_plan_mode` question. An intent changes presentation only: a UI honouring it answers with the same option labels a generic UI would send, and a UI that does not know the tag renders the generic option list, so callers read the same answer fields either way. `approve` names the label that approves rather than relying on option order. `ask()` rejects with `BAD_INTENT` the two assertions no type can carry: an `approve` naming none of that question's own options, and an intent on a question with no `detail` — the thing it declares itself a review of.
+
+## Role
+
+This is the Service Definition package. Consumers such as `@hasna-internal/kai-tool-ask-user` depend on this service; the Web host runtime supplies the shipped Service Provider. The loop stays unchanged: a tool call awaits a promise, and the tool result resumes the normal agent loop.
+
+## Model Experience
+
+Indirectly, through `dsh-tool-ask-user`, which retains a successful provider answer as compact JSON or one of these failures: `Error: ask_user_question was aborted before the user answered`, `Error: ask_user_question requires at least one question`, `Error: human interaction requires the exact live calling agent when an agent is supplied`, `Error: human interaction is unavailable while the calling agent is owned by another live agent; include the unresolved question or decision in the child agent's final result`, `Error: no user-questions provider is registered`, or `Error: <message>`. Waiting for the human adds no tokens.
+
+#### KV Cache effect
+
+No direct invalidation; the named consumer owns any request-prefix changes.
+
+## Known Limitations and Deferred Work
+
+- **One provider per context** — there is no routing or fan-out to multiple UIs; a second registration throws `DUPLICATE_PROVIDER`, and with none registered `ask()` throws `NO_PROVIDER` rather than degrading.
+- **The vocabulary is the question-form shape only** — selectable options plus optional custom text; richer interaction shapes (file pickers, diff-preview confirmations) have no seam vocabulary yet.

package/README.zh.md

@@ -0,0 +1,46 @@
+# @hasna-internal/kai-user-questions
+
+[English](README.md) | 中文
+
+用户交互 Service Definition。它定义 `ctx.userQuestions`，供面向模型的工具或权限插件在需要暂停工作并询问人类决定时使用。
+
+## 服务：`UserQuestionService`（ctx 键：`userQuestions`）
+
+### 公开 API
+
+- `ctx.userQuestions.registerProvider(provider): () => void` 注册 UI 侧提供方。同一上下文中只能有一个活跃提供方；dispose（资源释放）会将其注销。
+- `ctx.userQuestions.ask(request): Promise<AskUserQuestionAnswer>` 向活跃提供方提问并等待回答。
+
+### 关键类型
+
+- `AskUserQuestionRequest`：`{ questions: [{ id, question, detail?, header?, options?, multiSelect?, intent? }], agent?, signal? }`；`detail` 提供辅助文本，提供方会将其随问题一起渲染，而不会将其变成选项标签。如提供 `agent`，它必须与注册表中的存活运行时根 agent（智能体）是同一对象。
+- `AskUserQuestionOption`：`{ label, description? }`。
+- `AskUserQuestionIntent`：`{ kind: 'plan-review', approve }`；即下文的带标签呈现意图。
+- `AskUserQuestionAnswer`：`{ answers: [{ id, selected, custom? }] }`。
+- `UserQuestionProvider`：包含 `ask(request)` 的 UI 实现。
+- `UserQuestionError`：`HarnessError` 的子类，包含 `EMPTY_QUESTIONS`、`BAD_INTENT`、`NO_PROVIDER`、`DUPLICATE_PROVIDER`、`ASK_ABORTED`、`CALLER_NOT_LIVE` 和 `DELEGATED_CALLER` 等代码。
+
+对于单选题，`custom` 会覆盖选中的选项，且 `selected` 为空。对于多选题，`custom` 可以补充 `selected` 中的标签。UI 可以把跳过的条目保留为 `{ id, selected: [] }`，既维持现有回答形态，也保留该批次中的其他回答。
+
+请求包含 agent 时，`ask()` 会通过当前 `AgentRegistry` 验证该 agent 与注册表中的存活实例是同一对象，并且只允许运行时根调用。持久谱系不构成权限依据：带有历史委托深度的会话恢复为新的运行时根后可以提问；归属于另一个 agent 的存活子级即使持久化记录的委托深度为零也会被拒绝。不含 agent 的程序化请求继续沿用现有提供方路径。
+
+### 呈现意图
+
+`intent` 声明某个问题本身就是一种已知决策，因此认识该标签的 UI 可以照此呈现——`plan-review` 表示 `detail` 是一份待审阅的计划，`dsh-plan-mode` 会在 `exit_plan_mode` 的问题上设置它。意图只改变呈现：遵循它的 UI 回答的仍是通用 UI 会发送的那些选项标签，不认识该标签的 UI 渲染通用选项列表，因此调用方两种情况下读到的回答字段相同。`approve` 指名表示批准的标签，而不依赖选项顺序。有两项断言无法通过类型表达，`ask()` 会以 `BAD_INTENT` 拒绝它们：`approve` 未命中该问题自身的任一选项，以及意图落在没有 `detail` 的问题上——而 `detail` 正是它自称在审阅的东西。
+
+## 职责
+
+这是 Service Definition 包。`@hasna-internal/kai-tool-ask-user` 等 Consumer 依赖此服务；Web 宿主运行时提供随产品交付的 Service Provider。循环保持不变：工具调用等待 Promise，工具结果随后恢复正常的 agent loop（智能体循环）。
+
+## 模型体验
+
+间接地，通过 `dsh-tool-ask-user`：它会将成功的提供方回答保留为紧凑 JSON，或返回以下失败之一：`Error: ask_user_question was aborted before the user answered`、`Error: ask_user_question requires at least one question`、`Error: human interaction requires the exact live calling agent when an agent is supplied`、`Error: human interaction is unavailable while the calling agent is owned by another live agent; include the unresolved question or decision in the child agent's final result`、`Error: no user-questions provider is registered` 或 `Error: <message>`。等待人类回答不会增加 token。
+
+#### KV Cache 影响
+
+不会直接使 KV Cache 失效；请求前缀的任何变更均由上述消费方负责。
+
+## 已知限制与暂缓事项
+
+- **每个上下文只能有一个提供方**：不支持路由或扇出到多个 UI；第二次注册会抛出 `DUPLICATE_PROVIDER`，未注册任何提供方时，`ask()` 会抛出 `NO_PROVIDER`，而不会降级。
+- **词汇仅包含问题表单形态**：可供选择的选项加可选的自定义文本；更丰富的交互形态（文件选择器、diff 预览确认）尚无 seam 词汇。

package/lib/index.js

@@ -0,0 +1,76 @@
+import { Service } from "@deepseek-ai/cordis";
+import { HarnessError } from "@hasna-internal/kai-llm";
+//#region lib/types/index.js
+/**
+* Service Definition for the user-questions capability seam (`ctx.userQuestions`): a UI-backed service for
+* pausing an agent tool call until the human answers a question. The model-
+* facing tool lives in `@hasna-internal/kai-tool-ask-user`; UI packages provide
+* the single active provider.
+*
+* @module @hasna-internal/kai-user-questions
+*/
+/** Stable error taxonomy for user-questions failures. */
+var UserQuestionError = class extends HarnessError {
+	constructor(message, code, options) {
+		super(message, code, options);
+		this.name = "UserQuestionError";
+	}
+};
+/** `ctx.userQuestions`: one active UI provider plus an `ask()` API. */
+var UserQuestionService = class extends Service {
+	provider;
+	constructor(ctx) {
+		super(ctx, "userQuestions");
+	}
+	/**
+	* Register the UI provider. Only one provider may be active in a context.
+	*
+	* @param provider UI-side implementation that collects answers.
+	* @returns Disposer that unregisters this provider.
+	*/
+	registerProvider(provider) {
+		const dispose = this.ctx.effect(function* () {
+			if (this.provider !== void 0) throw new UserQuestionError("a user-questions provider is already registered", "DUPLICATE_PROVIDER");
+			this.provider = provider;
+			yield () => {
+				this.provider = void 0;
+			};
+		}.bind(this), "userInteraction.registerProvider()");
+		return () => void dispose();
+	}
+	/**
+	* Ask the active UI provider and wait for the user's answer.
+	*
+	* When a caller supplies an agent, human interaction is valid only for the
+	* exact live runtime root. Runtime ownership, not durable session lineage,
+	* decides this boundary: an owned child has no human answerer and would
+	* block forever, while a lineage-bearing session resumed as a new runtime
+	* root may ask normally.
+	*
+	* @param request Questions, owner agent, and abort signal.
+	* @returns The answer chosen or typed by the human.
+	* @throws {UserQuestionError} code `CALLER_NOT_LIVE` when a supplied
+	*   agent is not the registry's exact live instance, or `DELEGATED_CALLER`
+	*   when that live agent is owned by another agent.
+	*/
+	async ask(request) {
+		if (request.signal?.aborted) throw new UserQuestionError("ask_user_question was aborted before the user answered", "ASK_ABORTED");
+		if (request.questions.length === 0) throw new UserQuestionError("ask_user_question requires at least one question", "EMPTY_QUESTIONS");
+		const agent = request.agent;
+		if (agent !== void 0) {
+			const agents = this.ctx.get("agents");
+			if (agents === void 0 || agents.get(agent.id) !== agent) throw new UserQuestionError("human interaction requires the exact live calling agent when an agent is supplied", "CALLER_NOT_LIVE");
+			if (!agents.roots().includes(agent)) throw new UserQuestionError("human interaction is unavailable while the calling agent is owned by another live agent; include the unresolved question or decision in the child agent's final result", "DELEGATED_CALLER");
+		}
+		for (const question of request.questions) {
+			const intent = question.intent;
+			if (intent === void 0) continue;
+			if (!(question.options ?? []).some((option) => option.label === intent.approve)) throw new UserQuestionError(`question ${question.id} declares intent ${intent.kind} whose approve label ${JSON.stringify(intent.approve)} names none of its options`, "BAD_INTENT");
+			if (question.detail === void 0) throw new UserQuestionError(`question ${question.id} declares intent ${intent.kind} without the detail it reviews`, "BAD_INTENT");
+		}
+		if (this.provider === void 0) throw new UserQuestionError("no user-questions provider is registered", "NO_PROVIDER");
+		return this.provider.ask(request);
+	}
+};
+//#endregion
+export { UserQuestionError, UserQuestionService, UserQuestionService as default };

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@hasna-internal/kai-user-questions`.
+* @module @hasna-internal/kai-user-questions/invariant
+*/
+const PACKAGE_NAME = "@hasna-internal/kai-user-questions";
+/** Cordis companion plugin name. */
+const name = "user-questions-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the single provider slot is validated at registration and asks return
+* directly to their caller; the seam publishes no independent request/answer audit stream.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Service Definition for the user-questions capability seam (`ctx.userQuestions`): a UI-backed service for
+ * pausing an agent tool call until the human answers a question. The model-
+ * facing tool lives in `@hasna-internal/kai-tool-ask-user`; UI packages provide
+ * the single active provider.
+ *
+ * @module @hasna-internal/kai-user-questions
+ */
+import { Context, Service } from '@deepseek-ai/cordis';
+import type { Agent } from '@hasna-internal/kai-agent';
+import { HarnessError } from '@hasna-internal/kai-llm';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        userQuestions: UserQuestionService;
+    }
+}
+import type { AskUserQuestionAnswer, AskUserQuestionItem } from './types.ts';
+export type { AskUserQuestionAnswer, AskUserQuestionAnswerItem, AskUserQuestionIntent, AskUserQuestionItem, AskUserQuestionOption, } from './types.ts';
+/** Request for a human answer. */
+export interface AskUserQuestionRequest {
+    /** Questions to display. */
+    questions: AskUserQuestionItem[];
+    /** Exact live calling agent, when the request came from an agent tool call. */
+    agent?: Agent;
+    /** Abort signal for the owning tool/step. */
+    signal?: AbortSignal;
+}
+/** UI-side provider for user questions. */
+export interface UserQuestionProvider {
+    ask(request: AskUserQuestionRequest): Promise<AskUserQuestionAnswer>;
+}
+/** Stable error taxonomy for user-questions failures. */
+export declare class UserQuestionError extends HarnessError {
+    constructor(message: string, code: string, options?: ErrorOptions);
+}
+/** `ctx.userQuestions`: one active UI provider plus an `ask()` API. */
+export declare class UserQuestionService extends Service {
+    private provider;
+    constructor(ctx: Context);
+    /**
+     * Register the UI provider. Only one provider may be active in a context.
+     *
+     * @param provider UI-side implementation that collects answers.
+     * @returns Disposer that unregisters this provider.
+     */
+    registerProvider(provider: UserQuestionProvider): () => void;
+    /**
+     * Ask the active UI provider and wait for the user's answer.
+     *
+     * When a caller supplies an agent, human interaction is valid only for the
+     * exact live runtime root. Runtime ownership, not durable session lineage,
+     * decides this boundary: an owned child has no human answerer and would
+     * block forever, while a lineage-bearing session resumed as a new runtime
+     * root may ask normally.
+     *
+     * @param request Questions, owner agent, and abort signal.
+     * @returns The answer chosen or typed by the human.
+     * @throws {UserQuestionError} code `CALLER_NOT_LIVE` when a supplied
+     *   agent is not the registry's exact live instance, or `DELEGATED_CALLER`
+     *   when that live agent is owned by another agent.
+     */
+    ask(request: AskUserQuestionRequest): Promise<AskUserQuestionAnswer>;
+}
+export default UserQuestionService;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,101 @@
+/**
+ * Service Definition for the user-questions capability seam (`ctx.userQuestions`): a UI-backed service for
+ * pausing an agent tool call until the human answers a question. The model-
+ * facing tool lives in `@hasna-internal/kai-tool-ask-user`; UI packages provide
+ * the single active provider.
+ *
+ * @module @hasna-internal/kai-user-questions
+ */
+import { Service } from '@deepseek-ai/cordis';
+import { HarnessError } from '@hasna-internal/kai-llm';
+/** Stable error taxonomy for user-questions failures. */
+export class UserQuestionError extends HarnessError {
+    constructor(message, code, options) {
+        super(message, code, options);
+        this.name = 'UserQuestionError';
+    }
+}
+/** `ctx.userQuestions`: one active UI provider plus an `ask()` API. */
+export class UserQuestionService extends Service {
+    provider;
+    constructor(ctx) {
+        super(ctx, 'userQuestions');
+    }
+    /**
+     * Register the UI provider. Only one provider may be active in a context.
+     *
+     * @param provider UI-side implementation that collects answers.
+     * @returns Disposer that unregisters this provider.
+     */
+    registerProvider(provider) {
+        const dispose = this.ctx.effect(function* () {
+            if (this.provider !== undefined) {
+                throw new UserQuestionError('a user-questions provider is already registered', 'DUPLICATE_PROVIDER');
+            }
+            this.provider = provider;
+            yield () => {
+                this.provider = undefined;
+            };
+        }.bind(this), 'userInteraction.registerProvider()');
+        return () => void dispose();
+    }
+    /**
+     * Ask the active UI provider and wait for the user's answer.
+     *
+     * When a caller supplies an agent, human interaction is valid only for the
+     * exact live runtime root. Runtime ownership, not durable session lineage,
+     * decides this boundary: an owned child has no human answerer and would
+     * block forever, while a lineage-bearing session resumed as a new runtime
+     * root may ask normally.
+     *
+     * @param request Questions, owner agent, and abort signal.
+     * @returns The answer chosen or typed by the human.
+     * @throws {UserQuestionError} code `CALLER_NOT_LIVE` when a supplied
+     *   agent is not the registry's exact live instance, or `DELEGATED_CALLER`
+     *   when that live agent is owned by another agent.
+     */
+    async ask(request) {
+        if (request.signal?.aborted) {
+            throw new UserQuestionError('ask_user_question was aborted before the user answered', 'ASK_ABORTED');
+        }
+        if (request.questions.length === 0) {
+            throw new UserQuestionError('ask_user_question requires at least one question', 'EMPTY_QUESTIONS');
+        }
+        const agent = request.agent;
+        if (agent !== undefined) {
+            const agents = this.ctx.get('agents');
+            if (agents === undefined || agents.get(agent.id) !== agent) {
+                throw new UserQuestionError('human interaction requires the exact live calling agent when an agent is supplied', 'CALLER_NOT_LIVE');
+            }
+            if (!agents.roots().includes(agent)) {
+                throw new UserQuestionError('human interaction is unavailable while the calling agent is owned by another live agent; '
+                    + "include the unresolved question or decision in the child agent's final result", 'DELEGATED_CALLER');
+            }
+        }
+        // A presentation intent asserts two things the types cannot: that the
+        // named approve label is one of this question's own options, and that a
+        // plan-review carries the plan it is a review of. A UI honouring the
+        // intent answers with that label, and shows that detail as the plan, so
+        // either gap would put a choice the asker never offered — or an approval of
+        // something invisible — in front of the user. Caught at the asker, where
+        // the mistake is, rather than in each UI.
+        for (const question of request.questions) {
+            const intent = question.intent;
+            if (intent === undefined)
+                continue;
+            if (!(question.options ?? []).some(option => option.label === intent.approve)) {
+                throw new UserQuestionError(`question ${question.id} declares intent ${intent.kind} whose approve label `
+                    + `${JSON.stringify(intent.approve)} names none of its options`, 'BAD_INTENT');
+            }
+            if (question.detail === undefined) {
+                throw new UserQuestionError(`question ${question.id} declares intent ${intent.kind} without the detail it reviews`, 'BAD_INTENT');
+            }
+        }
+        if (this.provider === undefined) {
+            throw new UserQuestionError('no user-questions provider is registered', 'NO_PROVIDER');
+        }
+        return this.provider.ask(request);
+    }
+}
+export default UserQuestionService;
+//# sourceMappingURL=index.js.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@hasna-internal/kai-user-questions`.
+ * @module @hasna-internal/kai-user-questions/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "user-questions-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,22 @@
+/**
+ * Package-owned invariant companion for `@hasna-internal/kai-user-questions`.
+ * @module @hasna-internal/kai-user-questions/invariant
+ */
+const PACKAGE_NAME = '@hasna-internal/kai-user-questions';
+/** Cordis companion plugin name. */
+export const name = 'user-questions-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/**
+ * No runtime invariant: the single provider slot is validated at registration and asks return
+ * directly to their caller; the seam publishes no independent request/answer audit stream.
+ */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */
+//# sourceMappingURL=invariant.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Wire-safe question and answer types, free of cordis/service imports so browser
+ * type chains (apiproxy api → client) can consume them without loading this
+ * package's Context augmentation.
+ * @module @hasna-internal/kai-user-questions/types
+ */
+/** One selectable answer offered to the user. */
+export interface AskUserQuestionOption {
+    /** User-facing label. */
+    label: string;
+    /** Optional extra context rendered by capable UIs. */
+    description?: string;
+}
+/**
+ * A caller-declared presentation intent: the question IS this kind of
+ * decision, so a UI that recognises the tag may present it as such instead of as a
+ * generic option list. Tagged so further intents can be added; a UI that does
+ * not know a tag renders the generic flow, and the answer encoding is identical
+ * either way — an intent changes presentation only, never the protocol.
+ */
+export type AskUserQuestionIntent = {
+    /** A plan submitted for review: `detail` is the plan markdown `ask()` requires, and the decision approves or declines it. */
+    kind: 'plan-review';
+    /**
+     * The option label that approves the plan; every other option declines it.
+     * Named rather than positional so no UI infers the verdict from option order.
+     * An `approve` naming no option of its own question is rejected at `ask()`.
+     */
+    approve: string;
+};
+/** One question in a user-questions request. */
+export interface AskUserQuestionItem {
+    /** Stable caller-provided question id, echoed in the answer. */
+    id: string;
+    /** The question to display. */
+    question: string;
+    /** Optional supporting detail rendered with the question but kept out of option labels. */
+    detail?: string;
+    /** Optional short heading/group label. */
+    header?: string;
+    /** Optional choices the UI can render as a menu. */
+    options?: AskUserQuestionOption[];
+    /** Whether more than one option may be selected. Defaults to single-select. */
+    multiSelect?: boolean;
+    /** Optional presentation intent for capable UIs; absent asks for the generic option list. */
+    intent?: AskUserQuestionIntent;
+}
+/** Answer to one question. */
+export interface AskUserQuestionAnswerItem {
+    /** The answered question id. */
+    id: string;
+    /** Selected option labels. May accompany custom text for a multi-select question. */
+    selected: string[];
+    /** Optional free-text "Other" answer. */
+    custom?: string;
+}
+/** The human's answer. */
+export interface AskUserQuestionAnswer {
+    /** Structured answers keyed by question id. */
+    answers: AskUserQuestionAnswerItem[];
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,8 @@
+/**
+ * Wire-safe question and answer types, free of cordis/service imports so browser
+ * type chains (apiproxy api → client) can consume them without loading this
+ * package's Context augmentation.
+ * @module @hasna-internal/kai-user-questions/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@hasna-internal/kai-user-questions",
+  "description": "Abstract user-questions seam (ctx.userQuestions) for asking the human during agent runs",
+  "version": "0.1.1-rc.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/interaction/user-questions"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@hasna-internal/kai-agent": "^0.1.1-rc.2",
+    "@hasna-internal/kai-invariants": "^0.1.1-rc.2",
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@hasna-internal/kai-llm": "^0.1.1-rc.2"
+  },
+  "devDependencies": {
+    "@hasna-internal/kai-agent": "^0.1.1-rc.2",
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@hasna-internal/kai-invariants": "^0.1.1-rc.2",
+    "@hasna-internal/kai-llm": "^0.1.1-rc.2"
+  }
+}