@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/agents/claude-code/claude-code-sessions.js

@@ -0,0 +1,207 @@
+import { deleteSession, getSessionMessages, listSessions, renameSession, tagSession, } from "@anthropic-ai/claude-agent-sdk";
+import { createReplay, SESSION_LIST_LIMIT } from "../../agent/index.js";
+import { applyTaskReport, isCompactSummary, isServiceText, parseTaskReport, settleTasks, taskOfCall, } from "./claude-code-replay.js";
+import { claudeMessageTimes } from "./claude-code-times.js";
+/** Claude Code accepts model aliases, so the list does not go stale with every release. */
+const permissionOptions = [
+    { value: "default", name: "Спрашивать", description: "Запрос перед правками и командами" },
+    {
+        value: "plan",
+        name: "План",
+        description: "Агент сначала составляет план без правок и ждёт вашего согласия",
+    },
+    {
+        value: "acceptEdits",
+        name: "Правки без вопросов",
+        description: "Файлы меняются сразу, команды — по запросу",
+    },
+    {
+        value: "auto",
+        name: "Авто",
+        description: "Классификатор сам разрешает безопасное и спрашивает о рискованном",
+    },
+    {
+        value: "bypassPermissions",
+        name: "Всё без вопросов",
+        description: "Без запросов разрешений",
+    },
+];
+export const CLAUDE_CONTROLS = [
+    {
+        id: "permission-mode",
+        via: "native",
+        category: "mode",
+        name: "Разрешения",
+        description: "Когда агент спрашивает подтверждение",
+        current: "default",
+        options: permissionOptions,
+    },
+    {
+        id: "model",
+        category: "model",
+        name: "Модель",
+        description: "Модель Claude Code; «По умолчанию» берёт выбор из настроек Claude",
+        current: "default",
+        via: "native",
+        options: [
+            { value: "default", name: "По умолчанию" },
+            { value: "opus", name: "Opus" },
+            { value: "sonnet", name: "Sonnet" },
+            { value: "haiku", name: "Haiku" },
+        ],
+    },
+    {
+        id: "effort",
+        category: "effort",
+        name: "Усилие",
+        description: "Сколько Claude думает над ответом; модель без поддержки уровня понижает его сама",
+        current: "default",
+        via: "native",
+        options: [
+            { value: "default", name: "По умолчанию" },
+            { value: "low", name: "Low" },
+            { value: "medium", name: "Medium" },
+            { value: "high", name: "High" },
+            { value: "xhigh", name: "Xhigh" },
+            { value: "max", name: "Max" },
+        ],
+    },
+    {
+        id: "budget",
+        category: "other",
+        name: "Бюджет хода",
+        description: "Ход прекращается, когда его стоимость достигает предела (доллары США)",
+        current: "default",
+        via: "native",
+        options: [
+            { value: "default", name: "Без предела" },
+            { value: "1", name: "1 $" },
+            { value: "5", name: "5 $" },
+            { value: "20", name: "20 $" },
+        ],
+    },
+    {
+        id: "steps",
+        category: "other",
+        name: "Шагов в ходе",
+        description: "Сколько раз агент может обратиться к модели за один ход",
+        current: "default",
+        via: "native",
+        options: [
+            { value: "default", name: "Без предела" },
+            { value: "10", name: "10" },
+            { value: "30", name: "30" },
+            { value: "100", name: "100" },
+        ],
+    },
+];
+export async function claudeSessions(cwd) {
+    const sessions = await listSessions({ dir: cwd, limit: SESSION_LIST_LIMIT });
+    return sessions
+        .map((session) => ({
+        id: session.sessionId,
+        title: (session.customTitle || session.summary || session.firstPrompt || "").trim() ||
+            "Без названия",
+        updatedAt: new Date(session.lastModified).toISOString(),
+        ...(session.tag === PINNED_TAG ? { pinned: true } : {}),
+    }))
+        .sort((a, b) => Number(b.pinned === true) - Number(a.pinned === true) ||
+        b.updatedAt.localeCompare(a.updatedAt));
+}
+const PINNED_TAG = "pinned";
+/** Renames a session and pins or unpins it; Claude Code keeps both in its own transcript. */
+export async function claudeUpdateSession(cwd, sessionId, change) {
+    if (change.title !== undefined) {
+        const title = change.title.trim();
+        if (!title)
+            throw new Error("Название не может быть пустым");
+        await renameSession(sessionId, title.slice(0, 200), { dir: cwd });
+    }
+    if (change.pinned !== undefined)
+        await tagSession(sessionId, change.pinned ? PINNED_TAG : null, { dir: cwd });
+}
+/** Removes the session's transcript from Claude Code's own storage. */
+export async function claudeDeleteSession(cwd, sessionId) {
+    await deleteSession(sessionId, { dir: cwd });
+}
+const blocksOf = (content) => typeof content === "string"
+    ? [{ type: "text", text: content }]
+    : Array.isArray(content)
+        ? content
+        : [];
+function stringify(value) {
+    if (typeof value === "string")
+        return value.slice(0, 8000);
+    if (value == null)
+        return "";
+    try {
+        return JSON.stringify(value, null, 2).slice(0, 8000);
+    }
+    catch {
+        return "";
+    }
+}
+/** The chat shape of a stored Claude Code transcript: text per turn, tool calls as chips. */
+export async function claudeLoadSession(cwd, sessionId) {
+    const [messages, times] = await Promise.all([
+        getSessionMessages(sessionId, { dir: cwd }),
+        claudeMessageTimes(cwd, sessionId),
+    ]);
+    const replay = createReplay("claude-code", sessionId);
+    for (const message of messages) {
+        if (message.type === "system" || message.parent_tool_use_id)
+            continue;
+        replay.mark(times.get(message.uuid));
+        const content = message.message?.content;
+        for (const block of blocksOf(content)) {
+            if (message.type === "assistant") {
+                if (block.type === "text" && block.text)
+                    replay.text(block.text);
+                else if (block.type === "thinking" && block.thinking)
+                    replay.thought(block.thinking);
+                else if (block.type === "tool_use" && block.id) {
+                    replay.tool({
+                        id: block.id,
+                        name: block.name ?? "tool",
+                        status: "running",
+                        detail: stringify(block.input),
+                    });
+                    const task = taskOfCall(block.name, block.id, block.input);
+                    if (task) {
+                        const turn = replay.turnFor("assistant");
+                        (turn.tasks ??= []).push(task);
+                    }
+                }
+            }
+            else if (block.type === "text" && block.text) {
+                const report = parseTaskReport(block.text);
+                if (report)
+                    applyTaskReport(replay.allTurns, report);
+                else if (isCompactSummary(block.text))
+                    replay.note("Контекст сжат");
+                else if (!isServiceText(block.text))
+                    replay.user(block.text);
+            }
+            else if (block.type === "tool_result") {
+                const chip = replay.findTool(block.tool_use_id ?? "");
+                if (chip) {
+                    chip.status = block.is_error ? "error" : "done";
+                    const output = stringify(typeof block.content === "string"
+                        ? block.content
+                        : blocksOf(block.content)
+                            .map((part) => part.text ?? "")
+                            .join("\n"));
+                    if (output)
+                        chip.detail = output;
+                    // A foreground subagent or command is over with its result; a background one reports later.
+                    for (const turn of replay.allTurns)
+                        for (const task of turn.tasks ?? [])
+                            if (task.tool === chip.id && !task.background)
+                                task.status = block.is_error ? "error" : "done";
+                }
+            }
+        }
+    }
+    settleTasks(replay.allTurns);
+    return replay.turns;
+}

