paseo-acp-agy 1.1.4 → 1.1.5

package/README.md

@@ -90,6 +90,28 @@ To include `paseo-acp-agy` in Paseo's built-in provider store (`ACP_PROVIDER_CAT
 
 ---
 
+## Plan Usage & Context Window Meter Setup
+
+To display the **Google Antigravity** quota breakdown in Paseo's `Settings -> Usage` (Plan usage) and activate the real-time context-window meter ("bolinha") in the chat composer:
+
+```bash
+npx -y paseo-acp-agy setup
+```
+
+Or if installed globally:
+```bash
+paseo-acp-agy setup
+```
+
+Then restart your Paseo app or daemon:
+```bash
+paseo daemon restart
+```
+
+> **Note**: `paseo-acp-agy` also checks and auto-configures your local Paseo server automatically whenever it launches via `--acp`. Running `setup` manually ensures your existing daemon instance picks up the telemetry hooks immediately upon restart.
+
+---
+
 ## Requirements
 
 - **Node.js**: >= 20.0.0 (Node.js 22 recommended)

package/dist/acp-server.d.ts

@@ -19,6 +19,7 @@ export declare class ACPServer {
     private sendSuccess;
     private sendError;
     private publishCommands;
+    private publishUsageUpdate;
     private sessionState;
     private requireSession;
     private validateModel;

package/dist/acp-server.js

@@ -80,6 +80,26 @@ export class ACPServer {
             },
         });
     }
