paseo-acp-agy 1.1.0

package/dist/protocol.js

@@ -0,0 +1,471 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import { logger } from "./logger.js";
+import { saveBase64Image } from "./attachments.js";
+const execFileAsync = promisify(execFile);
+// ACP wire methods use snake_case. The aliases retain the public method names
+// accepted by the adapter before the hardening work so existing clients do not
+// lose compatibility.
+export const ACP_METHODS = {
+    INITIALIZE: "initialize",
+    SESSION_NEW: "session/new",
+    SESSION_NEW_ALIAS: "newSession",
+    SESSION_LOAD: "session/load",
+    SESSION_LOAD_ALIAS: "loadSession",
+    SESSION_RESUME: "session/resume",
+    SESSION_RESUME_ALIAS: "unstable_resumeSession",
+    SESSION_PROMPT: "session/prompt",
+    SESSION_PROMPT_ALIAS: "prompt",
+    SESSION_CANCEL: "session/cancel",
+    SESSION_CANCEL_ALIAS: "cancel",
+    SESSION_CLOSE: "session/close",
+    SESSION_CLOSE_ALIAS: "unstable_closeSession",
+    SESSION_SET_MODE: "session/set_mode",
+    SESSION_SET_MODE_ALIAS: "setSessionMode",
+    SESSION_SET_MODEL: "session/set_model",
+    SESSION_SET_MODEL_ALIAS: "unstable_setSessionModel",
+    SESSION_SET_CONFIG_OPTION: "session/set_config_option",
+    SESSION_SET_CONFIG_OPTION_ALIAS: "setSessionConfigOption",
+    SESSION_UPDATE: "session/update",
+};
+export function mapToolNameToKind(toolName) {
+    const name = toolName.toLowerCase();
+    if (name.includes("read") ||
+        name.includes("view") ||
+        name.includes("list") ||
+        name.includes("grep") ||
+        name.includes("find") ||
+        name === "view_file" ||
+        name === "list_dir")
+        return "read";
+    if (name.includes("write") ||
+        name.includes("replace") ||
+        name.includes("edit") ||
+        name.includes("sed") ||
+        name === "write_to_file" ||
+        name === "replace_file_content" ||
+        name === "multi_replace_file_content")
+        return "edit";
+    if (name.includes("command") ||
+        name.includes("terminal") ||
+        name.includes("execute") ||
+        name === "run_command")
+        return "execute";
+    if (name.includes("search") ||
+        name.includes("url") ||
+        name.includes("browser") ||
+        name === "search_web")
+        return "fetch";
+    return "other";
+}
+export function extractPromptText(promptInput) {
+    if (typeof promptInput === "string") {
+        const trimmed = promptInput.trim();
+        return trimmed || "Please continue.";
+    }
+    const textParts = [];
+    const imagePaths = [];
+    const processBlock = (block) => {
+        if (!block)
+            return;
+        if (typeof block === "string") {
+            if (block.trim())
+                textParts.push(block.trim());
+            return;
+        }
+        if (typeof block !== "object")
+            return;
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string" && b.text.trim()) {
+            textParts.push(b.text.trim());
+            return;
+        }
+        if (b.type === "image") {
+            if (typeof b.uri === "string" && b.uri.startsWith("file://")) {
+                try {
+                    imagePaths.push(fileURLToPath(b.uri));
+                }
+                catch {
+                    logger.warn("Ignoring invalid file:// image URI");
+                }
+            }
+            else if (typeof b.path === "string" && b.path.trim()) {
+                imagePaths.push(b.path.trim());
+            }
+            else if (typeof b.data === "string" && b.data.length > 0) {
+                const mime = typeof b.mimeType === "string" ? b.mimeType : "image/png";
+                const savedPath = saveBase64Image(b.data, mime);
+                if (savedPath)
+                    imagePaths.push(savedPath);
+            }
+            return;
+        }
+        if (b.type === "resource_link" && typeof b.uri === "string") {
+            textParts.push(`[Resource: ${b.uri}]`);
+        }
+        else if (typeof b.content === "string" && b.content.trim()) {
+            textParts.push(b.content.trim());
+        }
+    };
+    if (Array.isArray(promptInput)) {
+        for (const item of promptInput)
+            processBlock(item);
+    }
+    else {
+        processBlock(promptInput);
+    }
+    const imageInstructions = imagePaths.map((imgPath) => `[Attached Image: ${imgPath}]\n(The user attached an image saved at "${imgPath}". Please inspect and view it using the \`view_file\` tool with AbsolutePath="${imgPath}".)`);
+    if (textParts.length > 0) {
+        if (imageInstructions.length > 0) {
+            return `${textParts.join("\n\n")}\n\n${imageInstructions.join("\n\n")}`;
+        }
+        return textParts.join("\n\n");
+    }
+    if (imageInstructions.length > 0) {
+        return `Please inspect and analyze the attached image(s) using the \`view_file\` tool.\n\n${imageInstructions.join("\n\n")}`;
+    }
+    return "Please continue.";
+}
+export const MODEL_PRICING = {
+    "gemini-3.8-flash": { inputCostPerM: 0.10, outputCostPerM: 0.40, cachedInputCostPerM: 0.025 },
+    "gemini-3.7-flash": { inputCostPerM: 0.10, outputCostPerM: 0.40, cachedInputCostPerM: 0.025 },
+    "gemini-3.6-flash": { inputCostPerM: 0.10, outputCostPerM: 0.40, cachedInputCostPerM: 0.025 },
+    "gemini-3.1-pro": { inputCostPerM: 1.25, outputCostPerM: 5.00, cachedInputCostPerM: 0.3125 },
+    "claude-sonnet-4-6": { inputCostPerM: 3.00, outputCostPerM: 15.00, cachedInputCostPerM: 0.30 },
+    "claude-opus-4-6-thinking": { inputCostPerM: 15.00, outputCostPerM: 75.00, cachedInputCostPerM: 1.50 },
+    "gpt-oss-120b": { inputCostPerM: 0.15, outputCostPerM: 0.60, cachedInputCostPerM: 0.0375 },
+};
+export const MODEL_CONTEXT_WINDOWS = {
+    "gemini-3.8-flash": 1_048_576,
+    "gemini-3.7-flash": 1_048_576,
+    "gemini-3.6-flash": 1_048_576,
+    "gemini-3.1-pro": 2_097_152,
+    "claude-sonnet-4-6": 200_000,
+    "claude-opus-4-6-thinking": 200_000,
+    "gpt-oss-120b": 128_000,
+};
+export function getModelContextWindow(modelId) {
+    if (!modelId)
+        return 1_048_576;
+    if (MODEL_CONTEXT_WINDOWS[modelId])
+        return MODEL_CONTEXT_WINDOWS[modelId];
+    const lower = modelId.toLowerCase();
+    if (lower.includes("pro"))
+        return 2_097_152;
+    if (lower.includes("claude"))
+        return 200_000;
+    if (lower.includes("gpt"))
+        return 128_000;
+    if (lower.includes("flash"))
+        return 1_048_576;
+    return 1_048_576;
+}
+export function getModelPricing(modelId) {
+    if (!modelId)
+        return null;
+    if (MODEL_PRICING[modelId])
+        return MODEL_PRICING[modelId];
+    const lower = modelId.toLowerCase();
+    if (lower.includes("opus"))
+        return MODEL_PRICING["claude-opus-4-6-thinking"];
+    if (lower.includes("claude") || lower.includes("sonnet"))
+        return MODEL_PRICING["claude-sonnet-4-6"];
+    if (lower.includes("pro"))
+        return MODEL_PRICING["gemini-3.1-pro"];
+    if (lower.includes("flash"))
+        return MODEL_PRICING["gemini-3.7-flash"];
+    if (lower.includes("gpt-oss"))
+        return MODEL_PRICING["gpt-oss-120b"];
+    return null;
+}
+// Keep costs at full JavaScript floating-point precision. Rounding happens
+// only when values are serialized for the UI so micro-costs accumulate.
+export function calculateUsageCostUsd(modelId = "gemini-3.7-flash", inputTokens = 0, outputTokens = 0, cachedInputTokens = 0) {
+    const pricing = getModelPricing(modelId);
+    if (!pricing)
+        return 0;
+    const inputCost = (inputTokens / 1_000_000) * pricing.inputCostPerM;
+    const outputCost = (outputTokens / 1_000_000) * pricing.outputCostPerM;
+    const cachedCost = (cachedInputTokens / 1_000_000) * pricing.cachedInputCostPerM;
+    return inputCost + outputCost + cachedCost;
+}
+export function roundUsageCostUsd(costUsd, decimals = 6) {
+    const factor = 10 ** decimals;
+    return Math.round(costUsd * factor) / factor;
+}
+export function deriveUsageTone(usedPct) {
+    if (usedPct >= 90)
+        return "danger";
+    if (usedPct >= 75)
+        return "warning";
+    return "ok";
+}
+export function parseAgyQuotaOutput(raw) {
+    const windows = [];
+    const lines = raw.split(/[\r\n]+/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.toLowerCase().startsWith("quota:"))
+            continue;
+        const parts = trimmed.split(/\t+|\s{2,}/).map((p) => p.trim());
+        if (parts.length >= 3) {
+            const scope = parts[0];
+            const limitType = parts[1];
+            const remainingMatch = parts[2].match(/(\d+)%/);
+            const resetsAt = parts[3] || null;
+            if (remainingMatch) {
+                const remainingPct = parseInt(remainingMatch[1], 10);
+                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 (5h)" : isWeekly ? "Weekly" : limitType;
+                if (!isGemini) {
+                    id = `claude_${id}`;
+                    label = `Claude ${label}`;
+                }
+                windows.push({
+                    id,
+                    label,
+                    usedPct,
+                    remainingPct,
+                    resetsAt,
+                    tone: deriveUsageTone(usedPct),
+                });
+            }
+        }
+    }
+    return windows;
+}
+export function parseAgyCreditsOutput(raw) {
+    const match = raw.match(/Remaining\s+credits\s+([\d.]+)/i);
+    const remaining = match ? parseFloat(match[1]) : 0;
+    return {
+        id: "credits",
+        label: "Credits",
+        remaining,
+        unit: "usd",
+        tone: remaining > 0 ? "ok" : "default",
+    };
+}
+let cachedProviderUsage = null;
+let cachedProviderUsageBinaryPath = null;
+let lastProviderUsageFetch = 0;
+const PROVIDER_USAGE_CACHE_TTL_MS = 30_000;
+function errorMessage(reason) {
+    if (reason instanceof Error)
+        return reason.message;
+    return String(reason || "unknown error");
+}
+function cacheProviderUsage(binaryPath, result, now) {
+    cachedProviderUsage = result;
+    cachedProviderUsageBinaryPath = binaryPath;
+    lastProviderUsageFetch = now;
+    return result;
+}
+export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
+    const now = Date.now();
+    if (!force &&
+        cachedProviderUsage &&
+        cachedProviderUsageBinaryPath === binaryPath &&
+        now - lastProviderUsageFetch < PROVIDER_USAGE_CACHE_TTL_MS) {
+        return cachedProviderUsage;
+    }
+    try {
+        const [usageResult, creditsResult] = await Promise.allSettled([
+            execFileAsync(binaryPath, ["--print", "/usage"], {
+                timeout: 8_000,
+                maxBuffer: 1024 * 1024,
+                env: process.env,
+            }),
+            execFileAsync(binaryPath, ["--print", "/credits"], {
+                timeout: 8_000,
+                maxBuffer: 1024 * 1024,
+                env: process.env,
+            }),
+        ]);
+        const balances = [];
+        if (creditsResult.status === "fulfilled") {
+            const creditsOutput = creditsResult.value.stdout || creditsResult.value.stderr || "";
+            if (creditsOutput.trim())
+                balances.push(parseAgyCreditsOutput(creditsOutput));
+        }
+        // /usage is the primary provider-availability probe. allSettled never
+        // throws for an exec failure, so rejected results must be handled here.
+        if (usageResult.status === "rejected") {
+            const error = `Unable to fetch Antigravity quota: ${errorMessage(usageResult.reason)}`;
+            logger.warn("Failed to fetch Antigravity provider usage", { error });
+            return cacheProviderUsage(binaryPath, {
+                providerId: "antigravity",
+                displayName: "Antigravity",
+                status: "unavailable",
+                planLabel: null,
+                windows: [],
+                balances,
+                details: [],
+                error,
+            }, now);
+        }
+        const quotaOutput = usageResult.value.stdout || usageResult.value.stderr || "";
+        const windows = parseAgyQuotaOutput(quotaOutput);
+        const partialError = creditsResult.status === "rejected"
+            ? `Credits unavailable: ${errorMessage(creditsResult.reason)}`
+            : null;
+        return cacheProviderUsage(binaryPath, {
+            providerId: "antigravity",
+            displayName: "Antigravity",
+            status: "available",
+            planLabel: "Google Gemini",
+            windows,
+            balances,
+            details: [],
+            error: partialError,
+        }, now);
+    }
+    catch (err) {
+        const error = errorMessage(err);
+        logger.warn("Failed to fetch Antigravity provider usage", { error });
+        return cacheProviderUsage(binaryPath, {
+            providerId: "antigravity",
+            displayName: "Antigravity",
+            status: "unavailable",
+            planLabel: null,
+            windows: [],
+            balances: [],
+            details: [],
+            error,
+        }, now);
+    }
+}
+export const ALL_THINKING_LEVELS = {
+    low: { name: "Low", description: "Fast response with minimal reasoning latency" },
+    medium: { name: "Medium", description: "Balanced reasoning effort and speed" },
+    high: { name: "High", description: "Deep reasoning effort for complex tasks" },
+};
+export const FALLBACK_MODELS = [
+    { modelId: "gemini-3.8-flash", name: "Gemini 3.8 Flash", description: "Google Gemini 3.8 Flash", supportedEfforts: ["high", "medium", "low"], contextWindowMaxTokens: 1_048_576 },
+    { modelId: "gemini-3.7-flash", name: "Gemini 3.7 Flash", description: "Google Gemini 3.7 Flash", supportedEfforts: ["high", "medium", "low"], contextWindowMaxTokens: 1_048_576 },
+    { modelId: "gemini-3.6-flash", name: "Gemini 3.6 Flash", description: "Google Gemini 3.6 Flash", supportedEfforts: ["high", "medium", "low"], contextWindowMaxTokens: 1_048_576 },
+    { modelId: "gemini-3.1-pro", name: "Gemini 3.1 Pro", description: "Google Gemini 3.1 Pro", supportedEfforts: ["high", "low"], contextWindowMaxTokens: 2_097_152 },
+    { modelId: "claude-sonnet-4-6", name: "Claude Sonnet 4.6 (Thinking)", description: "Anthropic Claude Sonnet 4.6 (Thinking)", supportedEfforts: [], contextWindowMaxTokens: 200_000 },
+    { modelId: "claude-opus-4-6-thinking", name: "Claude Opus 4.6 (Thinking)", description: "Anthropic Claude Opus 4.6 (Thinking)", supportedEfforts: [], contextWindowMaxTokens: 200_000 },
+    { modelId: "gpt-oss-120b", name: "GPT-OSS 120B", description: "GPT-OSS 120B (Medium)", supportedEfforts: ["medium"], contextWindowMaxTokens: 128_000 },
+];
+let cachedModels = null;
+let cachedModelsBinaryPath = null;
+let lastModelFetch = 0;
+const MODEL_CACHE_TTL_MS = 60_000;
+export function parseAgyModelsOutput(rawOutput) {
+    const modelsMap = new Map();
+    for (const line of rawOutput.split(/[\r\n]+/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.includes("Fetching available models"))
+            continue;
+        const parts = trimmed.split(/\t+|\s{2,}/).map((p) => p.trim()).filter(Boolean);
+        if (parts.length < 2)
+            continue;
+        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)\)$/, "");
+        }
+        if (!modelsMap.has(baseId)) {
+            modelsMap.set(baseId, {
+                modelId: baseId,
+                name: baseLabel,
+                description: label,
+                supportedEfforts: [],
+                contextWindowMaxTokens: getModelContextWindow(baseId),
+            });
+        }
+        if (effort) {
+            const entry = modelsMap.get(baseId);
+            if (!entry.supportedEfforts.includes(effort))
+                entry.supportedEfforts.push(effort);
+        }
+    }
+    const result = Array.from(modelsMap.values());
+    return result.length > 0 ? result : FALLBACK_MODELS;
+}
+export async function fetchAvailableModels(binaryPath = "agy", force = false) {
+    const now = Date.now();
+    if (!force &&
+        cachedModels &&
+        cachedModelsBinaryPath === binaryPath &&
+        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,
+        });
+        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;
+    }
+}
+export function getEffectiveEffortForModel(modelId, requestedEffort, models) {
+    if (!modelId)
+        return undefined;
+    const modelList = models || cachedModels || FALLBACK_MODELS;
+    const modelDef = modelList.find((m) => m.modelId === modelId);
+    if (!modelDef || modelDef.supportedEfforts.length === 0)
+        return undefined;
+    if (requestedEffort && modelDef.supportedEfforts.includes(requestedEffort))
+        return requestedEffort;
+    if (modelDef.supportedEfforts.includes("high"))
+        return "high";
+    return modelDef.supportedEfforts[0];
+}
+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" },
+];
+export function buildConfigOptionsForModel(modelId, currentEffort = "high", availableModels) {
+    const modelList = availableModels || cachedModels || FALLBACK_MODELS;
+    const modelDef = modelList.find((m) => m.modelId === modelId);
+    const supported = modelDef ? modelDef.supportedEfforts : ["high", "medium", "low"];
+    if (!supported || supported.length === 0)
+        return [];
+    const effectiveEffort = supported.includes(currentEffort)
+        ? currentEffort
+        : supported.includes("high")
+            ? "high"
+            : supported[0];
+    const options = supported.map((effortId) => ({
+        value: effortId,
+        name: ALL_THINKING_LEVELS[effortId]?.name || effortId.toUpperCase(),
+        description: ALL_THINKING_LEVELS[effortId]?.description || `${effortId} effort`,
+    }));
+    return [
+        {
+            id: "thought_level",
+            name: "Thinking Effort",
+            category: "thought_level",
+            type: "select",
+            currentValue: effectiveEffort,
+            options,
+        },
+    ];
+}