package/packages/server/modules/agents/claude-code/claude-code-times.js

@@ -0,0 +1,42 @@
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const configDir = () => process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+/** Claude Code names the folder of a project after its path with every other character a dash. */
+const folderOf = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-");
+async function transcript(cwd, sessionId) {
+    const root = join(configDir(), "projects");
+    const file = `${sessionId}.jsonl`;
+    const direct = await readFile(join(root, folderOf(cwd), file), "utf8").catch(() => undefined);
+    if (direct !== undefined)
+        return direct;
+    // Long paths are shortened with a hash: look for the session in every project.
+    for (const folder of await readdir(root).catch(() => [])) {
+        const text = await readFile(join(root, folder, file), "utf8").catch(() => undefined);
+        if (text !== undefined)
+            return text;
+    }
+    return undefined;
+}
+/** Message `uuid` → when it was written (ms), read from the stored transcript. */
+export function messageTimes(text) {
+    const times = new Map();
+    for (const line of text.split("\n")) {
+        if (!line.includes('"timestamp"'))
+            continue;
+        try {
+            const { uuid, timestamp } = JSON.parse(line);
+            const time = typeof timestamp === "string" ? Date.parse(timestamp) : NaN;
+            if (typeof uuid === "string" && Number.isFinite(time))
+                times.set(uuid, time);
+        }
+        catch {
+            // A torn last line of a transcript still being written.
+        }
+    }
+    return times;
+}
+export async function claudeMessageTimes(cwd, sessionId) {
+    const text = await transcript(cwd, sessionId);
+    return text ? messageTimes(text) : new Map();
+}

