paseo-acp-agy 1.2.11 → 1.2.13

package/dist/acp-server.d.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from "node:events";
 import { SessionManager } from "./session.js";
 export declare class ACPServer extends EventEmitter {
     private sessionManager;
+    private mcpBridge;
     private input;
     private output;
     private binaryPath;

package/dist/acp-server.js

@@ -1,12 +1,14 @@
 import readline from "node:readline";
 import { EventEmitter } from "node:events";
 import { logger } from "./logger.js";
-import { ACP_METHODS, AVAILABLE_MODES, AVAILABLE_PERMISSIONS, fetchAvailableModels, buildConfigOptionsForSession, extractPromptText, mapToolNameToKind, extractImageMarkdownLink, isNarrationText, calculateUsageCostUsd, roundUsageCostUsd, getModelContextWindow, fetchAntigravityUsage, } from "./protocol.js";
+import { ACP_METHODS, AVAILABLE_MODES, AVAILABLE_PERMISSIONS, fetchAvailableModels, buildConfigOptionsForSession, extractPromptText, extractImageMarkdownLink, isNarrationText, calculateUsageCostUsd, roundUsageCostUsd, getModelContextWindow, fetchAntigravityUsage, } from "./protocol.js";
 import { SessionManager } from "./session.js";
 import { executeSlashCommand, AVAILABLE_SLASH_COMMANDS } from "./slash-commands.js";
 import { getShortVersion } from "./version.js";
 import { resolveDefaultAgyBinary } from "./antigravity-process.js";
 import { loadConversationTranscript } from "./transcript.js";
+import { normalizeToolCall, normalizeToolResult, extractPlanEntries } from "./tool-formatter.js";
+import { McpBridge } from "./mcp-bridge.js";
 function splitModelAndEffort(modelInput) {
     if (!modelInput)
         return {};
@@ -20,6 +22,7 @@ function splitModelAndEffort(modelInput) {
 }
 export class ACPServer extends EventEmitter {
     sessionManager;
+    mcpBridge;
     input;
     output;
     binaryPath;
@@ -31,6 +34,7 @@ export class ACPServer extends EventEmitter {
         this.input = options.input || process.stdin;
         this.output = options.output || process.stdout;
         this.binaryPath = options.binaryPath || resolveDefaultAgyBinary();
+        this.mcpBridge = new McpBridge(this.binaryPath);
         this.skipNarration =
             options.skipNarration ?? (process.env.AGY_ACP_SKIP_NARRATION === "true");
         this.sessionManager =
@@ -223,6 +227,10 @@ export class ACPServer extends EventEmitter {
                     const requestedModel = typeof params.model === "string" ? params.model : undefined;
                     const parsedModel = splitModelAndEffort(requestedModel);
                     const mode = typeof params.mode === "string" ? params.mode : undefined;
+                    const mcpServers = params.mcpServers;
+                    if (mcpServers) {
+                        void this.mcpBridge.syncServers(mcpServers);
+                    }
                     const session = this.sessionManager.createSession({
                         cwd,
                         model: parsedModel.model,
@@ -257,6 +265,10 @@ export class ACPServer extends EventEmitter {
                             this.sendError(id, -32602, "sessionId is required");
                         break;
                     }
+                    const mcpServers = params.mcpServers;
+                    if (mcpServers) {
+                        void this.mcpBridge.syncServers(mcpServers);
+                    }
                     let session = this.sessionManager.getSession(sessionId);
                     try {
                         if (!session) {
@@ -509,6 +521,17 @@ export class ACPServer extends EventEmitter {
                                         content: { type: "text", text: step.text_delta },
                                     },
                                 });
+                                // Live Plan / Todo checklist tracker
+                                const planEntries = extractPlanEntries(step.text_delta);
+                                if (planEntries) {
+                                    this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                        sessionId: session.id,
+                                        update: {
+                                            sessionUpdate: "plan",
+                                            entries: planEntries,
+                                        },
+                                    });
+                                }
                             }
                             else if (step.step_type === "thought" && step.text_delta) {
                                 hasSentNonNarration = true;
@@ -522,29 +545,40 @@ export class ACPServer extends EventEmitter {
                             }
                             else if (step.step_type === "tool" && step.tool_info) {
                                 hasSentNonNarration = true;
-                                const toolCallId = `tool_${step.step_index}`;
                                 const toolName = step.tool_name || step.tool_info.name || "tool";
-                                const toolKind = mapToolNameToKind(toolName);
+                                const toolCall = normalizeToolCall(toolName, step.tool_info.parameters || {}, step.step_index);
                                 if (step.state === "ACTIVE") {
                                     this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                         sessionId: session.id,
                                         update: {
                                             sessionUpdate: "tool_call",
-                                            toolCallId,
-                                            title: toolName,
-                                            kind: toolKind,
-                                            rawInput: step.tool_info.parameters || {},
+                                            toolCallId: toolCall.toolCallId,
+                                            title: toolCall.title,
+                                            kind: toolCall.kind,
+                                            ...(toolCall.locations ? { locations: toolCall.locations } : {}),
+                                            rawInput: toolCall.rawInput,
                                         },
                                     });
+                                    if (toolCall.questionCard) {
+                                        this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                            sessionId: session.id,
+                                            update: {
+                                                sessionUpdate: "agent_message_chunk",
+                                                content: { type: "text", text: `\n\n${toolCall.questionCard}\n\n` },
+                                            },
+                                        });
+                                    }
                                 }
                                 else if (step.state === "DONE") {
+                                    const toolRes = normalizeToolResult(toolName, step.tool_info.parameters || {}, step.tool_info.output);
                                     this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                         sessionId: session.id,
                                         update: {
                                             sessionUpdate: "tool_call_update",
-                                            toolCallId,
-                                            status: "completed",
-                                            rawOutput: step.tool_info.output ?? "",
+                                            toolCallId: toolCall.toolCallId,
+                                            status: toolRes.status,
+                                            rawOutput: toolRes.rawOutput,
+                                            ...(toolRes.content ? { content: toolRes.content } : {}),
                                         },
                                     });
                                     const imageMarkdown = extractImageMarkdownLink(toolName, step.tool_info.output, step.tool_info.parameters);
@@ -559,13 +593,14 @@ export class ACPServer extends EventEmitter {
                                     }
                                 }
                                 else if (step.state === "ERROR") {
+                                    const toolRes = normalizeToolResult(toolName, step.tool_info.parameters || {}, null, step.tool_info.error || { message: "Tool execution error" });
                                     this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                         sessionId: session.id,
                                         update: {
                                             sessionUpdate: "tool_call_update",
-                                            toolCallId,
+                                            toolCallId: toolCall.toolCallId,
                                             status: "failed",
-                                            rawOutput: step.tool_info.error?.message || "Tool execution error",
+                                            rawOutput: toolRes.rawOutput,
                                         },
                                     });
                                 }
