lark-remote 0.1.7 → 0.1.8

package/dist/runner/codex/app-server/protocol-types.js

@@ -41,10 +41,10 @@ export const ServerRequestMethod = {
     COMMAND_EXECUTION_APPROVAL: 'item/commandExecution/requestApproval',
     FILE_CHANGE_APPROVAL: 'item/fileChange/requestApproval',
     PERMISSIONS_APPROVAL: 'item/permissions/requestApproval',
+    REQUEST_USER_INPUT: 'item/tool/requestUserInput',
 };
 /** Unsupported / ignored server request methods. */
 export const UNSUPPORTED_SERVER_REQUEST_METHODS = new Set([
-    'item/tool/requestUserInput',
     'mcpServer/elicitation/request',
     'item/tool/call',
     'account/chatgptAuthTokens/refresh',

package/dist/runner/codex/app-server/runner.d.ts

@@ -43,6 +43,16 @@ export interface CodexAppServerRunnerOptions {
  * object used by `thread/settings/update` (`sandboxPolicy`).
  */
 export declare function sandboxModeToSandboxPolicy(mode: SandboxMode): SandboxPolicy;
+/**
+ * Codex 官方 feature override（thread/start·resume 的 `config` 字段）：
+ * 让 `request_user_input` 在 Default 协作模式下也可用，无需改 codex
+ * config.toml。协议键与 openai/codex 的 feature registry 一致
+ * （key `default_mode_request_user_input`），app-server 官方测试
+ * （turn_start.rs）验证同一路径。
+ */
+export declare const THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT: {
+    readonly 'features.default_mode_request_user_input': true;
+};
 export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcClient<InitializeResult>, TranslatorEvent> {
     private connectionManager;
     private currentTranslator;

package/dist/runner/codex/app-server/runner.js

@@ -13,6 +13,7 @@
 import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { CodexAppServerTranslator } from './translator.js';
 import { RpcErrorCode } from '../../common/acp/protocol-types.js';
+import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
 /**
@@ -34,6 +35,39 @@ function buildApprovalResponse(action, view) {
     }
     return { decision: action };
 }
+/**
+ * 构造 request_user_input 响应。answer → 按问题 id 回编；decline/cancel →
+ * 空 answers。answers 值与问题 options 无强校验（Codex 接受任意字符串，
+ * 包括自由文本题的自定义答案）。
+ */
+function buildRequestUserInputResponse(action, questions, response) {
+    if (action !== 'answer') {
+        return { answers: {} };
+    }
+    const answers = response.answers;
+    if (!answers) {
+        return { answers: {} };
+    }
+    const notes = response.notes;
+    const byIndex = mapAnswersByIndex(questions ?? [], answers);
+    const result = {};
+    (questions ?? []).forEach((q, i) => {
+        const value = byIndex[i];
+        if (!q.id || value === undefined)
+            return;
+        const values = Array.isArray(value) ? value : [value];
+        const cleaned = values.filter((v) => typeof v === 'string' && v.length > 0);
+        // Codex user_note：补充说明编码为 "user_note: <text>" 条目（2026-08-18
+        // live 验证 deepseek-v4-flash 明确理解并遵守该格式）。
+        const note = notes?.[q.question]?.trim();
+        if (note)
+            cleaned.push(`user_note: ${note}`);
+        if (cleaned.length === 0)
+            return;
+        result[q.id] = { answers: cleaned };
+    });
+    return { answers: result };
+}
 /**
  * Map the client-side SandboxMode enum to the response-side SandboxPolicy
  * object used by `thread/settings/update` (`sandboxPolicy`).
@@ -54,6 +88,16 @@ export function sandboxModeToSandboxPolicy(mode) {
             return { type: 'dangerFullAccess' };
     }
 }
+/**
+ * Codex 官方 feature override（thread/start·resume 的 `config` 字段）：
+ * 让 `request_user_input` 在 Default 协作模式下也可用，无需改 codex
+ * config.toml。协议键与 openai/codex 的 feature registry 一致
+ * （key `default_mode_request_user_input`），app-server 官方测试
+ * （turn_start.rs）验证同一路径。
+ */
+export const THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT = {
+    'features.default_mode_request_user_input': true,
+};
 export class CodexAppServerRunner extends ConnectionBasedRunner {
     connectionManager;
     currentTranslator = null;
@@ -177,7 +221,15 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
         if (!client || !pending)
             return;
         const action = response?.action ?? 'decline';
-        if (pending.kind === 'permissions') {
+        if (pending.kind === 'question') {
+            // AskUserQuestion 回编：文本 key 答案按问题顺序展开后映射回问题 id
+            // （{answers:{id:{answers:[值]}}}）；跳过/拒绝/取消 → 空 answers
+            // （Codex 视为 unanswered，turn 继续，对齐 cc-connect deny 语义）。
+            const questions = pending.view.questions ?? [];
+            const answerPayload = buildRequestUserInputResponse(action, questions, response);
+            client.respond(requestId, answerPayload);
+        }
+        else if (pending.kind === 'permissions') {
             // 权限审批的响应没有 decision 字段（真实协议只回 granted profile +
             // scope）：decline/cancel 必须返回空授权（拒绝全部），否则会把用户已
             // 勾选的条目当作授予返回（2026-08-12 review 发现：勾选后点「拒绝」实
@@ -258,6 +310,9 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
             ...(this.modelProvider ? { modelProvider: this.modelProvider } : {}),
             ...(this.approvalPolicyConfig ? { approvalPolicy: this.approvalPolicyConfig } : {}),
             ...(this.sandboxConfig ? { sandbox: this.sandboxConfig } : {}),
+            // Default 协作模式下默认启用 request_user_input（Ask User Question），
+            // 协议级 override，不依赖 codex config.toml。
+            config: THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT,
         };
         return params;
     }

package/dist/runner/codex/app-server/translator.d.ts

@@ -43,6 +43,13 @@ export declare class CodexAppServerTranslator {
      * Handle a server request (incoming JSON-RPC request from server, e.g. approval).
      */
     handleServerRequest(id: number | string, method: string, params: unknown): TranslatorEvent[];
+    /**
+     * Codex AskUserQuestion：item/tool/requestUserInput → question 审批事件。
+     * 问题 id 保留在 UserQuestion.id（回编时文本 → id 映射），options 为
+     * null/空 → 自由文本题（空数组驱动卡片渲染输入框）；autoResolutionMs
+     * 透传为 per-request 超时（coordinator 优先使用）。
+     */
+    private handleRequestUserInput;
     /**
      * Synthesize a ResultEvent from the current turn state.
      * Called when the turn completes.

package/dist/runner/codex/app-server/translator.js

@@ -7,6 +7,7 @@
  * completes. Method names and parameter shapes follow the real Codex
  * app-server v2 protocol (see protocol-types.ts).
  */
+import { makeQuestionApprovalEvent } from '../../question-common.js';
 import { NotificationMethod, ServerRequestMethod, UNSUPPORTED_SERVER_REQUEST_METHODS, } from './protocol-types.js';
 // =============================================================================
 // Translator
@@ -86,10 +87,33 @@ export class CodexAppServerTranslator {
                 return this.handleFileApproval(id, params);
             case ServerRequestMethod.PERMISSIONS_APPROVAL:
                 return this.handlePermissionsApproval(id, params);
+            case ServerRequestMethod.REQUEST_USER_INPUT:
+                return this.handleRequestUserInput(id, params);
             default:
                 return [];
         }
     }
+    /**
+     * Codex AskUserQuestion：item/tool/requestUserInput → question 审批事件。
+     * 问题 id 保留在 UserQuestion.id（回编时文本 → id 映射），options 为
+     * null/空 → 自由文本题（空数组驱动卡片渲染输入框）；autoResolutionMs
+     * 透传为 per-request 超时（coordinator 优先使用）。
+     */
+    handleRequestUserInput(requestId, params) {
+        const questions = params.questions
+            .map((q) => requestUserInputQuestionToUserQuestion(q))
+            .filter((q) => q !== null);
+        if (questions.length === 0) {
+            // 无有效问题：不渲染空提问卡，返回 [] 由 runner 以 method-not-found
+            // 拒绝（服务端视作请求失败，不会悬挂）。
+            return [];
+        }
+        return [
+            makeQuestionApprovalEvent(requestId, questions, params.threadId, {
+                timeoutMs: params.autoResolutionMs ?? undefined,
+            }),
+        ];
+    }
     /**
      * Synthesize a ResultEvent from the current turn state.
      * Called when the turn completes.
@@ -713,4 +737,25 @@ function normalizeCommandDecisions(list) {
         ...(Object.keys(payloads).length > 0 ? { payloads } : {}),
     };
 }
+/** Codex wire question → 统一 UserQuestion（options null/空 → 自由文本题）。 */
+function requestUserInputQuestionToUserQuestion(q) {
+    const question = q.question?.trim();
+    if (!question)
+        return null;
+    const options = (q.options ?? []).map((opt) => ({
+        label: opt.label,
+        ...(opt.description ? { description: opt.description } : {}),
+    }));
+    return {
+        id: q.id,
+        header: q.header || undefined,
+        question,
+        isOther: q.isOther,
+        isSecret: q.isSecret,
+        options,
+        // Codex user_note：选项题渲染「补充说明（可选）」输入（live 验证模型理解
+        // "user_note:" 条目）；自由文本题（options 空）不需要。
+        ...(options.length > 0 ? { allowNote: true } : {}),
+    };
+}
 //# sourceMappingURL=translator.js.map

package/dist/runner/common/acp/protocol-types.d.ts

@@ -207,6 +207,8 @@ export interface SessionUpdateNotification {
 }
 export declare const ServerRequestMethod: {
     readonly REQUEST_PERMISSION: "session/request_permission";
+    /** Kimi AskUserQuestion elicitation form（客户端广告 elicitation.form 时启用）。 */
+    readonly ELICITATION_CREATE: "elicitation/create";
 };
 export interface PermissionOption {
     /** Opaque option identifier — echo back in response outcome.optionId. */
@@ -236,3 +238,34 @@ export interface RequestPermissionResponse {
         optionId?: string;
     };
 }
+export interface ElicitationEnumOption {
+    const: string;
+    title?: string;
+    description?: string;
+}
+export interface ElicitationPropertySchema {
+    type: 'string' | 'array';
+    title?: string;
+    description?: string;
+    minItems?: number;
+    oneOf?: ElicitationEnumOption[];
+    items?: {
+        anyOf?: ElicitationEnumOption[];
+    };
+}
+export interface ElicitationCreateParams {
+    sessionId: string;
+    toolCallId?: string;
+    mode: 'form';
+    message?: string;
+    requestedSchema: {
+        type: 'object';
+        required?: string[];
+        properties: Record<string, ElicitationPropertySchema>;
+    };
+}
+export interface ElicitationCreateResponse {
+    action: 'accept' | 'decline' | 'cancel';
+    /** accept 时的答案，key 为 q0..qn（按问题顺序）。 */
+    content?: Record<string, string | string[]>;
+}

package/dist/runner/common/acp/protocol-types.js

@@ -71,5 +71,7 @@ export const SessionEventType = {
 // =============================================================================
 export const ServerRequestMethod = {
     REQUEST_PERMISSION: 'session/request_permission',
+    /** Kimi AskUserQuestion elicitation form（客户端广告 elicitation.form 时启用）。 */
+    ELICITATION_CREATE: 'elicitation/create',
 };
 //# sourceMappingURL=protocol-types.js.map

package/dist/runner/dsh/client.d.ts

@@ -0,0 +1,95 @@
+/**
+ * DshClient — HTTP client for the DSH Web Host proxy.
+ *
+ * Two transports:
+ *  1. unary POST /api/<method> (client-request → server-response).
+ *  2. SSE GET /api/events.mux (all-session aggregated stream). Frames are
+ *     ServerRequest envelopes; `method` equals the MuxFrame's `type`.
+ *
+ * The client is stateless apart from the base URL: each `run()` opens its own
+ * mux subscription and closes it on terminal. `sessionEvents()` wraps the raw
+ * mux with per-session filtering plus reconnect + history-replay dedup
+ * (DSH v1 has no `since` resume — reconnection = reopen stream + refetch
+ * history, dedup by event seq).
+ */
+import type { DshModelCatalogValue, DshModelSelection, DshPresetListValue, DshServerRequest, DshSessionModelsValue, DshStreamItem, DshTokenUsage } from './types.js';
+interface WebSocketMessageEvent {
+    data: unknown;
+}
+interface WebSocketLike {
+    onmessage: ((event: WebSocketMessageEvent) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    onclose: ((event: unknown) => void) | null;
+    close(): void;
+}
+export type WebSocketFactory = (url: string) => WebSocketLike;
+export declare class DshError extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown>;
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+export declare class DshClient {
+    readonly baseUrl: string;
+    private readonly fetchImpl;
+    private readonly webSocketImpl;
+    constructor(baseUrl: string, fetchImpl?: typeof fetch, webSocketImpl?: WebSocketFactory);
+    /** Perform a unary POST and return the ok value; throws DshError on failure. */
+    unary(method: string, payload: unknown): Promise<unknown>;
+    /** Create a session. Pass `agentPreset` to pin the session's preset (fixed at
+     *  creation). */
+    createSession(payload: {
+        cwd: string;
+        agentPreset?: string;
+    }): Promise<{
+        sessionId: string;
+        agentPreset?: string;
+    }>;
+    /** Align the session's model/reasoningEffort (also persists as global default
+     *  server-side). Failures are surfaced as DshError for the caller to downgrade. */
+    selectModel(payload: DshModelSelection & {
+        sessionId: string;
+    }): Promise<DshModelSelection>;
+    /** Read the session's current model selection + full model catalog. */
+    sessionModels(sessionId: string): Promise<DshSessionModelsValue>;
+    /** Read the model catalog (session-independent, llm.models). */
+    listModels(): Promise<DshModelCatalogValue>;
+    /** Read the preset catalog (agentPreset.list). */
+    listPresets(): Promise<DshPresetListValue>;
+    /**
+     * Return the highest event `seq` currently persisted in session.history.
+     *
+     * The caller snapshots this before `session.prompt`. `session.history` is a
+     * full-session replay rather than a delta, so this high-water mark is what
+     * lets a subsequent replay skip every already-completed turn.
+     */
+    latestEventSeq(sessionId: string): Promise<number>;
+    /**
+     * Raw SSE mux stream: yields ServerRequest envelopes until the stream ends,
+     * errors, or `signal` aborts. Does NOT reconnect (the caller owns retry).
+     */
+    mux(signal: AbortSignal): AsyncGenerator<DshServerRequest>;
+    /**
+     * WebSocket mux stream. The real DSH `/api/events.mux` endpoint is a
+     * WebSocket upgrade, not HTTP SSE: each text message is already a
+     * `DshServerRequest` JSON envelope. This yields those envelopes and ends on
+     * close/abort, letting `sessionEvents()` reconnect through the same
+     * history-replay loop.
+     */
+    muxWebSocket(signal: AbortSignal): AsyncGenerator<DshServerRequest>;
+    /**
+     * Replay session.history events that are newer than `state.lastSeq`, updating
+     * `state.lastSeq` as it goes. Yields each non-duplicate SessionEvent. Used for
+     * both the initial baseline (first subscription) and reconnect gap-fill.
+     */
+    private replayHistory;
+    /**
+     * Per-session subscription: yields session events (and approval notices) for
+     * `sessionId`, auto-reconnecting on stream drop/error and replaying
+     * `session.history` to fill the gap (dedup by seq). Terminates on turn/end
+     * or `signal` abort.
+     */
+    sessionEvents(sessionId: string, cwd: string, signal: AbortSignal, initialSeq?: number): AsyncGenerator<DshStreamItem>;
+    /** Extract TokenUsage from an assistant/message data payload (absent → undefined). */
+    static usageOf(data: Record<string, unknown>): DshTokenUsage | undefined;
+}
+export {};