package/packages/server/modules/agents/claude-code/index.js

@@ -0,0 +1,2 @@
+export { claudeCodeBackend, runClaudeCode } from "./claude-code-backend.js";
+export { CLAUDE_SESSION_ENV } from "./claude-code-env.js";

package/packages/server/modules/agents/claude-code/questions.js

@@ -0,0 +1,51 @@
+const text = (value, limit) => typeof value === "string" ? value.slice(0, limit) : "";
+/** Claude Code's `AskUserQuestion` input: a few questions, each with options and a multi-select flag. */
+function claudeQuestions(input) {
+    const list = Array.isArray(input.questions) ? input.questions.slice(0, 10) : [];
+    return list.flatMap((raw, index) => {
+        const item = (raw ?? {});
+        const question = text(item.question, 2000);
+        if (!question)
+            return [];
+        const options = (Array.isArray(item.options) ? item.options.slice(0, 20) : []).flatMap((option, at) => {
+            const entry = (option ?? {});
+            const label = text(entry.label, 500);
+            if (!label)
+                return [];
+            const description = text(entry.description, 1000);
+            return [{ id: String(at), label, ...(description ? { description } : {}) }];
+        });
+        const header = text(item.header, 100);
+        return [
+            {
+                id: String(index),
+                question,
+                ...(header ? { header } : {}),
+                options,
+                multiple: item.multiSelect === true,
+            },
+        ];
+    });
+}
+/**
+ * Answers Claude Code's `AskUserQuestion`. The tool is not run by the host: the SDK expects the
+ * answers back in the input (`answers`, keyed by the question text; several choices joined by
+ * ", "), so an allow without them would tell the agent the user answered with nothing.
+ */
+export async function askClaudeQuestions(options, input) {
+    const questions = claudeQuestions(input);
+    if (!options.ask || !questions.length)
+        return { behavior: "deny", message: "Клиент не может показать вопрос пользователю" };
+    const answer = await options.ask({ questions, custom: true }).catch(() => null);
+    if (!answer)
+        return { behavior: "deny", message: "Пользователь пропустил вопрос" };
+    const answers = {};
+    for (const question of questions) {
+        const chosen = (answer[question.id] ?? [])
+            .map((value) => question.options.find((option) => option.id === value)?.label ?? value)
+            .filter((value) => value.trim());
+        if (chosen.length)
+            answers[question.question] = chosen.join(", ");
+    }
+    return { behavior: "allow", updatedInput: { ...input, answers } };
+}

package/packages/server/modules/agents/codex/dialect.js