+    publishUsageUpdate(session) {
+        const costUsd = roundUsageCostUsd(session.usage.totalCostUsd);
+        this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+            sessionId: session.id,
+            update: {
+                sessionUpdate: "usage_update",
+                size: session.usage.contextWindowMaxTokens,
+                used: session.usage.contextWindowUsedTokens,
+                cost: { amount: costUsd, currency: "USD" },
+                inputTokens: session.usage.inputTokens,
+                outputTokens: session.usage.outputTokens,
+                cachedReadTokens: session.usage.cachedInputTokens,
+                cachedInputTokens: session.usage.cachedInputTokens,
+                totalTokens: session.usage.totalTokens,
+                totalCostUsd: costUsd,
+                contextWindowMaxTokens: session.usage.contextWindowMaxTokens,
+                contextWindowUsedTokens: session.usage.contextWindowUsedTokens,
+            },
+        });
+    }
     async sessionState(session, forceModels = false) {
         const availableModels = await fetchAvailableModels(this.binaryPath, forceModels);
         return {
@@ -178,6 +198,7 @@ export class ACPServer {
                     if (!isNotification) {
                         this.sendSuccess(id, await this.sessionState(session, true));
                         this.publishCommands(session.id);
+                        this.publishUsageUpdate(session);
                     }
                     break;
                 }
@@ -212,6 +233,7 @@ export class ACPServer {
                         if (!isNotification) {
                             this.sendSuccess(id, await this.sessionState(session));
                             this.publishCommands(session.id);
+                            this.publishUsageUpdate(session);
                         }
                     }
                     catch (err) {
@@ -375,6 +397,7 @@ export class ACPServer {
                             // after model/tool work. Record it before branching on status.
                             session.recordTurnUsage(turnUsage, executingModel);
                             const usagePayload = this.turnUsagePayload(session, turnUsage, executingModel);
+                            this.publishUsageUpdate(session);
                             if (session.isCancelled) {
                                 if (!isNotification) {
                                     this.sendSuccess(id, { stopReason: "cancelled", usage: usagePayload });

package/dist/index.js

@@ -2,6 +2,7 @@
 import { ACPServer } from "./acp-server.js";
 import { logger } from "./logger.js";
 import { formatDiagnosticVersion, resolveBuildMetadata } from "./version.js";
+import { ensurePaseoIntegration } from "./paseo-patcher.js";
 const args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
     if (args.includes("--json")) {
@@ -19,9 +20,14 @@ Usage:
   paseo-acp-agy [options]
   agy-acp [options]
   npx -y paseo-acp-agy [options]
+  npx -y paseo-acp-agy setup
+
+Commands:
+  setup, patch   Configure and integrate Antigravity telemetry with Paseo
 
 Options:
   --acp          Start ACP server over stdio (default)
+  --setup        Integrate Antigravity with local Paseo server installation
   -v, --version  Show version
   --json         Show version in JSON format (with --version)
   -h, --help     Show help
@@ -32,9 +38,43 @@ Environment Variables:
   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_BIN_PATH                      Path to agy binary (default: agy in PATH or ~/.local/bin/agy)
+  PASEO_SERVER_PATH                 Path to local @getpaseo/server directory
 `);
     process.exit(0);
 }
+if (args.includes("setup") ||
+    args.includes("patch") ||
+    args.includes("--setup") ||
+    args.includes("--patch")) {
+    process.stdout.write("Checking Paseo installation and configuring Antigravity telemetry...\n");
+    try {
+        const res = ensurePaseoIntegration({ verbose: true });
+        if (!res.found) {
+            process.stdout.write("Notice: No active @getpaseo/server installation found in standard paths.\n" +
+                "If Paseo is installed in a custom directory, set PASEO_SERVER_PATH and run setup again.\n");
+        }
+        else {
+            process.stdout.write(`Found ${res.serverPaths.length} Paseo server installation(s).\n`);
+            if (res.patchedPaths.length > 0) {
+                process.stdout.write(`Successfully integrated with: \n${res.patchedPaths.map((p) => `  - ${p}`).join("\n")}\n\n` +
+                    `Antigravity quota provider and context-window telemetry are now enabled!\n` +
+                    `Please restart Paseo (or run 'paseo daemon restart') to apply changes.\n`);
+            }
+            else {
+                process.stdout.write("Paseo is already up-to-date and configured for Antigravity telemetry.\n");
+            }
+        }
+    }
+    catch (err) {
+        process.stderr.write(`Setup encountered an issue: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    process.exit(0);
+}
+// Auto-run integration in background when starting ACP server
+try {
+    ensurePaseoIntegration();
+}
+catch { }
 const server = new ACPServer();
 const cleanup = async () => {
     try {

package/dist/paseo-patcher.d.ts

@@ -0,0 +1,34 @@
+export interface PatchResult {
+    found: boolean;
+    serverPaths: string[];
+    patchedPaths: string[];
+    errors: string[];
+}
+/**
+ * Searches the host machine for @getpaseo/server installations across
+ * Windows, macOS, and Linux.
+ */
+export declare function findPaseoServerInstallations(): string[];
+/**
+ * Returns the JavaScript source for the Antigravity quota provider to be
+ * injected into Paseo server's quota-fetcher providers.
+ */
+export declare function generateAntigravityQuotaProviderJs(): string;
+/**
+ * Patches a Paseo server installation directory to enable Antigravity:
+ * 1. Patches quota-fetcher/manifest.js to register Antigravity
+ * 2. Writes quota-fetcher/providers/antigravity.js
+ * 3. Patches acp-agent.js to map context window tokens and emit usage updates
+ */
+export declare function patchPaseoServer(serverDir: string): {
+    success: boolean;
+    changes: string[];
+    error?: string;
+};
+/**
+ * Discovers and patches all accessible Paseo installations.
+ */
+export declare function ensurePaseoIntegration(options?: {
+    verbose?: boolean;
+    targetPaths?: string[];
+}): PatchResult;

package/dist/paseo-patcher.js

@@ -0,0 +1,457 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { logger } from "./logger.js";
+/**
+ * Searches the host machine for @getpaseo/server installations across
+ * Windows, macOS, and Linux.
+ */
+export function findPaseoServerInstallations() {
+    const candidates = new Set();
+    // 1. Explicit environment variable overrides
+    if (process.env.PASEO_SERVER_PATH && fs.existsSync(process.env.PASEO_SERVER_PATH)) {
+        candidates.add(path.resolve(process.env.PASEO_SERVER_PATH));
+    }
+    if (process.env.PASEO_INSTALL_DIR && fs.existsSync(process.env.PASEO_INSTALL_DIR)) {
+        const direct = path.join(process.env.PASEO_INSTALL_DIR, "node_modules", "@getpaseo", "server");
+        if (fs.existsSync(direct))
+            candidates.add(path.resolve(direct));
+    }
+    // 2. Platform-specific default paths
+    const home = os.homedir();
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || (home ? path.join(home, "AppData", "Roaming") : "");
+        const localAppData = process.env.LOCALAPPDATA || (home ? path.join(home, "AppData", "Local") : "");
+        const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+        const winLocations = [
+            path.join(appData, "npm", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"),
+            path.join(appData, "npm", "node_modules", "@getpaseo", "server"),
+            path.join(localAppData, "npm", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"),
+            path.join(localAppData, "npm", "node_modules", "@getpaseo", "server"),
+            path.join(programFiles, "nodejs", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"),
+            path.join(programFiles, "nodejs", "node_modules", "@getpaseo", "server"),
+            path.join(localAppData, "Programs", "Paseo", "resources", "app.asar.unpacked", "node_modules", "@getpaseo", "server"),
+            path.join(localAppData, "Programs", "Paseo", "resources", "app", "node_modules", "@getpaseo", "server"),
+            path.join(programFiles, "Paseo", "resources", "app.asar.unpacked", "node_modules", "@getpaseo", "server"),
+        ];
+        for (const loc of winLocations) {
+            if (loc && fs.existsSync(loc))
+                candidates.add(path.resolve(loc));
+        }
+        // Try detecting global npm root via npm.cmd
+        try {
+            const npmRoot = execFileSync("cmd.exe", ["/c", "npm.cmd", "root", "-g"], {
+                encoding: "utf-8",
+                timeout: 2000,
+                windowsHide: true,
+            }).trim();
+            if (npmRoot && fs.existsSync(npmRoot)) {
+                const p1 = path.join(npmRoot, "@getpaseo", "cli", "node_modules", "@getpaseo", "server");
+                const p2 = path.join(npmRoot, "@getpaseo", "server");
+                if (fs.existsSync(p1))
+                    candidates.add(path.resolve(p1));
+                if (fs.existsSync(p2))
+                    candidates.add(path.resolve(p2));
+            }
+        }
+        catch { }
+        // Check where.exe paseo
+        try {
+            const whereOut = execFileSync("where.exe", ["paseo"], {
+                encoding: "utf-8",
+                timeout: 2000,
+                windowsHide: true,
+            }).trim();
+            const first = whereOut.split(/\r?\n/)[0]?.trim();
+            if (first) {
+                const paseoDir = path.dirname(first);
+                const p1 = path.join(paseoDir, "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server");
+                const p2 = path.join(paseoDir, "node_modules", "@getpaseo", "server");
+                if (fs.existsSync(p1))
+                    candidates.add(path.resolve(p1));
+                if (fs.existsSync(p2))
+                    candidates.add(path.resolve(p2));
+            }
+        }
+        catch { }
+    }
+    else {
+        // POSIX locations (Linux / macOS)
+        const posixLocations = [
+            "/usr/lib/node_modules/@getpaseo/cli/node_modules/@getpaseo/server",
+            "/usr/lib/node_modules/@getpaseo/server",
+            "/usr/local/lib/node_modules/@getpaseo/cli/node_modules/@getpaseo/server",
+            "/usr/local/lib/node_modules/@getpaseo/server",
+            "/Applications/Paseo.app/Contents/Resources/app.asar.unpacked/node_modules/@getpaseo/server",
+            "/Applications/Paseo.app/Contents/Resources/app/node_modules/@getpaseo/server",
+        ];
+        if (home) {
+            posixLocations.push(path.join(home, ".local", "share", "pnpm", "global", "5", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"), path.join(home, ".bun", "install", "global", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"));
+            // Check nvm paths if available
+            const nvmDir = path.join(home, ".nvm", "versions", "node");
+            if (fs.existsSync(nvmDir)) {
+                try {
+                    const versions = fs.readdirSync(nvmDir);
+                    for (const ver of versions) {
+                        posixLocations.push(path.join(nvmDir, ver, "lib", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"), path.join(nvmDir, ver, "lib", "node_modules", "@getpaseo", "server"));
+                    }
+                }
+                catch { }
+            }
+        }
+        for (const loc of posixLocations) {
+            if (fs.existsSync(loc))
+                candidates.add(path.resolve(loc));
+        }
+        try {
+            const npmRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf-8", timeout: 2000 }).trim();
+            if (npmRoot && fs.existsSync(npmRoot)) {
+                const p1 = path.join(npmRoot, "@getpaseo", "cli", "node_modules", "@getpaseo", "server");
+                const p2 = path.join(npmRoot, "@getpaseo", "server");
+                if (fs.existsSync(p1))
+                    candidates.add(path.resolve(p1));
+                if (fs.existsSync(p2))
+                    candidates.add(path.resolve(p2));
+            }
+        }
+        catch { }
+    }
+    // Filter out any paths that do not actually have a dist directory or package.json
+    const verified = [];
+    for (const dir of candidates) {
+        if (fs.existsSync(path.join(dir, "dist")) || fs.existsSync(path.join(dir, "package.json"))) {
+            verified.push(dir);
+        }
+    }
+    return verified;
+}
+/**
+ * Returns the JavaScript source for the Antigravity quota provider to be
+ * injected into Paseo server's quota-fetcher providers.
+ */
+export function generateAntigravityQuotaProviderJs() {
+    return `import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { toneFromUsedPct, windowFromUsedPct, unavailableUsage } from "../usage.js";
+
+const execFileAsync = promisify(execFile);
+
+function resolveAgyBinary() {
+    if (process.env.AGY_BIN_PATH) return process.env.AGY_BIN_PATH;
+    const home = os.homedir();
+    if (home) {
+        if (process.platform === "win32") {
+            const candidates = [
+                path.join(home, ".local", "bin", "agy.exe"),
+                path.join(home, "AppData", "Local", "Programs", "antigravity", "agy.exe"),
+                path.join(home, ".local", "bin", "agy.cmd"),
+                path.join(home, ".local", "bin", "agy.bat"),
+            ];
+            for (const cand of candidates) {
+                if (fs.existsSync(cand)) return cand;
+            }
+            try {
+                const { execFileSync } = require("node:child_process");
+                const out = execFileSync("where.exe", ["agy"], { encoding: "utf-8", timeout: 1000 }).trim();
+                const first = out.split(/\\r?\\n/)[0]?.trim();
+                if (first && fs.existsSync(first)) return first;
+            } catch {}
+        } else {
+            const localPath = path.join(home, ".local", "bin", "agy");
+            if (fs.existsSync(localPath)) return localPath;
+        }
+    }
+    return "agy";
+}
+
+export class AntigravityQuotaProvider {
+    constructor(options) {
+        this.providerId = "antigravity";
+        this.displayName = "Antigravity";
+        this.logger = typeof options?.logger?.child === "function" ? options.logger.child({ module: "antigravity-quota-provider" }) : options?.logger;
+        this.binaryPath = resolveAgyBinary();
+    }
+
+    async fetchUsage() {
+        try {
+            const isWin = process.platform === "win32";
+            const [usageRes, creditsRes] = await Promise.allSettled([
+                execFileAsync(this.binaryPath, ["--print", "/usage"], { timeout: 8000, env: process.env, shell: isWin }),
+                execFileAsync(this.binaryPath, ["--print", "/credits"], { timeout: 8000, env: process.env, shell: isWin }),
+            ]);
+
+            const usageOut = usageRes.status === "fulfilled" ? usageRes.value.stdout || usageRes.value.stderr : "";
+            const creditsOut = creditsRes.status === "fulfilled" ? creditsRes.value.stdout || creditsRes.value.stderr : "";
+
+            const rawWindows = [];
+            for (const line of usageOut.split(/[\\r\\n]+/)) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.toLowerCase().startsWith("quota:")) continue;
+
+                let scope = "";
+                let limitType = "";
+                let remainingPct = null;
+                let resetsAt = null;
+
+                const m = trimmed.match(/^(.*?)\\s{2,}(.*?Remaining)\\s+(\\d+)%(?:\\s+(.*))?$/i);
+                if (m) {
+                    scope = m[1].trim();
+                    limitType = m[2].trim();
+                    remainingPct = parseInt(m[3], 10);
+                    resetsAt = m[4] ? new Date(m[4].trim()).toISOString() : null;
+                } else {
+                    const parts = trimmed.split(/\\t+|\\s{2,}/).map(p => p.trim());
+                    if (parts.length >= 3) {
+                        scope = parts[0];
+                        limitType = parts[1];
+                        const remMatch = parts[2].match(/(\\d+)%/);
+                        if (remMatch) remainingPct = parseInt(remMatch[1], 10);
+                        resetsAt = parts[3] ? new Date(parts[3]).toISOString() : null;
+                    }
+                }
+
+                if (remainingPct !== null && !isNaN(remainingPct)) {
+                    const usedPct = Math.max(0, Math.min(100, 100 - remainingPct));
+                    const isFiveHour = /five\\s*hour/i.test(limitType);
+                    const isWeekly = /weekly/i.test(limitType);
+                    const isGemini = /gemini/i.test(scope);
+
+                    let id = isFiveHour ? "session" : isWeekly ? "weekly" : "quota";
+                    let label = isFiveHour ? "Session" : isWeekly ? "Weekly" : limitType.replace(/\\s+Remaining$/i, "");
+                    if (!isGemini) {
+                        id = \`claude_\${id}\`;
+                        label = \`Claude \${label}\`;
+                    }
+
+                    rawWindows.push({
+                        id,
+                        label,
+                        utilizationPct: usedPct,
+                        resetsAt,
+                        tone: toneFromUsedPct(usedPct),
+                        isFiveHour,
+                        isGemini,
+                    });
+                }
+            }
+
+            rawWindows.sort((a, b) => {
+                if (a.isGemini && !b.isGemini) return -1;
+                if (!a.isGemini && b.isGemini) return 1;
+                if (a.isFiveHour && !b.isFiveHour) return -1;
+                if (!a.isFiveHour && b.isFiveHour) return 1;
+                return 0;
+            });
+
+            const windows = rawWindows.map(w => windowFromUsedPct(w));
+
+            const balances = [];
+            const credMatch = creditsOut.match(/Remaining\\s+credits\\s+([\\d.]+)/i);
+            const remainingCredits = credMatch ? parseFloat(credMatch[1]) : 0;
+            balances.push({
+                id: "credits",
+                label: "Credits",
+                remaining: remainingCredits,
+                unit: "usd",
+                tone: remainingCredits > 0 ? "ok" : "default",
+            });
+
+            return {
+                providerId: this.providerId,
+                displayName: "Antigravity",
+                status: "available",
+                planLabel: "Google Gemini",
+                windows,
+                balances,
+                details: [],
+                error: null,
+            };
+        } catch (err) {
+            return unavailableUsage({
+                providerId: this.providerId,
+                displayName: "Antigravity",
+                error: err.message,
+            });
+        }
+    }
+}
+`;
+}
+/**
+ * Patches a Paseo server installation directory to enable Antigravity:
+ * 1. Patches quota-fetcher/manifest.js to register Antigravity
+ * 2. Writes quota-fetcher/providers/antigravity.js
+ * 3. Patches acp-agent.js to map context window tokens and emit usage updates
+ */
+export function patchPaseoServer(serverDir) {
+    const changes = [];
+    try {
+        // 1. Locate manifest.js in quota-fetcher
+        const manifestCandidates = [
+            path.join(serverDir, "dist", "server", "services", "quota-fetcher", "manifest.js"),
+            path.join(serverDir, "dist", "services", "quota-fetcher", "manifest.js"),
+        ];
+        let manifestFile = manifestCandidates.find((f) => fs.existsSync(f));
+        if (!manifestFile && fs.existsSync(path.join(serverDir, "dist"))) {
+            const findManifest = (dir) => {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                    const full = path.join(dir, e.name);
+                    if (e.isDirectory() && e.name !== "node_modules") {
+                        const found = findManifest(full);
+                        if (found)
+                            return found;
+                    }
+                    else if (e.isFile() && e.name === "manifest.js" && dir.includes("quota-fetcher")) {
+                        return full;
+                    }
+                }
+                return null;
+            };
+            manifestFile = findManifest(path.join(serverDir, "dist")) || undefined;
+        }
+        if (manifestFile) {
+            const quotaDir = path.dirname(manifestFile);
+            const providersDir = path.join(quotaDir, "providers");
+            if (!fs.existsSync(providersDir)) {
+                fs.mkdirSync(providersDir, { recursive: true });
+            }
+            // Write / update providers/antigravity.js
+            const antigravityJsPath = path.join(providersDir, "antigravity.js");
+            fs.writeFileSync(antigravityJsPath, generateAntigravityQuotaProviderJs(), "utf-8");
+            changes.push(`Created/Updated ${antigravityJsPath}`);
+            // Patch manifest.js
+            let manifestCode = fs.readFileSync(manifestFile, "utf-8");
+            let manifestModified = false;
+            if (!manifestCode.includes('from "./providers/antigravity.js"') && !manifestCode.includes("AntigravityQuotaProvider")) {
+                manifestCode = `import { AntigravityQuotaProvider } from "./providers/antigravity.js";\n` + manifestCode;
+                manifestModified = true;
+            }
+            if (!manifestCode.includes('providerId: "antigravity"')) {
+                const entryToAdd = `    {\n        providerId: "antigravity",\n        create: (options) => new AntigravityQuotaProvider({\n            logger: options.logger,\n            fetch: options.fetch,\n        }),\n    },\n`;
+                const marker = "export const PROVIDER_USAGE_FETCHERS = [";
+                if (manifestCode.includes(marker)) {
+                    manifestCode = manifestCode.replace(marker, `${marker}\n${entryToAdd}`);
+                    manifestModified = true;
+                }
+            }
+            if (manifestModified) {
+                fs.writeFileSync(manifestFile, manifestCode, "utf-8");
+                changes.push(`Patched ${manifestFile} with AntigravityQuotaProvider`);
+            }
+        }
+        // 2. Locate acp-agent.js
+        const acpCandidates = [
+            path.join(serverDir, "dist", "server", "server", "agent", "providers", "acp-agent.js"),
+            path.join(serverDir, "dist", "server", "agent", "providers", "acp-agent.js"),
+            path.join(serverDir, "dist", "agent", "providers", "acp-agent.js"),
+        ];
+        let acpFile = acpCandidates.find((f) => fs.existsSync(f));
+        if (!acpFile && fs.existsSync(path.join(serverDir, "dist"))) {
+            const findAcp = (dir) => {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                    const full = path.join(dir, e.name);
+                    if (e.isDirectory() && e.name !== "node_modules") {
+                        const found = findAcp(full);
+                        if (found)
+                            return found;
+                    }
+                    else if (e.isFile() && e.name === "acp-agent.js") {
+                        return full;
+                    }
+                }
+                return null;
+            };
+            acpFile = findAcp(path.join(serverDir, "dist")) || undefined;
+        }
+        if (acpFile) {
+            let acpCode = fs.readFileSync(acpFile, "utf-8");
+            let acpModified = false;
+            // Patch mapACPUsage
+            if (!acpCode.includes("contextWindowMaxTokens: usage.contextWindowMaxTokens")) {
+                const oldMapRegex = /export\s+function\s+mapACPUsage\s*\([^)]*\)\s*\{[\s\S]*?return\s*\{[\s\S]*?\};\s*\}/m;
+                const newMap = `export function mapACPUsage(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    return {
+        inputTokens: usage.inputTokens ?? undefined,
+        outputTokens: usage.outputTokens ?? undefined,
+        cachedInputTokens: usage.cachedReadTokens ?? usage.cachedInputTokens ?? undefined,
+        totalCostUsd: usage.totalCostUsd ?? (usage.cost?.amount !== undefined ? Number(usage.cost.amount) : undefined),
+        contextWindowMaxTokens: usage.contextWindowMaxTokens ?? usage.size ?? undefined,
+        contextWindowUsedTokens: usage.contextWindowUsedTokens ?? usage.used ?? undefined,
+    };
+}`;
+                if (oldMapRegex.test(acpCode)) {
+                    acpCode = acpCode.replace(oldMapRegex, newMap);
+                    acpModified = true;
+                }
+            }
+            // Patch handleUsageUpdate
+            if (acpCode.includes("handleUsageUpdate(update) {") && !acpCode.includes("this.notifySubscribers({")) {
+                const oldHandlerRegex = /handleUsageUpdate\s*\(\s*update\s*\)\s*\{[\s\S]*?void\s+update;?[\s\S]*?\}/m;
+                const newHandler = `handleUsageUpdate(update) {
+        if (!update) return;
+        const usage = mapACPUsage(update);
+        if (usage) {
+            this.currentTurnUsage = { ...this.currentTurnUsage, ...usage };
+            this.notifySubscribers({
+                type: "usage_updated",
+                provider: this.provider,
+                usage: this.currentTurnUsage,
+                ...(this.activeForegroundTurnId ? { turnId: this.activeForegroundTurnId } : {}),
+            });
+        }
+    }`;
+                if (oldHandlerRegex.test(acpCode)) {
+                    acpCode = acpCode.replace(oldHandlerRegex, newHandler);
+                    acpModified = true;
+                }
+            }
+            if (acpModified) {
+                fs.writeFileSync(acpFile, acpCode, "utf-8");
+                changes.push(`Patched ${acpFile} for context-window token telemetry and usage updates`);
+            }
+        }
+        return { success: true, changes };
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        logger.warn("Failed to patch Paseo server", { serverDir, error: errorMsg });
+        return { success: false, changes, error: errorMsg };
+    }
+}
+/**
+ * Discovers and patches all accessible Paseo installations.
+ */
+export function ensurePaseoIntegration(options) {
+    const serverPaths = options?.targetPaths || findPaseoServerInstallations();
+    const patchedPaths = [];
+    const errors = [];
+    for (const sPath of serverPaths) {
+        const res = patchPaseoServer(sPath);
+        if (res.success) {
+            if (res.changes.length > 0) {
+                patchedPaths.push(sPath);
+                if (options?.verbose) {
+                    logger.info(`Integrated with Paseo server at ${sPath}`, { changes: res.changes });
+                }
+            }
+        }
+        else if (res.error) {
+            errors.push(`${sPath}: ${res.error}`);
+        }
+    }
+    return {
+        found: serverPaths.length > 0,
+        serverPaths,
+        patchedPaths,
+        errors,
+    };
+}

package/dist/protocol.d.ts

@@ -173,6 +173,7 @@ export interface ProviderUsage {
     }>;
     error: string | null;
 }
+export declare function formatExecBinaryPath(binaryPath: string): string;
 export declare function fetchAntigravityUsage(binaryPath?: string, force?: boolean): Promise<ProviderUsage>;
 export declare const ALL_THINKING_LEVELS: Record<string, {
     name: string;

package/dist/protocol.js

@@ -278,6 +278,12 @@ function cacheProviderUsage(binaryPath, result, now) {
     lastProviderUsageFetch = now;
     return result;
 }
+export function formatExecBinaryPath(binaryPath) {
+    if (process.platform === "win32" && binaryPath.includes(" ") && !binaryPath.startsWith('"')) {
+        return `"${binaryPath}"`;
+    }
+    return binaryPath;
+}
 export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
     const now = Date.now();
     if (!force &&
@@ -286,15 +292,16 @@ export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
         now - lastProviderUsageFetch < PROVIDER_USAGE_CACHE_TTL_MS) {
         return cachedProviderUsage;
     }
+    const cmd = formatExecBinaryPath(binaryPath);
     try {
         const [usageResult, creditsResult] = await Promise.allSettled([
-            execFileAsync(binaryPath, ["--print", "/usage"], {
+            execFileAsync(cmd, ["--print", "/usage"], {
                 timeout: 8_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
                 shell: process.platform === "win32",
             }),
-            execFileAsync(binaryPath, ["--print", "/credits"], {
+            execFileAsync(cmd, ["--print", "/credits"], {
                 timeout: 8_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
@@ -371,6 +378,7 @@ export const FALLBACK_MODELS = [
 let cachedModels = null;
 let cachedModelsBinaryPath = null;
 let lastModelFetch = 0;
+let inFlightModelFetch = null;
 const MODEL_CACHE_TTL_MS = 60_000;
 export function parseAgyModelsOutput(rawOutput) {
     const modelsMap = new Map();
@@ -384,24 +392,21 @@ export function parseAgyModelsOutput(rawOutput) {
         const modelId = parts[0];
         const label = parts[1];
         const effortMatch = modelId.match(/-(high|medium|low)$/);
-        let baseId = modelId;
-        let baseLabel = label;
-        let effort = null;
-        if (effortMatch) {
-            effort = effortMatch[1];
-            baseId = modelId.slice(0, -(effort.length + 1));
-            baseLabel = label.replace(/\s*\((High|Medium|Low)\)$/, "");
-        }
+        const baseId = effortMatch ? modelId.replace(/-(high|medium|low)$/, "") : modelId;
+        const effort = effortMatch ? effortMatch[1] : undefined;
+        const cleanLabel = effortMatch
+            ? label.replace(/\s*\((High|Medium|Low)\)$/i, "").trim()
+            : label;
         if (!modelsMap.has(baseId)) {
             modelsMap.set(baseId, {
                 modelId: baseId,
-                name: baseLabel,
+                name: cleanLabel,
                 description: label,
-                supportedEfforts: [],
+                supportedEfforts: effort ? [effort] : [],
                 contextWindowMaxTokens: getModelContextWindow(baseId),
             });
         }
-        if (effort) {
+        else if (effort) {
             const entry = modelsMap.get(baseId);
             if (!entry.supportedEfforts.includes(effort))
                 entry.supportedEfforts.push(effort);
@@ -418,28 +423,38 @@ export async function fetchAvailableModels(binaryPath = "agy", force = false) {
         now - lastModelFetch < MODEL_CACHE_TTL_MS) {
         return cachedModels;
     }
-    try {
-        const { stdout } = await execFileAsync(binaryPath, ["models"], {
-            timeout: 5_000,
-            env: process.env,
-            maxBuffer: 4 * 1024 * 1024,
-            shell: process.platform === "win32",
-        });
-        const parsed = parseAgyModelsOutput(stdout);
-        cachedModels = parsed;
-        cachedModelsBinaryPath = binaryPath;
-        lastModelFetch = now;
-        return parsed;
-    }
-    catch (err) {
-        logger.warn("Failed to fetch models from agy CLI, using fallback models", {
-            error: err.message,
-        });
-        cachedModels = FALLBACK_MODELS;
-        cachedModelsBinaryPath = binaryPath;
-        lastModelFetch = now;
-        return FALLBACK_MODELS;
+    if (inFlightModelFetch) {
+        return inFlightModelFetch;
     }
+    inFlightModelFetch = (async () => {
+        const cmd = formatExecBinaryPath(binaryPath);
+        try {
+            const { stdout } = await execFileAsync(cmd, ["models"], {
+                timeout: 10_000,
+                env: process.env,
+                maxBuffer: 4 * 1024 * 1024,
+                shell: process.platform === "win32",
+            });
+            const parsed = parseAgyModelsOutput(stdout);
+            cachedModels = parsed;
+            cachedModelsBinaryPath = binaryPath;
+            lastModelFetch = Date.now();
+            return parsed;
+        }
+        catch (err) {
+            logger.warn("Failed to fetch models from agy CLI, using fallback models", {
+                error: err.message,
+            });
+            cachedModels = FALLBACK_MODELS;
+            cachedModelsBinaryPath = binaryPath;
+            lastModelFetch = Date.now();
+            return FALLBACK_MODELS;
+        }
+        finally {
+            inFlightModelFetch = null;
+        }
+    })();
+    return inFlightModelFetch;
 }
 export function getEffectiveEffortForModel(modelId, requestedEffort, models) {
     if (!modelId)

package/dist/slash-commands.js

@@ -5,6 +5,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { logger } from "./logger.js";
 import { sessionStore } from "./session-store.js";
+import { formatExecBinaryPath } from "./protocol.js";
 const execFileAsync = promisify(execFile);
 const AGY_COMMAND_TIMEOUT_MS = 30_000;
 const AGY_COMMAND_MAX_BUFFER = 4 * 1024 * 1024;
@@ -336,7 +337,8 @@ export function formatUsageOutput(rawText) {
     return out;
 }
 async function runAgySlash(binaryPath, cwd, slashCommand) {
-    const { stdout, stderr } = await execFileAsync(binaryPath, ["--print", slashCommand], {
+    const cmd = formatExecBinaryPath(binaryPath);
+    const { stdout, stderr } = await execFileAsync(cmd, ["--print", slashCommand], {
         cwd,
         env: process.env,
         timeout: AGY_COMMAND_TIMEOUT_MS,

package/package.json

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