paseo-acp-agy 1.1.9 → 1.2.0

package/dist/acp-server.d.ts

@@ -5,6 +5,7 @@ export declare class ACPServer {
     private input;
     private output;
     private binaryPath;
+    private skipNarration;
     private rl;
     private isRunning;
     constructor(options?: {
@@ -12,6 +13,7 @@ export declare class ACPServer {
         output?: Writable;
         sessionManager?: SessionManager;
         binaryPath?: string;
+        skipNarration?: boolean;
     });
     start(): void;
     private send;

package/dist/acp-server.js

@@ -1,6 +1,6 @@
 import readline from "node:readline";
 import { logger } from "./logger.js";
-import { ACP_METHODS, AVAILABLE_MODES, fetchAvailableModels, buildConfigOptionsForModel, extractPromptText, mapToolNameToKind, calculateUsageCostUsd, roundUsageCostUsd, getModelContextWindow, fetchAntigravityUsage, } from "./protocol.js";
+import { ACP_METHODS, AVAILABLE_MODES, AVAILABLE_PERMISSIONS, fetchAvailableModels, buildConfigOptionsForSession, extractPromptText, mapToolNameToKind, 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";
@@ -21,12 +21,15 @@ export class ACPServer {
     input;
     output;
     binaryPath;
+    skipNarration;
     rl = null;
     isRunning = false;
     constructor(options = {}) {
         this.input = options.input || process.stdin;
         this.output = options.output || process.stdout;
         this.binaryPath = options.binaryPath || resolveDefaultAgyBinary();
+        this.skipNarration =
+            options.skipNarration ?? (process.env.AGY_ACP_SKIP_NARRATION === "true");
         this.sessionManager =
             options.sessionManager || new SessionManager({ defaultBinaryPath: this.binaryPath });
     }
@@ -112,7 +115,13 @@ export class ACPServer {
                 availableModels,
                 currentModelId: session.model,
             },
-            configOptions: buildConfigOptionsForModel(session.model, session.effort, availableModels),
+            configOptions: buildConfigOptionsForSession({
+                modelId: session.model,
+                currentEffort: session.effort,
+                currentMode: session.mode,
+                currentPermission: session.permission,
+                availableModels,
+            }),
         };
     }
     requireSession(sessionId) {
@@ -329,11 +338,19 @@ export class ACPServer {
                                 this.sendSuccess(id, { stopReason: "end_turn" });
                             break;
                         }
+                        let hasSentNonNarration = false;
                         const onStepUpdate = (event) => {
                             const step = event.step_update;
                             if (!step)
                                 return;
                             if (step.step_type === "agent_response" && step.text_delta) {
+                                if (this.skipNarration && !hasSentNonNarration) {
+                                    if (isNarrationText(step.text_delta)) {
+                                        logger.debug("Skipping pure narration text chunk", { delta: step.text_delta });
+                                        return;
+                                    }
+                                    hasSentNonNarration = true;
+                                }
                                 this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                     sessionId: session.id,
                                     update: {
@@ -343,6 +360,7 @@ export class ACPServer {
                                 });
                             }
                             else if (step.step_type === "thought" && step.text_delta) {
+                                hasSentNonNarration = true;
                                 this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                     sessionId: session.id,
                                     update: {
@@ -352,6 +370,7 @@ export class ACPServer {
                                 });
                             }
                             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);
@@ -377,6 +396,16 @@ export class ACPServer {
                                             rawOutput: step.tool_info.output ?? "",
                                         },
                                     });
+                                    const imageMarkdown = extractImageMarkdownLink(toolName, step.tool_info.output, step.tool_info.parameters);
+                                    if (imageMarkdown) {
+                                        this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                            sessionId: session.id,
+                                            update: {
+                                                sessionUpdate: "agent_message_chunk",
+                                                content: { type: "text", text: `\n\n${imageMarkdown}\n\n` },
+                                            },
+                                        });
+                                    }
                                 }
                                 else if (step.state === "ERROR") {
                                     this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
@@ -496,6 +525,7 @@ export class ACPServer {
                     break;
                 }
                 case ACP_METHODS.SESSION_SET_MODE:
+                case ACP_METHODS.SESSION_SET_MODE_CAMEL:
                 case ACP_METHODS.SESSION_SET_MODE_ALIAS: {
                     const sessionId = String(params.sessionId || "");
                     const modeId = String(params.modeId || params.mode || "default");
@@ -516,6 +546,7 @@ export class ACPServer {
                     break;
                 }
                 case ACP_METHODS.SESSION_SET_MODEL:
+                case ACP_METHODS.SESSION_SET_MODEL_CAMEL:
                 case ACP_METHODS.SESSION_SET_MODEL_ALIAS: {
                     const sessionId = String(params.sessionId || "");
                     const session = this.requireSession(sessionId);
@@ -546,12 +577,19 @@ export class ACPServer {
                     if (parsedModel.effort)
                         session.setEffort(parsedModel.effort);
                     session.setModel(model.modelId);
-                    const configOptions = buildConfigOptionsForModel(session.model, session.effort, models);
+                    const configOptions = buildConfigOptionsForSession({
+                        modelId: session.model,
+                        currentEffort: session.effort,
+                        currentMode: session.mode,
+                        currentPermission: session.permission,
+                        availableModels: models,
+                    });
                     if (!isNotification)
                         this.sendSuccess(id, { configOptions });
                     break;
                 }
                 case ACP_METHODS.SESSION_SET_CONFIG_OPTION:
+                case ACP_METHODS.SESSION_SET_CONFIG_OPTION_CAMEL:
                 case ACP_METHODS.SESSION_SET_CONFIG_OPTION_ALIAS: {
                     const sessionId = String(params.sessionId || "");
                     const configId = String(params.configId || "");
@@ -584,12 +622,36 @@ export class ACPServer {
                         session.setModel(value);
                         logger.info("Updated model for session via config option", { sessionId, model: value });
                     }
+                    else if (configId === "mode") {
+                        if (!AVAILABLE_MODES.some((candidate) => candidate.id === value)) {
+                            if (!isNotification)
+                                this.sendError(id, -32602, `Unsupported mode: ${value}`);
+                            break;
+                        }
+                        session.setMode(value);
+                        logger.info("Updated mode for session via config option", { sessionId, mode: value });
+                    }
+                    else if (configId === "permission") {
+                        if (!AVAILABLE_PERMISSIONS.some((candidate) => candidate.id === value)) {
+                            if (!isNotification)
+                                this.sendError(id, -32602, `Unsupported permission: ${value}`);
+                            break;
+                        }
+                        session.setPermission(value);
+                        logger.info("Updated permission for session via config option", { sessionId, permission: value });
+                    }
                     else {
                         if (!isNotification)
                             this.sendError(id, -32602, `Unsupported config option: ${configId}`);
                         break;
                     }
-                    const configOptions = buildConfigOptionsForModel(session.model, session.effort, models);
+                    const configOptions = buildConfigOptionsForSession({
+                        modelId: session.model,
+                        currentEffort: session.effort,
+                        currentMode: session.mode,
+                        currentPermission: session.permission,
+                        availableModels: models,
+                    });
                     if (!isNotification)
                         this.sendSuccess(id, { configOptions });
                     break;

package/dist/antigravity-process.d.ts

@@ -40,6 +40,8 @@ export declare class AntigravityProcess extends EventEmitter {
     setModel(model: string): void;
     setEffort(effort: string): void;
     setMode(mode: string): void;
+    get currentPermissions(): PermissionSettings;
+    setPermissions(permissions: Partial<PermissionSettings>): void;
     setConversationId(conversationId?: string): void;
     private scheduleRestart;
     private isProcessTreeAlive;

package/dist/antigravity-process.js

@@ -189,6 +189,13 @@ export class AntigravityProcess extends EventEmitter {
             this.scheduleRestart();
         }
     }
+    get currentPermissions() {
+        return this.permissions;
+    }
+    setPermissions(permissions) {
+        this.permissions = { ...this.permissions, ...permissions };
+        this.scheduleRestart();
+    }
     setConversationId(conversationId) {
         if (this.conversationId !== conversationId) {
             this.conversationId = conversationId;

package/dist/asar.d.ts

@@ -0,0 +1,28 @@
+export interface AsarNode {
+    files?: Record<string, AsarNode>;
+    size?: number;
+    offset?: string;
+    executable?: boolean;
+    unpacked?: boolean;
+}
+/**
+ * Reads and parses the ASAR archive header and returns the root node and base offset for data.
+ */
+export declare function readArchiveHeader(archivePath: string): {
+    header: AsarNode;
+    dataBaseOffset: number;
+};
+/**
+ * Lists all file paths inside an ASAR archive.
+ */
+export declare function listPackage(archivePath: string): string[];
+/**
+ * Pure TypeScript, zero-dependency ASAR archive extractor.
+ * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
+ */
+export declare function extractAll(archivePath: string, destDir: string): void;
+/**
+ * Pure TypeScript, zero-dependency ASAR archive builder.
+ * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
+ */
+export declare function createPackage(srcDir: string, destFile: string): Promise<void>;

package/dist/asar.js

@@ -0,0 +1,171 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Reads and parses the ASAR archive header and returns the root node and base offset for data.
+ */
+export function readArchiveHeader(archivePath) {
+    if (!fs.existsSync(archivePath)) {
+        throw new Error(`ASAR archive not found: ${archivePath}`);
+    }
+    const fd = fs.openSync(archivePath, "r");
+    try {
+        const sizeBuf = Buffer.alloc(8);
+        const bytesRead = fs.readSync(fd, sizeBuf, 0, 8, 0);
+        if (bytesRead < 8) {
+            throw new Error(`Invalid ASAR archive: file too small (${bytesRead} bytes)`);
+        }
+        const payloadSize = sizeBuf.readUInt32LE(0);
+        const headerSize = sizeBuf.readUInt32LE(4);
+        if (payloadSize !== 4 || headerSize <= 0) {
+            throw new Error(`Invalid ASAR archive header size: payloadSize=${payloadSize}, headerSize=${headerSize}`);
+        }
+        const headerPickleBuf = Buffer.alloc(headerSize);
+        const headerRead = fs.readSync(fd, headerPickleBuf, 0, headerSize, 8);
+        if (headerRead < headerSize) {
+            throw new Error(`Truncated ASAR header: expected ${headerSize} bytes, got ${headerRead}`);
+        }
+        const strLen = headerPickleBuf.readUInt32LE(4);
+        const jsonStr = headerPickleBuf.subarray(8, 8 + strLen).toString("utf8");
+        const header = JSON.parse(jsonStr);
+        const dataBaseOffset = 8 + headerSize;
+        return { header, dataBaseOffset };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Lists all file paths inside an ASAR archive.
+ */
+export function listPackage(archivePath) {
+    const { header } = readArchiveHeader(archivePath);
+    const result = [];
+    function walk(node, currentPrefix) {
+        if (node.files) {
+            for (const [name, child] of Object.entries(node.files)) {
+                const next = currentPrefix ? `${currentPrefix}/${name}` : `/${name}`;
+                walk(child, next);
+            }
+        }
+        else {
+            result.push(currentPrefix);
+        }
+    }
+    walk(header, "");
+    return result;
+}
+/**
+ * Pure TypeScript, zero-dependency ASAR archive extractor.
+ * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
+ */
+export function extractAll(archivePath, destDir) {
+    const { header, dataBaseOffset } = readArchiveHeader(archivePath);
+    const fd = fs.openSync(archivePath, "r");
+    try {
+        function extractNode(node, currentPath, relParts = []) {
+            if (node.files) {
+                fs.mkdirSync(currentPath, { recursive: true });
+                for (const [name, child] of Object.entries(node.files)) {
+                    extractNode(child, path.join(currentPath, name), [...relParts, name]);
+                }
+            }
+            else if (node.size !== undefined && node.offset !== undefined) {
+                const fileOffset = dataBaseOffset + parseInt(node.offset, 10);
+                const fileBuf = Buffer.alloc(node.size);
+                if (node.size > 0) {
+                    fs.readSync(fd, fileBuf, 0, node.size, fileOffset);
+                }
+                fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+                fs.writeFileSync(currentPath, fileBuf, {
+                    mode: node.executable ? 0o755 : 0o644,
+                });
+            }
+            else if (node.unpacked) {
+                const unpackedSrc = path.join(archivePath + ".unpacked", ...relParts);
+                if (fs.existsSync(unpackedSrc)) {
+                    fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+                    fs.copyFileSync(unpackedSrc, currentPath);
+                }
+            }
+        }
+        extractNode(header, destDir);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Pure TypeScript, zero-dependency ASAR archive builder.
+ * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
+ */
+export async function createPackage(srcDir, destFile) {
+    const files = [];
+    function walk(dir, rel = "") {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of entries) {
+            const entryRel = rel ? `${rel}/${e.name}` : e.name;
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walk(full, entryRel);
+            }
+            else if (e.isFile()) {
+                const stat = fs.statSync(full);
+                const executable = Boolean(stat.mode & 0o111);
+                files.push({
+                    relPath: entryRel,
+                    fullPath: full,
+                    size: stat.size,
+                    executable: executable || undefined,
+                });
+            }
+        }
+    }
+    walk(srcDir);
+    const header = { files: {} };
+    let currentOffset = 0;
+    for (const f of files) {
+        const parts = f.relPath.split("/");
+        let curr = header.files;
+        for (let i = 0; i < parts.length - 1; i++) {
+            if (!curr[parts[i]]) {
+                curr[parts[i]] = { files: {} };
+            }
+            curr = curr[parts[i]].files;
+        }
+        const leaf = parts[parts.length - 1];
+        curr[leaf] = {
+            size: f.size,
+            offset: String(currentOffset),
+            executable: f.executable,
+        };
+        currentOffset += f.size;
+    }
+    const jsonBuf = Buffer.from(JSON.stringify(header), "utf8");
+    const alignedJsonLen = (jsonBuf.length + 3) & ~3;
+    const headerPayloadSize = 4 + alignedJsonLen;
+    // Header pickle: payloadSize (uint32LE) + stringLength (uint32LE) + json bytes (padded to multiple of 4)
+    const headerPickle = Buffer.alloc(4 + headerPayloadSize, 0);
+    headerPickle.writeUInt32LE(headerPayloadSize, 0);
+    headerPickle.writeUInt32LE(jsonBuf.length, 4);
+    jsonBuf.copy(headerPickle, 8);
+    // Size pickle: 4 (uint32LE payload size) + headerPickle.length (uint32LE)
+    const sizePickle = Buffer.alloc(8, 0);
+    sizePickle.writeUInt32LE(4, 0);
+    sizePickle.writeUInt32LE(headerPickle.length, 4);
+    fs.mkdirSync(path.dirname(destFile), { recursive: true });
+    const fd = fs.openSync(destFile, "w");
+    try {
+        fs.writeSync(fd, sizePickle);
+        fs.writeSync(fd, headerPickle);
+        for (const f of files) {
+            if (f.size > 0) {
+                const content = fs.readFileSync(f.fullPath);
+                fs.writeSync(fd, content);
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}

package/dist/attachments.js

@@ -7,6 +7,9 @@ const DEFAULT_MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 function getStateRoot() {
     if (process.env.AGY_ACP_STATE_DIR)
         return process.env.AGY_ACP_STATE_DIR;
+    if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+        return path.join(process.env.LOCALAPPDATA, "agy-acp");
+    }
     const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
     return path.join(stateHome, "agy-acp");
 }

package/dist/index.js

@@ -32,18 +32,22 @@ Commands:
   doctor         Diagnose Antigravity binary, quota provider, and Paseo status
 
 Options:
-  --acp          Start ACP server over stdio (default)
-  --setup        Integrate Antigravity with local Paseo server installation
-  --doctor       Run environment, binary, and telemetry diagnostics
-  -v, --version  Show version
-  --json         Show version in JSON format (with --version)
-  -h, --help     Show help
+  --acp             Start ACP server over stdio (default)
+  --setup           Integrate Antigravity with local Paseo server installation
+  --doctor          Run environment, binary, and telemetry diagnostics
+  --skip-naration   Drop leading narration-only assistant chunks (e.g. 'I will...')
+  --skip-narration  Alias for --skip-naration
+  -v, --version     Show version
+  --json            Show version in JSON format (with --version)
+  -h, --help        Show help
 
 Environment Variables:
   AGY_ACP_LOG_LEVEL                 debug | info | warn | error (default: info)
   AGY_ACP_LOG_DIR                   Directory for log files
   AGY_ACP_SANDBOX                   Set to 'true' to run agy in sandbox mode
   AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS Set to 'true' to auto-approve tool permissions
+  AGY_ACP_SKIP_NARRATION            Set to 'true' to drop leading narration chunks
+  AGY_EXTRA_ARGS                    Extra space-separated CLI arguments passed to agy
   AGY_BIN_PATH                      Path to agy binary (default: agy in PATH or ~/.local/bin/agy)
   PASEO_SERVER_PATH                 Path to local @getpaseo/server directory
   PASEO_ASAR_PATH                   Path to local Paseo app.asar package
@@ -239,7 +243,10 @@ if (args.includes("setup") ||
 }
 // Auto-run integration in background when starting ACP server
 void ensurePaseoIntegration().catch(() => { });
-const server = new ACPServer();
+const skipNarration = args.includes("--skip-naration") ||
+    args.includes("--skip-narration") ||
+    process.env.AGY_ACP_SKIP_NARRATION === "true";
+const server = new ACPServer({ skipNarration });
 const cleanup = async () => {
     try {
         await server.stop();

package/dist/paseo-patcher.js

@@ -3,6 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
 import { logger } from "./logger.js";
+import { extractAll, createPackage, listPackage } from "./asar.js";
 /**
  * Searches the host machine for @getpaseo/server installations across
  * Windows, macOS, and Linux.
@@ -160,7 +161,12 @@ export function findPaseoServerInstallations() {
     }
     // Filter out any paths that do not actually have a dist directory or package.json
     const verified = [];
+    const seen = new Set();
     for (const dir of candidates) {
+        const key = process.platform === "win32" ? dir.toLowerCase() : dir;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
         if (fs.existsSync(path.join(dir, "dist")) || fs.existsSync(path.join(dir, "package.json"))) {
             verified.push(dir);
         }
@@ -649,7 +655,16 @@ export function findPaseoAsarPaths() {
                 candidates.add(path.resolve(loc));
         }
     }
-    return Array.from(candidates);
+    const result = [];
+    const seen = new Set();
+    for (const loc of candidates) {
+        const key = process.platform === "win32" ? loc.toLowerCase() : loc;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(loc);
+        }
+    }
+    return result;
 }
 /**
  * Extracts, patches, and repacks a Paseo app.asar archive to integrate Antigravity
@@ -663,11 +678,8 @@ export async function patchPaseoAsar(asarPath) {
         if (!fs.existsSync(asarPath)) {
             return { success: false, changes: [], error: `Asar archive not found: ${asarPath}` };
         }
-        // Dynamic import of @electron/asar
-        const asarModule = await import("@electron/asar");
-        const asar = asarModule.default || asarModule;
         tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paseo-asar-extract-"));
-        asar.extractAll(asarPath, tempDir);
+        extractAll(asarPath, tempDir);
         // Look for server directory in extracted files
         const serverCandidates = [
             path.join(tempDir, "node_modules", "@getpaseo", "server"),
@@ -722,7 +734,7 @@ export async function patchPaseoAsar(asarPath) {
             }
         }
         tempAsar = path.join(os.tmpdir(), `app-${Date.now()}.asar`);
-        await asar.createPackage(tempDir, tempAsar);
+        await createPackage(tempDir, tempAsar);
         // Replace original archive with locked file handling for Windows
         try {
             fs.copyFileSync(tempAsar, asarPath);
@@ -871,9 +883,7 @@ export async function isPaseoAsarPatched(asarPath) {
     try {
         if (!fs.existsSync(asarPath))
             return false;
-        const asarModule = await import("@electron/asar");
-        const asar = asarModule.default || asarModule;
-        const files = asar.listPackage(asarPath);
+        const files = listPackage(asarPath);
         return files.some((f) => f.includes("antigravity.js"));
     }
     catch {

package/dist/permissions.d.ts

@@ -12,4 +12,5 @@ export declare function resolvePermissionSettings(options?: {
     addDirs?: string[];
     printTimeout?: string;
 }): PermissionSettings;
+export declare function parseExtraArgs(raw?: string): string[];
 export declare function buildAgyArgs(settings: PermissionSettings, extraArgs?: string[]): string[];

package/dist/permissions.js

@@ -20,6 +20,14 @@ export function resolvePermissionSettings(options) {
         printTimeout,
     };
 }
+export function parseExtraArgs(raw) {
+    if (!raw || !raw.trim())
+        return [];
+    const matches = raw.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+    if (!matches)
+        return [];
+    return matches.map((m) => m.replace(/^["']|["']$/g, ""));
+}
 export function buildAgyArgs(settings, extraArgs) {
     const args = ["--input-format", "stream-json", "--output-format", "stream-json", "--print="];
     if (settings.printTimeout) {
@@ -41,6 +49,10 @@ export function buildAgyArgs(settings, extraArgs) {
             }
         }
     }
+    const envExtra = parseExtraArgs(process.env.AGY_EXTRA_ARGS);
+    if (envExtra.length > 0) {
+        args.push(...envExtra);
+    }
     if (extraArgs && extraArgs.length > 0) {
         args.push(...extraArgs);
     }

package/dist/protocol.d.ts

@@ -113,10 +113,13 @@ export declare const ACP_METHODS: {
     readonly SESSION_CLOSE: "session/close";
     readonly SESSION_CLOSE_ALIAS: "unstable_closeSession";
     readonly SESSION_SET_MODE: "session/set_mode";
+    readonly SESSION_SET_MODE_CAMEL: "session/setMode";
     readonly SESSION_SET_MODE_ALIAS: "setSessionMode";
     readonly SESSION_SET_MODEL: "session/set_model";
+    readonly SESSION_SET_MODEL_CAMEL: "session/setModel";
     readonly SESSION_SET_MODEL_ALIAS: "unstable_setSessionModel";
     readonly SESSION_SET_CONFIG_OPTION: "session/set_config_option";
+    readonly SESSION_SET_CONFIG_OPTION_CAMEL: "session/setConfigOption";
     readonly SESSION_SET_CONFIG_OPTION_ALIAS: "setSessionConfigOption";
     readonly SESSION_UPDATE: "session/update";
 };
@@ -193,6 +196,11 @@ export declare const AVAILABLE_MODES: {
     name: string;
     description: string;
 }[];
+export declare const AVAILABLE_PERMISSIONS: {
+    id: string;
+    name: string;
+    description: string;
+}[];
 export declare function buildConfigOptionsForModel(modelId: string, currentEffort?: string, availableModels?: ModelDefinition[]): {
     id: string;
     name: string;
@@ -205,3 +213,40 @@ export declare function buildConfigOptionsForModel(modelId: string, currentEffor
         description: string;
     }[];
 }[];
+export declare function buildConfigOptionsForSession(options: {
+    modelId: string;
+    currentEffort?: string;
+    currentMode?: string;
+    currentPermission?: string;
+    availableModels?: ModelDefinition[];
+}): {
+    id: string;
+    name: string;
+    category: string;
+    type: "select";
+    currentValue: string;
+    options: {
+        value: string;
+        name: string;
+        description: string;
+    }[];
+}[];
+/**
+ * Escapes characters in URLs/paths for Markdown image/link syntax.
+ * Escapes backslashes `\` and parentheses `)` to prevent premature link termination,
+ * especially crucial for Windows paths (e.g. C:\path\img (1).png).
+ */
+export declare function escapeMarkdownUrl(urlOrPath: string): string;
+/**
+ * Normalizes an image path or file URL and formats it as an inline Markdown image link.
+ */
+export declare function formatImageMarkdown(filePathOrUrl: string): string;
+/**
+ * Extracts an image reference from a tool execution output or parameters,
+ * returning a formatted Markdown image string if detected.
+ */
+export declare function extractImageMarkdownLink(toolName: string, output: unknown, parameters?: Record<string, unknown>): string | null;
+/**
+ * Detects whether text consists entirely of conversational narration (e.g. "I will...", "I'll...").
+ */
+export declare function isNarrationText(text: string): boolean;

package/dist/protocol.js

@@ -23,10 +23,13 @@ export const ACP_METHODS = {
     SESSION_CLOSE: "session/close",
     SESSION_CLOSE_ALIAS: "unstable_closeSession",
     SESSION_SET_MODE: "session/set_mode",
+    SESSION_SET_MODE_CAMEL: "session/setMode",
     SESSION_SET_MODE_ALIAS: "setSessionMode",
     SESSION_SET_MODEL: "session/set_model",
+    SESSION_SET_MODEL_CAMEL: "session/setModel",
     SESSION_SET_MODEL_ALIAS: "unstable_setSessionModel",
     SESSION_SET_CONFIG_OPTION: "session/set_config_option",
+    SESSION_SET_CONFIG_OPTION_CAMEL: "session/setConfigOption",
     SESSION_SET_CONFIG_OPTION_ALIAS: "setSessionConfigOption",
     SESSION_UPDATE: "session/update",
 };
@@ -485,6 +488,12 @@ export function getEffectiveEffortForModel(modelId, requestedEffort, models) {
 export const AVAILABLE_MODES = [
     { id: "default", name: "Default (Accept Edits)", description: "Standard autonomous execution and coding mode" },
     { id: "plan", name: "Plan Mode", description: "Planning and read-only analysis without file modifications" },
+    { id: "accept-edits", name: "Accept Edits", description: "Run agy with --mode accept-edits" },
+];
+export const AVAILABLE_PERMISSIONS = [
+    { id: "default", name: "Default", description: "Standard permission flow" },
+    { id: "sandbox", name: "Sandbox", description: "Run agy with --sandbox" },
+    { id: "bypass", name: "Bypass", description: "Run agy with --dangerously-skip-permissions" },
 ];
 export function buildConfigOptionsForModel(modelId, currentEffort = "high", availableModels) {
     const modelList = availableModels || cachedModels || FALLBACK_MODELS;
@@ -513,3 +522,118 @@ export function buildConfigOptionsForModel(modelId, currentEffort = "high", avai
         },
     ];
 }
+export function buildConfigOptionsForSession(options) {
+    const modelOptions = buildConfigOptionsForModel(options.modelId, options.currentEffort, options.availableModels);
+    const modeOption = {
+        id: "mode",
+        name: "Execution Mode",
+        category: "mode",
+        type: "select",
+        currentValue: options.currentMode || "default",
+        options: AVAILABLE_MODES.map((m) => ({
+            value: m.id,
+            name: m.name,
+            description: m.description,
+        })),
+    };
+    const permissionOption = {
+        id: "permission",
+        name: "Permission Policy",
+        category: "permission",
+        type: "select",
+        currentValue: options.currentPermission || "default",
+        options: AVAILABLE_PERMISSIONS.map((p) => ({
+            value: p.id,
+            name: p.name,
+            description: p.description,
+        })),
+    };
+    return [...modelOptions, modeOption, permissionOption];
+}
+/**
+ * Escapes characters in URLs/paths for Markdown image/link syntax.
+ * Escapes backslashes `\` and parentheses `)` to prevent premature link termination,
+ * especially crucial for Windows paths (e.g. C:\path\img (1).png).
+ */
+export function escapeMarkdownUrl(urlOrPath) {
+    return urlOrPath.replace(/\\/g, "\\\\").replace(/\)/g, "\\)");
+}
+/**
+ * Normalizes an image path or file URL and formats it as an inline Markdown image link.
+ */
+export function formatImageMarkdown(filePathOrUrl) {
+    let clean = filePathOrUrl.trim();
+    if (clean.startsWith("file://")) {
+        try {
+            clean = fileURLToPath(clean);
+        }
+        catch {
+            clean = clean.replace(/^file:\/\//, "");
+            if (process.platform === "win32" && /^\/[a-zA-Z]:/.test(clean)) {
+                clean = clean.slice(1);
+            }
+        }
+    }
+    return `![Generated image](${escapeMarkdownUrl(clean)})`;
+}
+/**
+ * Extracts an image reference from a tool execution output or parameters,
+ * returning a formatted Markdown image string if detected.
+ */
+export function extractImageMarkdownLink(toolName, output, parameters) {
+    const name = toolName.toLowerCase();
+    const isImageTool = name.includes("image") || name.includes("generate_image");
+    let rawPath = null;
+    if (typeof output === "string") {
+        const fileUriMatch = output.match(/file:\/\/[^\s)"]+\.(png|jpe?g|webp|gif|svg|bmp)/i);
+        if (fileUriMatch) {
+            rawPath = fileUriMatch[0];
+        }
+        else {
+            const winPathMatch = output.match(/[a-zA-Z]:\\[^\s)"]+\.(png|jpe?g|webp|gif|svg|bmp)/i);
+            if (winPathMatch) {
+                rawPath = winPathMatch[0];
+            }
+            else {
+                const posixPathMatch = output.match(/\/[^\s)"]+\.(png|jpe?g|webp|gif|svg|bmp)/i);
+                if (posixPathMatch) {
+                    rawPath = posixPathMatch[0];
+                }
+            }
+        }
+    }
+    else if (output && typeof output === "object") {
+        const obj = output;
+        if (typeof obj.path === "string")
+            rawPath = obj.path;
+        else if (typeof obj.filePath === "string")
+            rawPath = obj.filePath;
+        else if (typeof obj.uri === "string")
+            rawPath = obj.uri;
+    }
+    if (!rawPath && isImageTool && parameters) {
+        if (typeof parameters.TargetFile === "string" &&
+            /\.(png|jpe?g|webp|gif|svg|bmp)$/i.test(parameters.TargetFile)) {
+            rawPath = parameters.TargetFile;
+        }
+    }
+    if (!rawPath)
+        return null;
+    return formatImageMarkdown(rawPath);
+}
+/**
+ * Detects whether text consists entirely of conversational narration (e.g. "I will...", "I'll...").
+ */
+export function isNarrationText(text) {
+    const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (lines.length === 0)
+        return false;
+    return lines.every((l) => {
+        const lower = l.toLowerCase();
+        return (lower.startsWith("i will") ||
+            lower.startsWith("i'll") ||
+            lower.startsWith("i’ll") ||
+            lower.startsWith("let me") ||
+            lower.startsWith("i am going to"));
+    });
+}

package/dist/session-store.d.ts

@@ -14,6 +14,7 @@ export interface PersistedSessionState {
     model: string;
     effort: string;
     mode: string;
+    permission?: string;
     usage?: SessionUsageState;
     updatedAt: string;
 }

package/dist/session-store.js

@@ -7,6 +7,9 @@ function getStateRoot() {
     if (process.env.AGY_ACP_STATE_DIR) {
         return process.env.AGY_ACP_STATE_DIR;
     }
+    if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+        return path.join(process.env.LOCALAPPDATA, "agy-acp");
+    }
     const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
     return path.join(stateHome, "agy-acp");
 }

package/dist/session.d.ts

@@ -6,6 +6,7 @@ export interface SessionOptions {
     model?: string;
     effort?: string;
     mode?: string;
+    permission?: string;
     conversationId?: string;
     usage?: SessionUsageState;
     sandbox?: boolean;
@@ -20,6 +21,7 @@ export declare class Session {
     model: string;
     effort: string;
     mode: string;
+    permission: string;
     readonly createdAt: Date;
     lastActivity: Date;
     isCancelled: boolean;
@@ -36,6 +38,7 @@ export declare class Session {
     setModel(model: string): void;
     setEffort(effort: string): void;
     setMode(mode: string): void;
+    setPermission(permission: string): void;
     setConversationId(conversationId?: string): void;
     ensureReadyForResume(): Promise<void>;
     resumeConversation(conversationId: string): Promise<void>;

package/dist/session.js

@@ -10,6 +10,7 @@ export class Session {
     model;
     effort;
     mode;
+    permission;
     createdAt;
     lastActivity;
     isCancelled = false;
@@ -23,6 +24,9 @@ export class Session {
         this.model = options.model || "gemini-3.7-flash";
         this.effort = options.effort || "high";
         this.mode = options.mode || "default";
+        this.permission =
+            options.permission ||
+                (options.sandbox ? "sandbox" : options.dangerouslySkipPermissions ? "bypass" : "default");
         this.createdAt = new Date();
         this.lastActivity = new Date();
         this.store = options.store || sessionStore;
@@ -35,9 +39,11 @@ export class Session {
             contextWindowUsedTokens: 0,
             contextWindowMaxTokens: getModelContextWindow(this.model),
         };
+        const isSandbox = this.permission === "sandbox" || options.sandbox;
+        const isBypass = this.permission === "bypass" || options.dangerouslySkipPermissions;
         const permissions = resolvePermissionSettings({
-            sandbox: options.sandbox,
-            dangerouslySkipPermissions: options.dangerouslySkipPermissions,
+            sandbox: isSandbox,
+            dangerouslySkipPermissions: isBypass,
             mode: this.mode,
         });
         this.process = new AntigravityProcess({
@@ -62,6 +68,7 @@ export class Session {
             model: this.model,
             effort: this.effort,
             mode: this.mode,
+            permission: this.permission,
             usage: this.usage,
             updatedAt: new Date().toISOString(),
         };
@@ -98,6 +105,16 @@ export class Session {
         this.process.setMode(mode);
         this.persist();
     }
+    setPermission(permission) {
+        this.permission = permission;
+        const isSandbox = permission === "sandbox";
+        const isBypass = permission === "bypass";
+        this.process.setPermissions({
+            sandbox: isSandbox,
+            dangerouslySkipPermissions: isBypass || (!isSandbox && this.process.currentPermissions.dangerouslySkipPermissions),
+        });
+        this.persist();
+    }
     setConversationId(conversationId) {
         this.process.setConversationId(conversationId);
         this.persist();
@@ -185,6 +202,7 @@ export class SessionManager {
             model: options.model || persisted?.model,
             effort: options.effort || persisted?.effort,
             mode: options.mode || persisted?.mode,
+            permission: options.permission || persisted?.permission,
             conversationId: options.conversationId || persisted?.conversationId,
             usage: options.usage || persisted?.usage,
             sandbox: options.sandbox,

package/dist/version.js

@@ -16,7 +16,7 @@ function getPackageVersion() {
     catch {
         // ignore
     }
-    return "1.1.0";
+    return "1.2.0";
 }
 export const SEMVER_VERSION = getPackageVersion();
 let cachedBuildMetadata = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-acp-agy",
-  "version": "1.1.9",
+  "version": "1.2.0",
   "description": "ACP (Agent Client Protocol) provider for Google Antigravity in Paseo and Zed",
   "type": "module",
   "main": "dist/index.js",
@@ -43,10 +43,11 @@
   "bugs": {
     "url": "https://github.com/tucomel/paseo-acp-agy/issues"
   },
-  "homepage": "https://github.com/tucomel/paseo-acp-agy#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
-    "@agentclientprotocol/sdk": "^0.17.1",
-    "@electron/asar": "^4.3.0"
+    "@agentclientprotocol/sdk": "^0.17.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",