@@ -0,0 +1,130 @@
+import { extendPlainDialect, inputOf, isOver, shorten, } from "../acp/index.js";
+/**
+ * Codex reports a subagent as two calls, "Start subagent <name>" and "Complete subagent <name>",
+ * tied by `rawInput.agentThreadId` (nothing the subagent does is shown). A command in a terminal
+ * keeps its call open until the process exits and streams its output as
+ * `_meta.terminal_output_delta` chunks instead of putting it into the final update.
+ */
+function subagentOf(update) {
+    const { agentThreadId, agentPath, activityKind } = inputOf(update);
+    if (typeof agentThreadId !== "string")
+        return undefined;
+    const fromTitle = String(update.title ?? "").replace(/^(Start|Complete) subagent\s*/i, "");
+    const name = fromTitle ||
+        String(agentPath ?? "")
+            .split("/")
+            .at(-1) ||
+        "subagent";
+    return { id: agentThreadId, name, completed: activityKind === "completed" };
+}
+function terminalOf(update) {
+    const content = Array.isArray(update.content) ? update.content : [];
+    const hasTerminal = content.some((item) => item?.type === "terminal");
+    const { command } = inputOf(update);
+    return update.kind === "execute" && hasTerminal && typeof command === "string"
+        ? command
+        : undefined;
+}
+function deltaOf(update) {
+    const meta = update._meta;
+    const data = meta?.terminal_output_delta?.data;
+    return typeof data === "string" ? data : "";
+}
+/** What Codex reports when a terminal command exits: output arrives separately as deltas. */
+function terminalExitOf(update) {
+    const exit = update._meta?.terminal_exit;
+    if (!exit)
+        return undefined;
+    return {
+        code: typeof exit.exit_code === "number" ? exit.exit_code : undefined,
+        signal: typeof exit.signal === "string" && exit.signal ? exit.signal : undefined,
+    };
+}
+/** The one-line end of a command: its last output line, or the exit status when it said nothing. */
+function endSummary(update, output) {
+    const exit = terminalExitOf(update);
+    if (exit?.signal)
+        return `Прервано сигналом ${exit.signal}`;
+    if (output.trim())
+        return shorten(output);
+    if (exit?.code === undefined)
+        return "";
+    return exit.code === 0 ? "Завершено без вывода" : `Код выхода ${exit.code}`;
+}
+export function createCodexDialect() {
+    const started = new Set();
+    const streamed = new Map();
+    /** Terminal commands that have not ended, and the ones already shown as tasks. */
+    const running = new Map();
+    const detached = new Set();
+    /**
+     * A terminal command still open while the agent moves on (it spoke, or the answer ended) runs in
+     * the background; its end is unknown once the answer is over.
+     */
+    function detach() {
+        const patches = [];
+        for (const [id, command] of running) {
+            if (detached.has(id))
+                continue;
+            detached.add(id);
+            patches.push({
+                id,
+                kind: "shell",
+                title: command,
+                status: "running",
+                background: true,
+                untracked: true,
+                tool: id,
+            });
+        }
+        return patches;
+    }
+    return extendPlainDialect({
+        call(update, id) {
+            const delta = deltaOf(update);
+            if (delta)
+                streamed.set(id, (streamed.get(id) ?? "") + delta);
+            const patches = [];
+            const agent = subagentOf(update);
+            if (agent?.completed)
+                patches.push({ id: agent.id, status: "done" });
+            else if (agent && !started.has(agent.id)) {
+                started.add(agent.id);
+                patches.push({
+                    id: agent.id,
+                    kind: "agent",
+                    title: agent.name,
+                    status: "running",
+                    background: false,
+                    tool: id,
+                });
+            }
+            const command = terminalOf(update);
+            if (command && !isOver(update))
+                running.set(id, command);
+            return patches;
+        },
+        output(id) {
+            const output = streamed.get(id) ?? "";
+            streamed.delete(id);
+            return output;
+        },
+        outputChunk: (update) => deltaOf(update),
+        result: (update, _id, output) => output || endSummary(update, ""),
+        end(update, id, output) {
+            running.delete(id);
+            if (!detached.delete(id))
+                return [];
+            const summary = endSummary(update, output);
+            return [
+                {
+                    id,
+                    status: update.status === "failed" ? "error" : "done",
+                    ...(summary ? { summary } : {}),
+                },
+            ];
+        },
+        speak: detach,
+        finish: detach,
+    });
+}

package/packages/server/modules/agents/codex/forms.js

@@ -0,0 +1,24 @@
+const record = (value) => value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+/** The metadata Codex puts on a form property. */
+const codexMeta = (field) => record(record(field.schema._meta).codex);
+const strippedKey = (key) => key.replace(/_(custom|note)\d*$/, "");
+/**
+ * Codex's own shape of `elicitation/create`: it marks the note that takes the user's own words
+ * with `_meta.codex` and lists a "none of the above" option next to it.
+ */
+export const codexForms = {
+    companion(field, properties) {
+        if (codexMeta(field).role === "user_note")
+            return true;
+        return strippedKey(field.key) !== field.key && strippedKey(field.key) in properties;
+    },
+    baseOf(field) {
+        const questionId = codexMeta(field).questionId;
+        return typeof questionId === "string" ? questionId : undefined;
+    },
+    fallbackOption(options) {
+        return options.find((option) => option.id === "None of the above");
+    },
+};

package/packages/server/modules/agents/codex/index.js

