paseo-acp-agy 1.2.15 → 1.2.16

package/dist/acp-server.d.ts

@@ -10,6 +10,8 @@ export declare class ACPServer extends EventEmitter {
     private skipNarration;
     private rl;
     private isRunning;
+    private pendingRequests;
+    private nextRequestId;
     constructor(options?: {
         input?: Readable;
         output?: Writable;
@@ -22,6 +24,7 @@ export declare class ACPServer extends EventEmitter {
     private sendNotification;
     private sendSuccess;
     private sendError;
+    sendRequest<T = any>(method: string, params: unknown): Promise<T>;
     private publishCommands;
     private publishUsageUpdate;
     private sessionState;

package/dist/acp-server.js

@@ -29,6 +29,8 @@ export class ACPServer extends EventEmitter {
     skipNarration;
     rl = null;
     isRunning = false;
+    pendingRequests = new Map();
+    nextRequestId = 1;
     constructor(options = {}) {
         super();
         this.input = options.input || process.stdin;
@@ -98,6 +100,13 @@ export class ACPServer extends EventEmitter {
         };
         this.send(response);
     }
+    sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = this.nextRequestId++;
+            this.pendingRequests.set(id, { resolve, reject });
+            this.send({ jsonrpc: "2.0", id, method, params });
+        });
+    }
     publishCommands(sessionId) {
         this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
             sessionId,
@@ -198,6 +207,20 @@ export class ACPServer extends EventEmitter {
         const isNotification = id === undefined || id === null;
         const params = (parsed.params || {});
         logger.debug("Received ACP message", { method, isNotification, id });
+        // Handle responses to requests initiated by the server (e.g. session/request_permission)
+        if (id !== undefined && !method) {
+            const pending = this.pendingRequests.get(id);
+            if (pending) {
+                this.pendingRequests.delete(id);
+                if (parsed.error) {
+                    pending.reject(parsed.error);
+                }
+                else {
+                    pending.resolve(parsed.result);
+                }
+                return;
+            }
+        }
         try {
             switch (method) {
                 case ACP_METHODS.INITIALIZE: {
@@ -559,13 +582,70 @@ export class ACPServer extends EventEmitter {
                                             rawInput: toolCall.rawInput,
                                         },
                                     });
-                                    if (toolCall.questionCard) {
-                                        this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                    if (toolName === "ask_question") {
+                                        const rawParams = step.tool_info.parameters || {};
+                                        const rawQuestions = Array.isArray(rawParams.questions)
+                                            ? rawParams.questions
+                                            : [];
+                                        const options = [];
+                                        for (let qIdx = 0; qIdx < rawQuestions.length; qIdx++) {
+                                            const q = rawQuestions[qIdx];
+                                            const opts = Array.isArray(q.options) ? q.options : [];
+                                            for (let optIdx = 0; optIdx < opts.length; optIdx++) {
+                                                const opt = opts[optIdx];
+                                                const clean = typeof opt === "string" ? opt.replace(/^\(Recommended\)\s*/i, "").trim() : String(opt);
+                                                const isRec = typeof opt === "string" && (opt.includes("(Recommended)") || opt.includes("(Recomendado)"));
+                                                options.push({
+                                                    optionId: `q${qIdx + 1}_opt${optIdx + 1}`,
+                                                    name: `${clean}${isRec ? " (Recomendado)" : ""}`,
+                                                    kind: "allow_once",
+                                                });
+                                            }
+                                        }
+                                        options.push({
+                                            optionId: "cancel",
+                                            name: "Cancelar",
+                                            kind: "reject_once",
+                                        });
+                                        const promptText = rawQuestions.map((q) => q.question).filter(Boolean).join(" / ") || "Pergunta do Assistente";
+                                        this.sendRequest("session/request_permission", {
                                             sessionId: session.id,
-                                            update: {
-                                                sessionUpdate: "agent_message_chunk",
-                                                content: { type: "text", text: `\n\n${toolCall.questionCard}\n\n` },
+                                            toolCall: {
+                                                toolCallId: toolCall.toolCallId,
+                                                title: toolCall.title,
+                                                kind: "question",
+                                                content: [{ type: "text", text: promptText }],
+                                                rawInput: toolCall.rawInput,
                                             },
+                                            options,
+                                            questions: rawQuestions,
+                                        }).then((permRes) => {
+                                            logger.info("Interactive question answered in Paseo", { permRes });
+                                            const outcome = permRes?.outcome;
+                                            let answerText = "";
+                                            if (outcome?._meta?.answers && typeof outcome._meta.answers === "object") {
+                                                answerText = Object.entries(outcome._meta.answers)
+                                                    .map(([k, v]) => `• **${k}**: ${v}`)
+                                                    .join("\n");
+                                            }
+                                            else if (outcome?.optionId && outcome.optionId !== "cancel") {
+                                                const matched = options.find((o) => o.optionId === outcome.optionId);
+                                                answerText = matched ? matched.name : outcome.optionId;
+                                            }
+                                            if (answerText) {
+                                                this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                                    sessionId: session.id,
+                                                    update: {
+                                                        sessionUpdate: "agent_message_chunk",
+                                                        content: {
+                                                            type: "text",
+                                                            text: `\n\n> 💡 **Opção Selecionada:**\n${answerText}\n\n`,
+                                                        },
+                                                    },
+                                                });
+                                            }
+                                        }).catch((err) => {
+                                            logger.debug("Interactive question cancelled or dismissed", { error: err.message });
                                         });
                                     }
                                 }

package/dist/paseo-patcher.js

@@ -1195,6 +1195,63 @@ ${braceIndent}}`;
                     }
                 }
             }
+            // Patch mapPermissionRequest for native QuestionFormCard support in Paseo UI
+            if (!acpCode.includes("snapshot?.kind === \"question\" || params?.kind === \"question\"")) {
+                const oldMapPermRegex = /function\s+mapPermissionRequest\s*\([^)]*\)\s*\{[\s\S]*?const\s+kind\s*=\s*snapshot\.kind\s*===\s*"switch_mode"\s*\?\s*"mode"\s*:\s*"tool";/m;
+                const newMapPerm = `function mapPermissionRequest(provider, requestId, params, snapshot) {
+    if (snapshot?.kind === "question" || params?.kind === "question" || (params?.questions && Array.isArray(params.questions)) || (snapshot?.rawInput?.questions && Array.isArray(snapshot?.rawInput?.questions))) {
+        const rawQ = params.questions || snapshot?.rawInput?.questions || [];
+        const questions = rawQ.map((q, idx) => ({
+            header: q.header || q.title || ("Question " + (idx + 1)),
+            question: q.question || q.prompt || "Escolha uma opção:",
+            options: (q.options || []).map((opt) => typeof opt === "string" ? {
+                label: opt.replace(/^\\(Recommended\\)\\s*/i, "").replace(/^\\(Recomendado\\)\\s*/i, "").trim(),
+                description: (opt.includes("(Recommended)") || opt.includes("(Recomendado)")) ? "Recomendado" : undefined
+            } : { label: opt.label || String(opt), description: opt.description }),
+            multiSelect: q.multiSelect === true || q.is_multi_select === true || q.multiple === true,
+            allowOther: true,
+            allowEmpty: false,
+        }));
+        return {
+            id: requestId,
+            provider,
+            name: "question",
+            kind: "question",
+            title: params.toolCall?.title ?? snapshot?.title ?? "Pergunta do Assistente",
+            input: { questions },
+            actions: (params.options || []).map((option) => ({
+                id: option.optionId,
+                label: option.name,
+                behavior: option.kind.startsWith("allow") ? "allow" : "deny",
+            })),
+            metadata: {
+                toolCallId: params.toolCall?.toolCallId,
+                rawRequest: params,
+                options: params.options,
+            },
+        };
+    }
+    const kind = snapshot.kind === "switch_mode" ? "mode" : "tool";`;
+                if (oldMapPermRegex.test(acpCode)) {
+                    acpCode = acpCode.replace(oldMapPermRegex, newMapPerm);
+                    acpModified = true;
+                    changes.push(`Patched ${acpFile} for interactive QuestionFormCard support`);
+                }
+            }
+            // Patch respondToPermission for QuestionFormCard updatedInput.answers
+            if (!acpCode.includes("response.updatedInput?.answers")) {
+                const oldRespondMatch = acpCode.match(/this\.pendingPermissions\.delete\(requestId\);[\s\S]*?pending\.resolve\([\s\S]*?\);\s*\r?\n\s*this\.pushEvent/m);
+                if (oldRespondMatch) {
+                    const newRespond = `this.pendingPermissions.delete(requestId);
+        const outcome = response.updatedInput?.answers
+            ? { outcome: "selected", optionId: selectedOption?.optionId || "form_submit", _meta: { answers: response.updatedInput.answers } }
+            : (selectedOption ? { outcome: { outcome: "selected", optionId: selectedOption.optionId } } : { outcome: { outcome: "cancelled" } });
+        pending.resolve(response.updatedInput?.answers ? { outcome } : (selectedOption ? { outcome: { outcome: "selected", optionId: selectedOption.optionId } } : { outcome: { outcome: "cancelled" } }));
+        this.pushEvent`;
+                    acpCode = acpCode.replace(oldRespondMatch[0], newRespond);
+                    acpModified = true;
+                }
+            }
             if (acpModified) {
                 fs.writeFileSync(acpFile, acpCode, "utf-8");
                 changes.push(`Patched ${acpFile} for context-window token telemetry and usage updates`);

package/dist/protocol.d.ts

@@ -135,7 +135,7 @@ export interface SessionInfo {
     updatedAt?: string | null;
     _meta?: Record<string, unknown> | null;
 }
-export type ToolKind = "read" | "edit" | "execute" | "fetch" | "search" | "other";
+export type ToolKind = "read" | "edit" | "execute" | "fetch" | "search" | "question" | "other";
 export declare function mapToolNameToKind(toolName: string): ToolKind;
 export declare function extractPromptText(promptInput: unknown): string;
 export interface ModelDefinition {

package/dist/tool-formatter.js

@@ -102,7 +102,7 @@ export function normalizeToolCall(toolName, rawParams = {}, stepIndex) {
         return {
             toolCallId,
             title: "❓ Pergunta do Assistente",
-            kind: "other",
+            kind: "question",
             rawInput: normalizedParams,
             questionCard: questionCard || undefined,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-acp-agy",
-  "version": "1.2.15",
+  "version": "1.2.16",
   "description": "ACP (Agent Client Protocol) provider for Google Antigravity in Paseo and Zed",
   "type": "module",
   "main": "dist/index.js",