@@ -610,7 +645,25 @@ export class ACPServer extends EventEmitter {
                             }
                         };
                         try {
-                            const resultEvent = await session.process.sendPrompt(promptText, onStepUpdate);
+                            let resultEvent;
+                            try {
+                                resultEvent = await session.process.sendPrompt(promptText, onStepUpdate);
+                            }
+                            catch (firstErr) {
+                                const firstMsg = firstErr.message || "";
+                                if (stepCount === 0 &&
+                                    !session.isCancelled &&
+                                    firstMsg.includes("agy process exited prematurely")) {
+                                    logger.warn("agy process exited before streaming any steps; retrying prompt with fresh process", {
+                                        sessionId,
+                                        error: firstMsg,
+                                    });
+                                    resultEvent = await session.process.sendPrompt(promptText, onStepUpdate);
+                                }
+                                else {
+                                    throw firstErr;
+                                }
+                            }
                             const turnUsage = resultEvent.result?.usage;
                             const numTurns = resultEvent.result?.num_turns || stepCount || 1;
                             // Usage is billable even when the turn terminates with ERROR
@@ -642,12 +695,14 @@ export class ACPServer extends EventEmitter {
                             }
                         }
                         catch (promptErr) {
-                            if (session.isCancelled) {
+                            const errorMsg = promptErr.message || "Turn execution failed";
+                            if (session.isCancelled ||
+                                errorMsg.includes("cancelled") ||
+                                errorMsg.includes("Turn was cancelled")) {
                                 if (!isNotification)
                                     this.sendSuccess(id, { stopReason: "cancelled" });
                             }
                             else {
-                                const errorMsg = promptErr.message || "Turn execution failed";
                                 logger.error("Error executing prompt turn", { error: errorMsg, sessionId });
                                 this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                     sessionId: session.id,

package/dist/antigravity-process.js

@@ -399,6 +399,7 @@ export class AntigravityProcess extends EventEmitter {
         child.stderr.setEncoding("utf-8");
         let stdoutBuffer = "";
         let stderrBuffer = "";
+        const recentStderrLines = [];
         child.stdout.on("data", (chunk) => {
             this.emit("activity");
             stdoutBuffer += chunk;
@@ -424,8 +425,13 @@ export class AntigravityProcess extends EventEmitter {
             const lines = stderrBuffer.split("\n");
             stderrBuffer = lines.pop() || "";
             for (const line of lines) {
-                if (line.trim())
-                    logger.warn("agy stderr: " + line.trim());
+                const trimmed = line.trim();
+                if (trimmed) {
+                    logger.warn("agy stderr: " + trimmed);
+                    recentStderrLines.push(trimmed);
+                    if (recentStderrLines.length > 20)
+                        recentStderrLines.shift();
+                }
             }
         });
         child.on("error", (err) => {
@@ -438,9 +444,24 @@ export class AntigravityProcess extends EventEmitter {
         });
         child.on("close", (code, signal) => {
             logger.info("agy process exited", { code, signal, pid: child.pid });
+            if (stderrBuffer.trim()) {
+                recentStderrLines.push(stderrBuffer.trim());
+                if (recentStderrLines.length > 20)
+                    recentStderrLines.shift();
+            }
+            const stderrDiagnostic = recentStderrLines.join(" ").trim();
+            const exitDiagnostic = stderrDiagnostic
+                ? `agy process exited prematurely with code ${code} signal ${signal}: ${stderrDiagnostic}`
+                : `agy process exited prematurely with code ${code} signal ${signal}`;
             if (this.currentTurnPromise?.child === child) {
-                this.currentTurnPromise.reject(new Error(`agy process exited prematurely with code ${code} signal ${signal}`));
+                const turn = this.currentTurnPromise;
                 this.currentTurnPromise = null;
+                if (turn.cancelled) {
+                    turn.reject(new Error("Turn was cancelled"));
+                }
+                else {
+                    turn.reject(new Error(exitDiagnostic));
+                }
             }
             // The leader can die while a tool subprocess remains in its process
             // group. Keep the group identity long enough to reap those descendants.
@@ -742,6 +763,11 @@ export class AntigravityProcess extends EventEmitter {
         logger.info("Cancelling active agy turn", { hasChild: Boolean(active.child) });
         if (active.child) {
             const child = active.child;
+            // Immediately detach this.child so subsequent turns will NOT attach to this dying process!
+            if (this.child === child) {
+                this.child = null;
+                this.initialInfo = null;
+            }
             this.signalProcessTree(child, "SIGINT");
             setTimeout(() => {
                 if (this.isProcessTreeAlive(child)) {

package/dist/mcp-bridge.d.ts

@@ -0,0 +1,27 @@
+export interface McpServerStdioConfig {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    alwaysLoad?: boolean;
+}
+export interface McpServerHttpConfig {
+    type: "http" | "sse";
+    url: string;
+    headers?: Record<string, string>;
+    alwaysLoad?: boolean;
+}
+export type McpServerConfig = McpServerStdioConfig | McpServerHttpConfig;
+/**
+ * Bridges Paseo session MCP servers into Google Antigravity CLI's MCP system.
+ */
+export declare class McpBridge {
+    private readonly binaryPath;
+    private registered;
+    constructor(binaryPath?: string);
+    /**
+     * Syncs MCP servers configured by Paseo into Antigravity.
+     */
+    syncServers(servers?: Record<string, McpServerConfig>): Promise<void>;
+    private addServer;
+}

package/dist/mcp-bridge.js

@@ -0,0 +1,62 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "./logger.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Bridges Paseo session MCP servers into Google Antigravity CLI's MCP system.
+ */
+export class McpBridge {
+    binaryPath;
+    registered = new Set();
+    constructor(binaryPath = "agy") {
+        this.binaryPath = binaryPath;
+    }
+    /**
+     * Syncs MCP servers configured by Paseo into Antigravity.
+     */
+    async syncServers(servers) {
+        if (!servers || typeof servers !== "object")
+            return;
+        for (const [name, config] of Object.entries(servers)) {
+            if (!name || !config || typeof config !== "object")
+                continue;
+            const key = `${name}:${JSON.stringify(config)}`;
+            if (this.registered.has(key))
+                continue;
+            try {
+                await this.addServer(name, config);
+                this.registered.add(key);
+                logger.info("Successfully synced MCP server from Paseo to Antigravity", { name, type: config.type });
+            }
+            catch (err) {
+                logger.warn("Could not sync MCP server to Antigravity (continuing without it)", {
+                    name,
+                    error: err.message,
+                });
+            }
+        }
+    }
+    async addServer(name, config) {
+        const args = ["mcp", "add"];
+        if (config.type === "stdio") {
+            if (config.env) {
+                for (const [k, v] of Object.entries(config.env)) {
+                    args.push("--env", `${k}=${v}`);
+                }
+            }
+            args.push(name, config.command);
+            if (config.args && config.args.length > 0) {
+                args.push(...config.args);
+            }
+        }
+        else if (config.type === "http" || config.type === "sse") {
+            if (config.headers) {
+                for (const [k, v] of Object.entries(config.headers)) {
+                    args.push("--header", `${k}: ${v}`);
+                }
+            }
+            args.push(name, config.url);
+        }
+        await execFileAsync(this.binaryPath, args, { timeout: 10_000 });
+    }
+}

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" | "other";
+export type ToolKind = "read" | "edit" | "execute" | "fetch" | "search" | "other";
 export declare function mapToolNameToKind(toolName: string): ToolKind;
 export declare function extractPromptText(promptInput: unknown): string;
 export interface ModelDefinition {

package/dist/protocol.js

@@ -40,12 +40,18 @@ export const ACP_METHODS = {
 };
 export function mapToolNameToKind(toolName) {
     const name = toolName.toLowerCase();
+    if (name.includes("search") ||
+        name.includes("grep") ||
+        name.includes("find") ||
+        name === "search_web" ||
+        name === "grep_search" ||
+        name === "find_by_name")
+        return "search";
     if (name.includes("read") ||
         name.includes("view") ||
         name.includes("list") ||
-        name.includes("grep") ||
-        name.includes("find") ||
         name === "view_file" ||
+        name === "read_file" ||
         name === "list_dir")
         return "read";
     if (name.includes("write") ||
@@ -59,12 +65,11 @@ export function mapToolNameToKind(toolName) {
     if (name.includes("command") ||
         name.includes("terminal") ||
         name.includes("execute") ||
+        name.includes("subagent") ||
         name === "run_command")
         return "execute";
-    if (name.includes("search") ||
-        name.includes("url") ||
-        name.includes("browser") ||
-        name === "search_web")
+    if (name.includes("url") ||
+        name.includes("browser"))
         return "fetch";
     return "other";
 }

package/dist/tool-formatter.d.ts

@@ -0,0 +1,37 @@
+import { ToolKind } from "./protocol.js";
+export interface NormalizedToolCall {
+    toolCallId: string;
+    title: string;
+    kind: ToolKind;
+    locations?: Array<{
+        path: string;
+        line?: number;
+    }>;
+    rawInput: Record<string, unknown>;
+    questionCard?: string;
+}
+export interface NormalizedToolResult {
+    status: "completed" | "failed";
+    rawOutput: string;
+    content?: Array<Record<string, unknown>>;
+    imageMarkdown?: string;
+}
+export interface PlanEntry {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+}
+/**
+ * Normalizes Antigravity tool calls into standard ACP format with descriptive titles,
+ * proper kinds, clickable file locations, and normalized parameter names.
+ */
+export declare function normalizeToolCall(toolName: string, rawParams: Record<string, unknown> | undefined, stepIndex: number): NormalizedToolCall;
+/**
+ * Normalizes tool execution results into rich timeline content (diffs, terminals, text, images).
+ */
+export declare function normalizeToolResult(toolName: string, rawParams: Record<string, unknown> | undefined, output: unknown, error?: {
+    message?: string;
+}): NormalizedToolResult;
+/**
+ * Extracts markdown checklist / todo plan updates from assistant text or thoughts.
+ */
+export declare function extractPlanEntries(text: string): PlanEntry[] | null;

package/dist/tool-formatter.js

@@ -0,0 +1,219 @@
+import path from "node:path";
+/**
+ * Normalizes Antigravity tool calls into standard ACP format with descriptive titles,
+ * proper kinds, clickable file locations, and normalized parameter names.
+ */
+export function normalizeToolCall(toolName, rawParams = {}, stepIndex) {
+    const toolCallId = `tool_${stepIndex}`;
+    const normalizedParams = { ...rawParams };
+    const name = toolName.toLowerCase();
+    // 1. Shell commands: run_command
+    if (name === "run_command" ||
+        name.includes("command") ||
+        name.includes("terminal") ||
+        Boolean(rawParams.CommandLine) ||
+        Boolean(rawParams.command)) {
+        const cmd = String(rawParams.CommandLine || rawParams.command || rawParams.cmd || "").trim();
+        const summary = String(rawParams.toolSummary || rawParams.summary || "").trim();
+        const title = summary || (cmd ? truncate(cmd, 60) : "run_command");
+        normalizedParams.command = cmd;
+        normalizedParams.CommandLine = cmd;
+        return {
+            toolCallId,
+            title,
+            kind: "execute",
+            rawInput: normalizedParams,
+        };
+    }
+    // 2. File reads: read_file, view_file, list_dir
+    if (name === "read_file" || name === "view_file" || name === "list_dir" || name.includes("read")) {
+        const rawPath = String(rawParams.Path || rawParams.path || rawParams.AbsolutePath || rawParams.filePath || rawParams.file || "").trim();
+        const startLine = typeof rawParams.StartLine === "number" ? rawParams.StartLine : undefined;
+        const base = rawPath ? path.basename(rawPath) : "read_file";
+        const title = rawPath ? (startLine ? `${base}:${startLine}` : base) : "read_file";
+        normalizedParams.path = rawPath;
+        normalizedParams.filePath = rawPath;
+        normalizedParams.Path = rawPath;
+        return {
+            toolCallId,
+            title,
+            kind: "read",
+            locations: rawPath ? [{ path: rawPath, ...(startLine ? { line: startLine } : {}) }] : undefined,
+            rawInput: normalizedParams,
+        };
+    }
+    // 3. File edits / writes: edit_file, write_file, replace_file_content, multi_replace_file_content
+    if (name === "edit_file" ||
+        name === "write_file" ||
+        name === "replace_file_content" ||
+        name === "multi_replace_file_content" ||
+        name === "sed_file" ||
+        name.includes("edit") ||
+        name.includes("write")) {
+        const rawPath = String(rawParams.Path || rawParams.path || rawParams.AbsolutePath || rawParams.filePath || rawParams.TargetFile || "").trim();
+        const base = rawPath ? path.basename(rawPath) : "edit_file";
+        const target = String(rawParams.Target || rawParams.oldText || rawParams.oldString || "");
+        const replacement = String(rawParams.Replacement || rawParams.newText || rawParams.newString || rawParams.Content || "");
+        normalizedParams.path = rawPath;
+        normalizedParams.filePath = rawPath;
+        normalizedParams.Path = rawPath;
+        normalizedParams.oldText = target;
+        normalizedParams.oldString = target;
+        normalizedParams.newText = replacement;
+        normalizedParams.newString = replacement;
+        return {
+            toolCallId,
+            title: base,
+            kind: "edit",
+            locations: rawPath ? [{ path: rawPath }] : undefined,
+            rawInput: normalizedParams,
+        };
+    }
+    // 4. Search tools: search_web, grep_search, find_by_name
+    if (name === "search_web" || name === "grep_search" || name === "find_by_name" || name.includes("search")) {
+        const query = String(rawParams.query || rawParams.pattern || rawParams.CommandLine || "").trim();
+        const title = query ? `Busca: ${truncate(query, 50)}` : "search";
+        normalizedParams.query = query;
+        return {
+            toolCallId,
+            title,
+            kind: "search",
+            rawInput: normalizedParams,
+        };
+    }
+    // 5. Subagents: invoke_subagent, browser_subagent, manage_subagents
+    if (name.includes("subagent")) {
+        const role = String(rawParams.Role || rawParams.TypeName || rawParams.type || "Subagente").trim();
+        const prompt = String(rawParams.Prompt || rawParams.prompt || "").trim();
+        const title = `🤖 Subagente: ${role}`;
+        normalizedParams.role = role;
+        normalizedParams.prompt = prompt;
+        return {
+            toolCallId,
+            title,
+            kind: "execute",
+            rawInput: normalizedParams,
+        };
+    }
+    // 6. Interactive Questions: ask_question
+    if (name === "ask_question") {
+        const questions = Array.isArray(rawParams.questions) ? rawParams.questions : [];
+        const questionCard = formatQuestionCard(questions);
+        return {
+            toolCallId,
+            title: "❓ Pergunta do Assistente",
+            kind: "other",
+            rawInput: normalizedParams,
+            questionCard: questionCard || undefined,
+        };
+    }
+    // 7. General fallback
+    const summary = String(rawParams.toolSummary || rawParams.summary || "").trim();
+    return {
+        toolCallId,
+        title: summary || toolName,
+        kind: "other",
+        rawInput: normalizedParams,
+    };
+}
+/**
+ * Normalizes tool execution results into rich timeline content (diffs, terminals, text, images).
+ */
+export function normalizeToolResult(toolName, rawParams = {}, output, error) {
+    if (error) {
+        return {
+            status: "failed",
+            rawOutput: error.message || "Tool execution error",
+        };
+    }
+    const outputStr = typeof output === "string" ? output : JSON.stringify(output ?? "");
+    const name = toolName.toLowerCase();
+    const content = [];
+    // Edit tools: emit diff block so Paseo displays visual green/red syntax diffs
+    if (name === "edit_file" ||
+        name === "replace_file_content" ||
+        name === "multi_replace_file_content" ||
+        name === "write_file") {
+        const filePath = String(rawParams.Path || rawParams.path || rawParams.AbsolutePath || "");
+        const oldText = String(rawParams.Target || rawParams.oldText || rawParams.oldString || "");
+        const newText = String(rawParams.Replacement || rawParams.newText || rawParams.newString || rawParams.Content || "");
+        if (oldText || newText) {
+            content.push({
+                type: "diff",
+                path: filePath,
+                oldText,
+                newText,
+            });
+        }
+    }
+    else if (name === "read_file" || name === "view_file") {
+        if (outputStr.trim()) {
+            content.push({
+                type: "text",
+                text: outputStr,
+            });
+        }
+    }
+    return {
+        status: "completed",
+        rawOutput: outputStr,
+        content: content.length > 0 ? content : undefined,
+    };
+}
+/**
+ * Extracts markdown checklist / todo plan updates from assistant text or thoughts.
+ */
+export function extractPlanEntries(text) {
+    if (!text || typeof text !== "string")
+        return null;
+    const lines = text.split(/\r?\n/);
+    const entries = [];
+    for (const line of lines) {
+        const match = line.match(/^[-*]\s+\[([ xX/\\-])\]\s+(.+)$/);
+        if (match) {
+            const mark = match[1].trim();
+            const content = match[2].trim();
+            let status = "pending";
+            if (mark === "x" || mark === "X") {
+                status = "completed";
+            }
+            else if (mark === "/" || mark === "-") {
+                status = "in_progress";
+            }
+            entries.push({ content, status });
+        }
+    }
+    return entries.length >= 2 ? entries : null;
+}
+/**
+ * Formats Antigravity's ask_question structure into a clear, responsive markdown card.
+ */
+function formatQuestionCard(questions) {
+    if (!questions || questions.length === 0)
+        return "";
+    const cards = [];
+    for (const q of questions) {
+        if (!q || typeof q !== "object")
+            continue;
+        const prompt = q.question || "Escolha uma opção:";
+        const options = Array.isArray(q.options) ? q.options : [];
+        let card = `### ❓ Pergunta do Assistente\n> **${prompt}**\n\n`;
+        if (options.length > 0) {
+            card += `*Responda indicando o número da opção desejada:*\n`;
+            card += options
+                .map((opt, idx) => {
+                const isRec = opt.includes("(Recommended)") || opt.includes("(Recomendado)");
+                const clean = opt.replace(/^\(Recommended\)\s*/i, "").replace(/^\(Recomendado\)\s*/i, "");
+                return `- **[${idx + 1}]** ${clean}${isRec ? " *(Recomendado)*" : ""}`;
+            })
+                .join("\n");
+        }
+        cards.push(card);
+    }
+    return cards.join("\n\n---\n\n");
+}
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 3) + "...";
+}

package/dist/transcript.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { logger } from "./logger.js";
-import { mapToolNameToKind } from "./protocol.js";
+import { normalizeToolCall } from "./tool-formatter.js";
 /**
  * Strips XML-like tags injected by harness or system prompts (e.g., <USER_REQUEST>, <ADDITIONAL_METADATA>)
  * to recover the clean user prompt for history display in clients like Paseo.
@@ -106,21 +106,20 @@ export function loadConversationTranscript(conversationId) {
                     for (let i = 0; i < step.tool_calls.length; i++) {
                         const tc = step.tool_calls[i];
                         const rawArgs = (tc.args || tc.parameters || {});
-                        const toolName = String(tc.name || tc.tool_name || rawArgs.toolAction || "tool");
-                        const title = String(rawArgs.toolSummary ||
-                            rawArgs.toolAction ||
-                            tc.toolSummary ||
-                            tc.toolAction ||
-                            tc.name ||
-                            "tool");
-                        const toolCallId = `tool_${stepIndex}_${i}`;
-                        lastToolCallId = toolCallId;
+                        const toolName = String(tc.name || tc.tool_name || tc.toolAction || rawArgs.toolAction || "tool");
+                        const mergedParams = {
+                            ...rawArgs,
+                            toolSummary: rawArgs.toolSummary || tc.toolSummary,
+                            toolAction: rawArgs.toolAction || tc.toolAction,
+                        };
+                        const toolCall = normalizeToolCall(toolName, mergedParams, stepIndex * 100 + i);
+                        lastToolCallId = toolCall.toolCallId;
                         replayItems.push({
                             type: "tool_call",
-                            toolCallId,
-                            title,
-                            kind: mapToolNameToKind(toolName),
-                            rawInput: rawArgs,
+                            toolCallId: toolCall.toolCallId,
+                            title: toolCall.title,
+                            kind: toolCall.kind,
+                            rawInput: toolCall.rawInput,
                         });
                     }
                 }

package/package.json

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