dsh-remote-bridge 2.2.1 → 2.2.2

package/docs/api/asyncapi.yaml

@@ -1,7 +1,7 @@
 asyncapi: 3.0.0
 info:
   title: DeepSeek Harness Mobile Events
-  version: 2.2.1
+  version: 2.2.2
   description: Live file and authorized DSH chat events. Reconnect clients must refresh REST state; unbounded replay is not provided.
 servers:
   local:

package/docs/api/openapi.yaml

@@ -1,7 +1,7 @@
 openapi: 3.1.0
 info:
   title: DeepSeek Harness Mobile API
-  version: 2.2.1
+  version: 2.2.2
   description: Versioned file and chat BFF for mobile and third-party DSH clients. HTTP and HTTPS are both supported.
 servers:
   - url: http://127.0.0.1:3090/api/v1
@@ -582,6 +582,102 @@ paths:
       responses:
         '202': { description: Decision accepted by DSH. }
         '409': { $ref: '#/components/responses/Error' }
+  /chat/sessions/{sessionId}/questions:
+    get:
+      operationId: listUserQuestions
+      description: |
+        Lists questions an agent is waiting on, from two sources merged together:
+        the ones this bridge is holding open (an `ask_user_question` call with no
+        `timeout`, taken over from the host's `user-questions/request` waterfall),
+        and the ones the kernel still accepts a late answer for (`continued`).
+        A question held open is reported first; the same `callId` never appears twice.
+        The `viaBridge` flag distinguishes the two. An unknown or inactive session
+        yields an empty list rather than an error.
+      parameters:
+        - name: sessionId
+          in: path
+          required: true
+          schema: { type: string }
+      responses:
+        '200':
+          description: Questions the current device may answer.
+          content:
+            application/json:
+              schema:
+                type: object
+                required: [items]
+                properties:
+                  items:
+                    type: array
+                    items:
+                      type: object
+                      required: [callId, state, questions]
+                      properties:
+                        callId: { type: string }
+                        state: { type: string, enum: [continued] }
+                        viaBridge:
+                          type: boolean
+                          description: True when the bridge is holding this question open, so the agent is blocked on it right now.
+                        questions:
+                          type: array
+                          items:
+                            type: object
+                            required: [id, question]
+                            properties:
+                              id: { type: string }
+                              question: { type: string }
+                              header: { type: string }
+                              detail: { type: string }
+                              multiSelect: { type: boolean }
+                              options:
+                                type: array
+                                items:
+                                  type: object
+                                  required: [label]
+                                  properties:
+                                    label: { type: string }
+                                    description: { type: string }
+        '404': { $ref: '#/components/responses/Error' }
+  /chat/sessions/{sessionId}/questions/{callId}/answer:
+    post:
+      operationId: answerUserQuestion
+      description: |
+        Answers one question set. Answers for a question the bridge holds open are
+        delivered as the return value of the tool call that is waiting; answers for a
+        `continued` question are steered into the session as a new turn. The
+        `selected` array carries option labels and must match the question's own
+        options; use `custom` for free text.
+      parameters:
+        - name: sessionId
+          in: path
+          required: true
+          schema: { type: string }
+        - name: callId
+          in: path
+          required: true
+          schema: { type: string }
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [answers]
+              properties:
+                answers:
+                  type: array
+                  items:
+                    type: object
+                    required: [id, selected]
+                    properties:
+                      id: { type: string }
+                      selected: { type: array, items: { type: string } }
+                      custom: { type: string }
+      responses:
+        '202': { description: Answer accepted. }
+        '400': { $ref: '#/components/responses/Error' }
+        '409': { $ref: '#/components/responses/Error' }
+        '503': { $ref: '#/components/responses/Error' }
   /chat/sessions/{sessionId}/commands:
     get:
       operationId: listSessionCommands

package/lib/index.d.ts

@@ -337,6 +337,36 @@ interface DshApiProxy {
       agentPreset: string;
     }>>;
   };