@@ -0,0 +1,17 @@
+import { createAcpBackend } from "../acp/index.js";
+import { createCodexDialect } from "./dialect.js";
+import { codexForms } from "./forms.js";
+/**
+ * Codex through its ACP server. The adapter ships as a package rather than in the CLI, so it prefers
+ * a global `codex-acp` binary and only falls back to `npx`, pinned to a reviewed version.
+ */
+export const codexProgram = {
+    id: "codex",
+    label: "Codex",
+    command: "npx",
+    args: ["-y", "@agentclientprotocol/codex-acp@2.1.1"],
+    binary: "codex-acp",
+    dialect: createCodexDialect,
+    forms: codexForms,
+};
+export const codexBackend = createAcpBackend(codexProgram);

package/packages/server/modules/agents/cursor/dialect.js

@@ -0,0 +1,66 @@
+import { extendPlainDialect, inputOf, } from "../acp/index.js";
+function parentOf(update) {
+    const meta = (update._meta ?? {});
+    for (const value of [update.parentToolCallId, meta.parentToolCallId, meta.parent])
+        if (typeof value === "string" && value.trim())
+            return value;
+    return undefined;
+}
+function subagentOf(value) {
+    if (typeof value === "string" && value.trim() && value !== "unspecified")
+        return value;
+    if (value && typeof value === "object" && "custom" in value) {
+        const custom = value.custom;
+        if (typeof custom === "string" && custom.trim())
+            return custom;
+    }
+    return undefined;
+}
+function taskOf(update) {
+    const input = inputOf(update);
+    const subagent = subagentOf(input.subagentType);
+    const description = typeof input.description === "string" ? input.description.trim() : "";
+    const prompt = typeof input.prompt === "string" ? input.prompt.trim() : "";
+    if (!subagent && !description)
+        return undefined;
+    return {
+        title: description || subagent || "задача",
+        ...(subagent ? { subagent } : {}),
+        ...(prompt ? { prompt } : {}),
+    };
+}
+/** Nested calls and `task` tools become the chat's task list; Lens reads the child from there. */
+export function createCursorDialect() {
+    const started = new Set();
+    return extendPlainDialect({
+        tool(update) {
+            const parent = parentOf(update);
+            return {
+                name: String(update.title || update.kind || "tool"),
+                ...(parent ? { parent } : {}),
+            };
+        },
+        inner: (update) => parentOf(update) !== undefined,
+        call(update, id) {
+            const patches = [];
+            const task = taskOf(update);
+            if (task && !started.has(id) && update.sessionUpdate === "tool_call") {
+                started.add(id);
+                patches.push({
+                    id,
+                    kind: "agent",
+                    title: task.title,
+                    status: "running",
+                    background: false,
+                    tool: id,
+                    ...(task.subagent ? { subagent: task.subagent } : {}),
+                    ...(task.prompt ? { prompt: task.prompt } : {}),
+                });
+            }
+            const parent = parentOf(update);
+            if (parent && update.sessionUpdate === "tool_call")
+                patches.push({ id: parent, lastTool: String(update.title || update.kind || "tool") });
+            return patches;
+        },
+    });
+}

package/packages/server/modules/agents/cursor/images.js

@@ -0,0 +1,12 @@
+const text = (value, limit) => typeof value === "string" ? value.slice(0, limit) : "";
+/** `cursor/generate_image`: the chat already renders `![alt](path)` from an absolute file. */
+export async function showCursorImage(options, params) {
+    const path = text(params.filePath, 2000);
+    const description = text(params.description, 500) || "изображение";
+    if (path)
+        options.emit("text", { text: `\n\n![${description}](${path})\n` });
+    const id = text(params.toolCallId, 200) || "generate_image";
+    options.emit("tool", { id, name: "generate_image", input: { description, filePath: path } });
+    options.emit("tool-result", { id, name: "generate_image", output: path });
+    return {};
+}

package/packages/server/modules/agents/cursor/index.js