package/dist/session-store.d.ts

@@ -0,0 +1,27 @@
+export interface SessionUsageState {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    totalTokens: number;
+    totalCostUsd: number;
+    contextWindowUsedTokens: number;
+    contextWindowMaxTokens: number;
+}
+export interface PersistedSessionState {
+    sessionId: string;
+    conversationId?: string;
+    cwd: string;
+    model: string;
+    effort: string;
+    mode: string;
+    usage?: SessionUsageState;
+    updatedAt: string;
+}
+export declare class SessionStore {
+    private dir;
+    constructor(dir?: string);
+    private pathFor;
+    load(sessionId: string): PersistedSessionState | null;
+    save(state: PersistedSessionState): void;
+}
+export declare const sessionStore: SessionStore;

package/dist/session-store.js

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { logger } from "./logger.js";
+function getStateRoot() {
+    if (process.env.AGY_ACP_STATE_DIR) {
+        return process.env.AGY_ACP_STATE_DIR;
+    }
+    const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+    return path.join(stateHome, "agy-acp");
+}
+function fileNameForSession(sessionId) {
+    return crypto.createHash("sha256").update(sessionId).digest("hex") + ".json";
+}
+export class SessionStore {
+    dir;
+    constructor(dir) {
+        this.dir = dir || path.join(getStateRoot(), "sessions");
+        try {
+            fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+            fs.chmodSync(this.dir, 0o700);
+        }
+        catch { }
+    }
+    pathFor(sessionId) {
+        return path.join(this.dir, fileNameForSession(sessionId));
+    }
+    load(sessionId) {
+        const filePath = this.pathFor(sessionId);
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+            if (parsed.sessionId !== sessionId) {
+                logger.warn("Ignoring persisted session with mismatched session ID", { sessionId });
+                return null;
+            }
+            return parsed;
+        }
+        catch (err) {
+            logger.warn("Failed to load persisted ACP session", {
+                sessionId,
+                error: err.message,
+            });
+            return null;
+        }
+    }
+    save(state) {
+        const filePath = this.pathFor(state.sessionId);
+        const tempPath = `${filePath}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+        try {
+            fs.writeFileSync(tempPath, JSON.stringify(state, null, 2) + "\n", {
+                encoding: "utf8",
+                mode: 0o600,
+                flag: "wx",
+            });
+            fs.renameSync(tempPath, filePath);
+            fs.chmodSync(filePath, 0o600);
+        }
+        catch (err) {
+            try {
+                fs.rmSync(tempPath, { force: true });
+            }
+            catch { }
+            logger.warn("Failed to persist ACP session state", {
+                sessionId: state.sessionId,
+                error: err.message,
+            });
+        }
+    }
+}
+export const sessionStore = new SessionStore();

package/dist/session.d.ts

@@ -0,0 +1,66 @@
+import { AntigravityProcess } from "./antigravity-process.js";
+import { SessionStore, SessionUsageState } from "./session-store.js";
+export interface SessionOptions {
+    id?: string;
+    cwd?: string;
+    model?: string;
+    effort?: string;
+    mode?: string;
+    conversationId?: string;
+    usage?: SessionUsageState;
+    sandbox?: boolean;
+    dangerouslySkipPermissions?: boolean;
+    env?: Record<string, string>;
+    binaryPath?: string;
+    store?: SessionStore;
+}
+export declare class Session {
+    readonly id: string;
+    cwd: string;
+    model: string;
+    effort: string;
+    mode: string;
+    readonly createdAt: Date;
+    lastActivity: Date;
+    isCancelled: boolean;
+    process: AntigravityProcess;
+    usage: SessionUsageState;
+    private store;
+    private promptOperationActive;
+    constructor(options?: SessionOptions);
+    private persistedState;
+    persist(): void;
+    get isPromptOperationActive(): boolean;
+    tryBeginPromptOperation(): boolean;
+    endPromptOperation(): void;
+    setModel(model: string): void;
+    setEffort(effort: string): void;
+    setMode(mode: string): void;
+    setConversationId(conversationId?: string): void;
+    ensureReadyForResume(): Promise<void>;
+    resumeConversation(conversationId: string): Promise<void>;
+    recordTurnUsage(turnUsage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        cache_read_tokens?: number;
+        total_tokens?: number;
+    }, executingModel?: string): void;
+    touch(): void;
+    cancelTurn(): boolean;
+    close(): Promise<void>;
+}
+export declare class SessionManager {
+    private sessions;
+    private defaultBinaryPath?;
+    private store;
+    constructor(options?: {
+        defaultBinaryPath?: string;
+        store?: SessionStore;
+    });
+    createSession(options?: SessionOptions): Session;
+    getSession(id: string): Session | undefined;
+    hasPersistedSession(id: string): boolean;
+    closeSession(id: string): Promise<boolean>;
+    closeAll(): Promise<void>;
+    listSessions(): Session[];
+}