+  /**
+   * 用户问题（内核 `ctx.userQuestions`，即 ask_user_question 工具）。
+   *
+   * 为什么单开一个命名空间而不是塞进 `sessions`：它由**另一个内核服务**提供
+   * （`@deepseek-ai/dsh-user-questions`），在一条没装它的 profile 上是**可选能力** ——
+   * 分开之后，「这个能力不在」和「这个会话有问题」在类型上就分得开。
+   */
+  userQuestions: {
+    /**
+     * 列出还能回答的问题（内核 `continued(agent)`）。
+     * 没有 live agent、或没有该服务时返回空列表 —— 冷会话是常态，不该报错。
+     */
+    list(request: {
+      rpcId: string;
+      payload: {
+        sessionId: string;
+      };
+    }): Promise<RpcResponse<{
+      items: UserQuestionView[];
+    }>>;
+    /** 提交答案；失败原因见 [UserQuestionAnswerOutcome]。 */
+    answer(request: {
+      rpcId: string;
+      payload: {
+        sessionId: string;
+        callId: string;
+        answer: UserQuestionAnswer;
+      };
+    }): Promise<RpcResponse<UserQuestionAnswerOutcome>>;
+  };
   events: {
     mux(request: {
       rpcId: string;
@@ -468,6 +498,60 @@ interface PendingApprovalView {
   risk: 'standard' | 'full-access';
   requestedAt: number;
 }
+/**
+ * 一条「还能回答」的用户问题 —— 内核 `userQuestions.continued()` 的一行。
+ *
+ * 为什么类型是宽松的、而不是照抄内核的 `AskUserQuestionItem`：内核往 item 或
+ * question 上加过字段（`intent` 就是一例），手机端该自己决定要不要用，
+ * 不该等插件跟着发版。所以这里只钉住三个**契约字段**，其余原样透传。
+ */
+interface UserQuestionView {
+  callId: string;
+  /** 内核 `UserQuestionState`：'open' 或 'continued'；本端点只返回 continued。 */
+  state: string;
+  /** 问题项**原样**透传（id / question / detail? / header? / options? / multiSelect? / intent?）。 */
+  questions: unknown[];
+  /** 内核以后加的字段照样透传，不在这里裁剪。 */
+  [key: string]: unknown;
+}
+/** 一条问题的答案（内核 `AskUserQuestionAnswerItem`）。 */
+interface UserQuestionAnswerItem {
+  /** 被回答的问题 id，必须与请求里的问题 id 对上。 */
+  id: string;
+  /** 选中的选项 label；多选时可能多项。 */
+  selected: string[];
+  /** 可选的「其他」自由文本。 */
+  custom?: string;
+}
+/** 一次提交的完整答案批次（内核 `AskUserQuestionAnswer`）：一次调用里的每个问题各占一项。 */
+interface UserQuestionAnswer {
+  answers: UserQuestionAnswerItem[];
+}
+/**
+ * 「把答案送进内核」的结果。
+ *
+ * 刻意**不走 RpcResponse 的 error 通道**：`unwrapDsh` 只认 `not-found` /
+ * `busy` / `locked` 三种 code 去映射 HTTP 状态，其余一律 400 —— 而这里需要区分
+ * 409 / 400 / 503。做成**值**之后由 adapter 决定 HTTP 状态，
+ * 和 approvals 的 `respond()` 返回 `{ accepted: false, reason }` 是同一个套路。
+ */
+type UserQuestionAnswerFailure =
+/** 内核里没有这个 callId 的悬空问题（`answer()` 返回了 false）。 */
+'not-pending' |
+/** 已经有一条回复在排队（内核 `REPLY_QUEUED`）。重复提交不是服务器故障。 */
+'reply-queued' |
+/** 答案批次没有「一问一答」地对齐（内核 `BAD_ANSWER`）。 */
+'answer-invalid' |
+/** 这个 agent 现在不接受人工回答（非 live root / 被别的 agent 拥有），或会话没有 live agent。 */
+'not-answerable' |
+/** 这套 DSH 构建里压根没有 `ctx.userQuestions` 服务。 */
+'unavailable';
+type UserQuestionAnswerOutcome = {
+  accepted: true;
+} | {
+  accepted: false;
+  reason: UserQuestionAnswerFailure;
+};
 interface ChatWorkspaceView {
   id: string;
   title: string;
@@ -556,6 +640,22 @@ declare class DshChatAdapter {
   archiveSession(principal: Principal, sessionId: string): Promise<string[]>;
   listPendingApprovals(principal: Principal, sessionId: string): Promise<PendingApprovalView[]>;
   decideApproval(principal: Principal, sessionId: string, approvalId: string, outcome: 'allowed-once' | 'rejected'): Promise<PendingApprovalView>;
+  /**
+   * 列出「agent 正在等、且还能回答」的用户问题。
+   *
+   * 口径与 [listPendingApprovals] 一致：先 requireSession（会话对本设备不可见 → 404），
+   * 再问内核；字段一个都不裁 —— 客户端照着渲染，内核加字段不用改插件。
+   */
+  listUserQuestions(principal: Principal, sessionId: string): Promise<UserQuestionView[]>;
+  /**
+   * 把一次答案提交给内核。
+   *
+   * 失败原因全部由 `api.userQuestions.answer` 以**值**给出（见 [UserQuestionAnswerOutcome]），
+   * 这里翻成 HTTP 语义：503 能力缺失 / 409 状态冲突 / 400 批次不合法。
+   * 为什么不在 bridge 里直接抛：`unwrapDsh` 只把 `not-found` / `busy` / `locked`
+   * 映成 404/409，其余一律 400 —— 表达不了这几种区别。
+   */
+  answerUserQuestion(principal: Principal, sessionId: string, callId: string, answer: UserQuestionAnswer): Promise<void>;
   models(principal: Principal, sessionId: string): Promise<SessionModelsView>;
   selectModel(principal: Principal, sessionId: string, selection: ModelSelectionView): Promise<ModelSelectionView>;
   listCommands(principal: Principal, sessionId: string): Promise<CommandDescriptorView[]>;

package/lib/index.js

@@ -513,6 +513,46 @@ var DshChatAdapter = class {
 		this.pendingApprovals.delete(key);
 		return publicApproval(pending);
 	}
+	/**
+	* 列出「agent 正在等、且还能回答」的用户问题。
+	*
+	* 口径与 [listPendingApprovals] 一致：先 requireSession（会话对本设备不可见 → 404），
+	* 再问内核；字段一个都不裁 —— 客户端照着渲染，内核加字段不用改插件。
+	*/
+	async listUserQuestions(principal, sessionId) {
+		await this.requireSession(principal, sessionId);
+		return unwrapDsh(await this.api.userQuestions.list({
+			rpcId: randomUUID(),
+			payload: { sessionId }
+		})).items;
+	}
+	/**
+	* 把一次答案提交给内核。
+	*
+	* 失败原因全部由 `api.userQuestions.answer` 以**值**给出（见 [UserQuestionAnswerOutcome]），
+	* 这里翻成 HTTP 语义：503 能力缺失 / 409 状态冲突 / 400 批次不合法。
+	* 为什么不在 bridge 里直接抛：`unwrapDsh` 只把 `not-found` / `busy` / `locked`
+	* 映成 404/409，其余一律 400 —— 表达不了这几种区别。
+	*/
+	async answerUserQuestion(principal, sessionId, callId, answer) {
+		await this.requireSession(principal, sessionId);
+		const outcome = unwrapDsh(await this.api.userQuestions.answer({
+			rpcId: randomUUID(),
+			payload: {
+				sessionId,
+				callId,
+				answer
+			}
+		}));
+		if (outcome.accepted) return;
+		switch (outcome.reason) {
+			case "unavailable": throw new ApiError(503, "USER_QUESTIONS_UNAVAILABLE", "This DSH build provides no ctx.userQuestions service, so questions cannot be answered.");
+			case "not-pending": throw new ApiError(409, "QUESTION_NOT_PENDING", "This question is no longer pending.");
+			case "reply-queued": throw new ApiError(409, "QUESTION_REPLY_QUEUED", "A reply is already queued for this question.");
+			case "not-answerable": throw new ApiError(409, "QUESTION_NOT_ANSWERABLE", "This session cannot answer questions right now: its agent is not the live root.");
+			case "answer-invalid": throw new ApiError(400, "QUESTION_ANSWER_INVALID", "The answer batch must name each question of the call exactly once.");
+		}
+	}
 	async models(principal, sessionId) {
 		await this.requireSession(principal, sessionId);
 		return unwrapDsh(await this.api.sessions.models({
@@ -1187,6 +1227,72 @@ function optionalService(host, name) {
 		return null;
 	}
 }
+/**
+* 容错取 Agent 作用域上的 `userQuestions` 服务；拿不到就返回 `null`。
+*
+* 依据（全部实测，不是推断）：
+* - `agent.ctx` 是内核声明的字段：`@deepseek-ai/dsh-agent` 的
+*   `lib/types/runtime-types.d.ts`（`interface Agent { readonly ctx: Context }`）。
+* - `ctx.get(name)` 由 cordis 混入 `ctx`：`@deepseek-ai/cordis/lib/index.js` 里
+*   `this.mixin("reflect", ["get", "set", "provide", "accessor", "mixin"])`；
+*   同一文件的 `get(name, strict = true)` 在没人提供该服务时返回 `undefined`，**不抛**。
+* - 内核自己也这么取：`dsh-user-questions/lib/types/index.js` 里
+*   `this.ctx.get('agents')` / `this.ctx.get('sessionProjections')`。
+*
+* 即便如此仍做三层防御（ctx 形状 → get 是不是函数 → try/catch）：这是**可选能力**，
+* 没装它的 profile 只该少一个功能，不该让整个插件激活失败 —— attachments /
+* fileUploads 已经用两次线上事故教过这个道理。
+*/
+function userQuestionsOf(agent) {
+	if (agent === null || typeof agent !== "object") return null;
+	const ctx = agent.ctx;
+	if (ctx === null || ctx === void 0 || typeof ctx !== "object") return null;
+	const get = ctx.get;
+	if (typeof get !== "function") return null;
+	try {
+		const service = get.call(ctx, "userQuestions");
+		return service !== null && typeof service === "object" ? service : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 内核的一行 `PendingUserQuestion` → 对外 view。
+*
+* 只钉三个契约字段（callId / state / questions），其余**原样透传**：内核以后往 item
+* 或 question 上加字段，手机端自己决定要不要用，插件不用跟着发版。
+* 缺 callId 或 questions 的行直接丢掉，而不是把残缺的行发给客户端。
+*/
+function toUserQuestionView(value) {
+	if (value === null || typeof value !== "object") return void 0;
+	const row = value;
+	const callId = row["callId"];
+	const questions = row["questions"];
+	if (typeof callId !== "string" || callId === "" || !Array.isArray(questions)) return void 0;
+	const state = row["state"];
+	return {
+		...row,
+		callId,
+		state: typeof state === "string" ? state : "continued",
+		questions: [...questions]
+	};
+}
+/**
+* 内核异常的 `code`，取不到就 `undefined`。
+*
+* 不看 `instanceof`（跨包副本 / 跨 realm 会失手），只认 `HarnessError` 上那个
+* 「稳定、可编程路由」的 `code`：`@deepseek-ai/dsh-llm` 的 `lib/types/error.js` 里
+* `HarnessError` 就是 `this.code = code`（`name` 也被设成子类名）。
+*/
+function errorCodeOf(error) {
+	if (error === null || typeof error !== "object") return void 0;
+	const code = error.code;
+	return typeof code === "string" ? code : void 0;
+}
+/** 会话没有 live agent —— `agentFor()` 抛的正是这个 code。 */
+function isAgentUnavailable(error) {
+	return errorCodeOf(error) === "session/agent-unavailable";
+}
 function ok(value) {
 	return { result: {
 		ok: true,
@@ -1443,6 +1549,175 @@ var ApprovalBridge = class {
 		return { accepted: true };
 	}
 };
+/**
+* 同一时刻最多挂起多少条前台提问：超了就把后来的直接委托给官方 UI。
+* 不做无上限的挂起表 —— 失控的 agent 能问出任意多问题，每条都吊着一个 Promise。
+*/
+const MAX_PENDING_QUESTIONS = 32;
+/**
+* `user-questions/request` 的接管者 —— 形状照 [ApprovalBridge]。
+*
+* 为什么非接不可：`ask_user_question` 只有在**参数 schema 声明了 `timeout`** 时才走
+* 「前台限时等待 → 超时转 `continued`」那条路（`dsh-user-questions/lib/types/projection.js`
+* 的 `isTimedAskUserQuestionSchema` 查 `tool.parameters.properties.timeout`），
+* 而实测 15 个真实调用的参数键清一色只有 `questions`。也就是说绝大多数提问**不进投影**，
+* `GET /questions` 永远查不到它们；它们只经过这条 Cordis waterfall 事件
+* （`types.d.ts:136-147`）。官方 WebUI 接了这个事件 → 电脑端看得到、手机端看不到。
+*
+* 三处与 approvals 不同，都是内核契约决定的、不是选择：
+* 1. **先委托，再竞速 —— 两端都能答**：进入时立刻调一次 `next()`（把这条请求交给
+*    后面的监听者，也就是官方 WebUI 那条远端 answerer），同时自己挂一张卡给 App，
+*    然后 `Promise.race`：谁先给出答案就算谁的。
+*    这与 ApprovalBridge 不同（它是「接管 = 否决下游」，cordis `lib/index.js:307-325`
+*    的文档原话：a listener that does not call next() vetoes the rest of the chain）——
+*    审批那边先不调，问题这边先调。代价是两端各有一张卡，后答的那张会变陈旧
+*    （客户端会收到 409「已不再等待」，语义正确）。
+* 2. **`this` 不能当 agent 用**：dispatcher 把它绑成 `scopeTarget(agent, agent)`
+*    （`lib/types/index.js:327`），而 `Scoped<T>` 明确写着
+*    「routing-only … does not expose the subject's properties」
+*    （`@deepseek-ai/dsh-scope/lib/types/index.d.ts:14-20`）。
+*    真 agent 只在 `request.agent` 里；官方 WebUI 也是另找 session
+*    （`ctx.sessions.scopeOf(this)`），而不是读 `this.session`。
+* 3. 回调必须是**普通函数**：cordis 用 `callback.bind(thisArg)` 绑定作用域载体
+*   （cordis `lib/index.js:263`）。本实现不依赖 `this`，但签名保持与内核契约一致。
+*/
+var QuestionBridge = class {
+	host;
+	mux;
+	pending = /* @__PURE__ */ new Map();
+	constructor(host, mux) {
+		this.host = host;
+		this.mux = mux;
+	}
+	/** Register the answerer once, during plugin activation. */
+	attach() {
+		const bridge = this;
+		this.host.on("user-questions/request", async function(...args) {
+			const request = args[0];
+			const next = args[args.length - 1];
+			const delegate = (async () => {
+				if (typeof next !== "function") throw new Error("user-questions/request was dispatched without a next() delegate");
+				return next();
+			})();
+			delegate.catch(() => {});
+			const sessionId = sessionIdOfAgent(request?.agent);
+			const questions = Array.isArray(request?.questions) ? [...request.questions] : void 0;
+			const callId = (typeof request?.wait?.callId === "string" && request.wait.callId !== "" ? request.wait.callId : void 0) ?? `bridge-${randomUUID()}`;
+			if (sessionId === void 0 || questions === void 0 || questions.length === 0) return delegate;
+			if (request?.signal?.aborted === true) return delegate;
+			if (bridge.pending.size >= MAX_PENDING_QUESTIONS) return delegate;
+			const rpcId = randomUUID();
+			const held = new Promise((resolve) => {
+				let done = false;
+				const settle = (value) => {
+					if (done) return;
+					done = true;
+					resolve(value);
+				};
+				bridge.pending.set(rpcId, {
+					sessionId,
+					callId,
+					questions,
+					settle
+				});
+				request?.signal?.addEventListener("abort", () => {
+					bridge.pending.delete(rpcId);
+					settle({ kind: "dismissed" });
+				}, { once: true });
+				bridge.mux.push({
+					type: "userQuestions/requested",
+					sessionId,
+					callId,
+					rpcId,
+					questions
+				});
+			});
+			const first = await Promise.race([delegate.then(() => ({ kind: "delegated" }), () => new Promise(() => {})), held]);
+			if (first.kind === "answered") {
+				bridge.pending.delete(rpcId);
+				bridge.mux.push({
+					type: "userQuestions/answered",
+					sessionId,
+					callId,
+					rpcId
+				});
+				return first.answer;
+			}
+			bridge.pending.delete(rpcId);
+			bridge.mux.push({
+				type: "userQuestions/dismissed",
+				sessionId,
+				callId,
+				rpcId
+			});
+			return await delegate;
+		});
+	}
+	/**
+	* 回答一条**正挂在前台等待**的提问（App 通过 `POST …/answer` 打进来）。
+	*
+	* 与 [ApprovalBridge.respond] 同形：按 (sessionId, callId) **精确**找挂起项；
+	* 找不到就报 `not-pending`，绝不挑一条最近的来答 —— 答错会话的代价太大。
+	*/
+	answer(request) {
+		if (!isUserQuestionAnswerLike(request.answer)) return {
+			accepted: false,
+			reason: "bad-response"
+		};
+		for (const [rpcId, entry] of this.pending) {
+			if (entry.sessionId !== request.sessionId || entry.callId !== request.callId) continue;
+			this.pending.delete(rpcId);
+			entry.settle({
+				kind: "answered",
+				answer: request.answer
+			});
+			return { accepted: true };
+		}
+		return {
+			accepted: false,
+			reason: "not-pending"
+		};
+	}
+	/**
+	* 某会话当前挂起中的提问（供 `GET /questions` 合并）。
+	*
+	* `state` 刻意报 `'continued'`：客户端（dsh-companion 的 HarnessViewModel:1314）
+	* 只认这一个值（`sets.filter { it.state == QUESTION_STATE_CONTINUED }`），
+	* 报 `'open'` 等于这张卡片永远不显示 —— 而它恰恰是**此刻真正阻塞着 agent** 的那条。
+	* 「这是插件接管的」由新增的 `viaBridge` 标记表达（客户端 decode 是
+	* `ignoreUnknownKeys = true`，加字段安全），将来客户端想换文案/单独过滤都有依据。
+	*/
+	pendingFor(sessionId) {
+		const out = [];
+		for (const entry of this.pending.values()) {
+			if (entry.sessionId !== sessionId) continue;
+			out.push({
+				callId: entry.callId,
+				state: "continued",
+				questions: [...entry.questions],
+				viaBridge: true
+			});
+		}
+		return out;
+	}
+};
+/**
+* 答案批次的最小校验（路由层已校验过一遍，这里是防御性第二道）。
+*
+* 只查「能不能安全喂给内核」：对象、`answers` 非空数组、每项 `id` 是非空字符串、
+* `selected` 是字符串数组。更细的「一问一答对齐」由内核自己判（BAD_ANSWER）。
+*/
+function isUserQuestionAnswerLike(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const answers = value.answers;
+	if (!Array.isArray(answers) || answers.length === 0) return false;
+	return answers.every((item) => {
+		if (item === null || typeof item !== "object" || Array.isArray(item)) return false;
+		const entry = item;
+		if (typeof entry.id !== "string" || entry.id === "") return false;
+		return Array.isArray(entry.selected) && entry.selected.every((label) => typeof label === "string");
+	});
+}
 /** Best-effort projection of an Agent identity to its session id. */
 function sessionIdOfAgent(agent) {
 	if (!agent || typeof agent !== "object") return void 0;
@@ -1473,6 +1748,8 @@ function createDsh02ApiProxy(host) {
 	const fileUploadService = optionalService(host, "fileUploads");
 	const approvals = new ApprovalBridge(host, mux);
 	approvals.attach();
+	const questions = new QuestionBridge(host, mux);
+	questions.attach();
 	const relay = new SessionEventRelay(host, mux);
 	host.on("api-session/added", (summary) => {
 		const sessionId = sessionIdOf(summary);
@@ -1517,6 +1794,21 @@ function createDsh02ApiProxy(host) {
 		if (agent === void 0 || agent === null) throw Object.assign(/* @__PURE__ */ new Error(`no live Agent for session ${sessionId}`), { code: "session/agent-unavailable" });
 		return agent;
 	}
+	/**
+	* `agentFor` 的宽松版：把「这个会话没有 live agent」当成**正常情况**（返回 null）。
+	*
+	* 为什么 list 需要它：手机端会对每个会话各拉一次问题列表，而冷会话（没在跑）没有
+	* agent 是常态。把常态报成错误，客户端只会看到一片红。
+	* 只放过 `session/agent-unavailable` 这一个 code，其它异常照旧往上抛。
+	*/
+	async function agentForQuestions(sessionId) {
+		try {
+			return await agentFor(sessionId);
+		} catch (error) {
+			if (isAgentUnavailable(error)) return null;
+			throw error;
+		}
+	}
 	return {
 		respond: (message) => approvals.respond(message),
 		sessions: {
@@ -1655,6 +1947,65 @@ function createDsh02ApiProxy(host) {
 				return { agentPreset: await host.agentPresets.select(agent, request.payload.agentPreset) };
 			})
 		},
+		userQuestions: {
+			list: (request) => call(async () => {
+				const { sessionId } = request.payload;
+				const bridged = questions.pendingFor(sessionId);
+				const bridgedIds = new Set(bridged.map((item) => item.callId));
+				const agent = await agentForQuestions(sessionId);
+				if (agent === null) return { items: bridged };
+				const service = userQuestionsOf(agent);
+				if (service === null || typeof service.continued !== "function") return { items: bridged };
+				const rows = service.continued(agent);
+				const continued = Array.isArray(rows) ? rows.map(toUserQuestionView).filter((item) => item !== void 0) : [];
+				return { items: [...bridged, ...continued.filter((item) => !bridgedIds.has(item.callId))] };
+			}),
+			answer: (request) => call(async () => {
+				const { sessionId, callId, answer } = request.payload;
+				const agent = await agentForQuestions(sessionId);
+				let kernelCouldNotAnswer = false;
+				if (agent !== null) {
+					const service = userQuestionsOf(agent);
+					if (service !== null && typeof service.answer === "function") {
+						let answered;
+						try {
+							answered = await service.answer(agent, callId, answer);
+						} catch (error) {
+							const code = errorCodeOf(error);
+							if (code === "REPLY_QUEUED") return {
+								accepted: false,
+								reason: "reply-queued"
+							};
+							if (code === "BAD_ANSWER") return {
+								accepted: false,
+								reason: "answer-invalid"
+							};
+							if (code === "CALLER_NOT_LIVE" || code === "DELEGATED_CALLER") kernelCouldNotAnswer = true;
+							else throw error;
+						}
+						if (answered === true) return { accepted: true };
+					}
+				}
+				const bridged = questions.answer({
+					sessionId,
+					callId,
+					answer
+				});
+				if (bridged.accepted) return { accepted: true };
+				if (bridged.reason === "bad-response") return {
+					accepted: false,
+					reason: "answer-invalid"
+				};
+				if (kernelCouldNotAnswer) return {
+					accepted: false,
+					reason: "not-answerable"
+				};
+				return {
+					accepted: false,
+					reason: "not-pending"
+				};
+			})
+		},
 		settings: {
 			describe: () => call(() => host.settingsController.describe()),
 			mutate: (request) => call(() => host.settingsController.mutate(request.payload.ns, request.payload.ops, request.payload.expectedRevision))
@@ -2813,6 +3164,29 @@ var ApiRouter = class {
 			sendJson(res, 202, { accepted: true });
 			return;
 		}
+		const questionsRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/questions$/);
+		if (method === "GET" && questionsRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.read");
+			const sessionId = decodeURIComponent(questionsRoute[1]);
+			sendJson(res, 200, { items: await this.options.chat.listUserQuestions(principal, sessionId) });
+			return;
+		}
+		const questionAnswerRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/questions\/([^/]+)\/answer$/);
+		if (method === "POST" && questionAnswerRoute !== null) {
+			this.options.auth.requireScope(principal, "chat.write");
+			const sessionId = decodeURIComponent(questionAnswerRoute[1]);
+			const callId = decodeURIComponent(questionAnswerRoute[2]);
+			const answer = readUserQuestionAnswer(await readJson(req, 64e3));
+			await this.options.chat.answerUserQuestion(principal, sessionId, callId, answer);
+			this.audit(principal, "chat.question.answer", void 0, void 0, requestId, {
+				sessionId,
+				callId,
+				answers: answer.answers.length,
+				questionIds: answer.answers.map((item) => item.id)
+			});
+			sendJson(res, 202, { accepted: true });
+			return;
+		}
 		const sessionModelsRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/model(?:s)?$/);
 		if (sessionModelsRoute !== null) {
 			const sessionId = decodeURIComponent(sessionModelsRoute[1]);
@@ -3168,6 +3542,33 @@ function readPromptParts(body) {
 		throw new ApiError(400, "BODY_INVALID", `content[${index}].type is not supported.`);
 	});
 }
+/**
+* 校验一次答案提交：`{ answers: [{ id, selected[], custom? }] }`。
+*
+* 为什么要逐项校验，而不是把 body 直接透传给内核：这是**用户输入**，
+* 形状不对时内核给的报错更难懂；而且内核的 `answer()` 会检查「一问一答」的对齐，
+* 类型层面能先挡掉的就不要等到那一步。
+*
+* 入参故意收 `unknown`：`readJson` 的返回值可能是 null / 数字 / 数组，
+* 当对象取字段会抛 TypeError 变成 500 —— 非法输入必须是 400。
+*/
+function readUserQuestionAnswer(body) {
+	if (body === null || typeof body !== "object" || Array.isArray(body)) throw new ApiError(400, "BODY_INVALID", "The request body must be a JSON object with an answers array.");
+	const answers = body.answers;
+	if (!Array.isArray(answers) || answers.length === 0) throw new ApiError(400, "BODY_INVALID", "answers must be a non-empty array.");
+	return { answers: answers.map((raw, index) => {
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new ApiError(400, "BODY_INVALID", `answers[${index}] must be an object.`);
+		const item = raw;
+		if (typeof item.id !== "string" || item.id === "") throw new ApiError(400, "BODY_INVALID", `answers[${index}].id is required.`);
+		if (!Array.isArray(item.selected) || item.selected.some((value) => typeof value !== "string")) throw new ApiError(400, "BODY_INVALID", `answers[${index}].selected must be an array of strings.`);
+		if (item.custom !== void 0 && typeof item.custom !== "string") throw new ApiError(400, "BODY_INVALID", `answers[${index}].custom must be a string.`);
+		return {
+			id: item.id,
+			selected: [...item.selected],
+			...item.custom === void 0 ? {} : { custom: item.custom }
+		};
+	}) };
+}
 function validateStringArray(value, name) {
 	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new ApiError(400, "BODY_INVALID", `${name} must be an array of strings.`);
 	return [...new Set(value)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-bridge",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "Versioned REST bridge for DeepSeek Harness: remote access for trusted clients (chat, files, devices) plus a Phone-settings panel inside the DSH WebUI.",
   "type": "module",
   "packageManager": "pnpm@11.19.0",