@@ -0,0 +1,30 @@
+import { createAcpBackend } from "../acp/index.js";
+import { createCursorDialect } from "./dialect.js";
+import { showCursorImage } from "./images.js";
+import { createCursorPlan } from "./plan.js";
+import { askCursorQuestions } from "./questions.js";
+import { normalizeCursorSelection } from "./selection.js";
+import { reportCursorTask } from "./task.js";
+import { updateCursorTodos } from "./todos.js";
+/** Cursor through its ACP mode (`agent acp`), with its own picker flag, questions and plan. */
+export const cursorProgram = {
+    id: "cursor",
+    label: "Cursor",
+    command: "agent",
+    args: ["acp"],
+    terminal: { executable: "agent" },
+    dialect: createCursorDialect,
+    clientCapabilities: {
+        subagents: {},
+        _meta: { parameterizedModelPicker: true },
+    },
+    normalizeSelection: normalizeCursorSelection,
+    extensions: {
+        "cursor/ask_question": askCursorQuestions,
+        "cursor/create_plan": createCursorPlan,
+        "cursor/update_todos": updateCursorTodos,
+        "cursor/task": reportCursorTask,
+        "cursor/generate_image": showCursorImage,
+    },
+};
+export const cursorBackend = createAcpBackend(cursorProgram);

package/packages/server/modules/agents/cursor/plan.js

@@ -0,0 +1,44 @@
+import { cursorTodos, rememberCursorTodos } from "./todos.js";
+const text = (value, limit) => typeof value === "string" ? value.slice(0, limit) : "";
+/**
+ * `cursor/create_plan`: show the todos on the plan island and ask the user to accept or reject.
+ * Without a prompt (a job with no UI) the plan is accepted so the turn can continue.
+ */
+export async function createCursorPlan(options, params) {
+    const todos = cursorTodos(params);
+    const id = text(params.toolCallId, 200) || "create_plan";
+    if (todos.length) {
+        rememberCursorTodos(options, todos);
+        options.emit("tool", { id, name: "create_plan", input: { todos } });
+        options.emit("tool-result", { id, name: "create_plan", output: "" });
+    }
+    if (!options.ask)
+        return { outcome: { outcome: "accepted" } };
+    const name = text(params.name, 300) || "План";
+    const overview = text(params.overview, 2000);
+    const plan = text(params.plan, 8000);
+    const answer = await options
+        .ask({
+        title: name,
+        custom: false,
+        questions: [
+            {
+                id: "plan",
+                question: [overview, plan].filter(Boolean).join("\n\n") || name,
+                options: [
+                    { id: "accept", label: "Принять план" },
+                    { id: "reject", label: "Отклонить" },
+                ],
+                multiple: false,
+            },
+        ],
+    })
+        .catch(() => undefined);
+    if (answer === undefined || answer === null)
+        return { outcome: { outcome: "cancelled" } };
+    if (answer.plan?.includes("accept"))
+        return { outcome: { outcome: "accepted" } };
+    if (answer.plan?.includes("reject"))
+        return { outcome: { outcome: "rejected", reason: "Пользователь отклонил план" } };
+    return { outcome: { outcome: "cancelled" } };
+}

package/packages/server/modules/agents/cursor/questions.js

@@ -0,0 +1,37 @@
+const text = (value, limit) => typeof value === "string" ? value.slice(0, limit) : "";
+/** Cursor's `cursor/ask_question` (ACP extension): the answer lists the chosen option IDs. */
+export async function askCursorQuestions(options, params) {
+    const list = Array.isArray(params.questions) ? params.questions.slice(0, 10) : [];
+    const questions = list.flatMap((raw) => {
+        const item = (raw ?? {});
+        const id = text(item.id, 200);
+        const question = text(item.prompt, 2000);
+        if (!id || !question)
+            return [];
+        const choices = (Array.isArray(item.options) ? item.options.slice(0, 20) : []).flatMap((option) => {
+            const entry = (option ?? {});
+            const optionId = text(entry.id, 200);
+            return optionId ? [{ id: optionId, label: text(entry.label, 500) || optionId }] : [];
+        });
+        return [{ id, question, options: choices, multiple: item.allowMultiple === true }];
+    });
+    if (!options.ask || !questions.length)
+        return { outcome: { outcome: "cancelled" } };
+    const title = text(params.title, 300);
+    const answer = await options
+        .ask({ ...(title ? { title } : {}), questions, custom: false })
+        .catch(() => undefined);
+    if (answer === undefined)
+        return { outcome: { outcome: "cancelled" } };
+    if (answer === null)
+        return { outcome: { outcome: "skipped", reason: "Пользователь пропустил вопрос" } };
+    return {
+        outcome: {
+            outcome: "answered",
+            answers: questions.map((question) => ({
+                questionId: question.id,
+                selectedOptionIds: (answer[question.id] ?? []).filter((value) => question.options.some((option) => option.id === value)),
+            })),
+        },
+    };
+}