visionclaw 0.1.91 → 0.1.92

package/dist/agent/providers/claude/session.d.ts

@@ -0,0 +1,134 @@
+import { type Query, type SDKMessage, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { MessageParam } from "@anthropic-ai/sdk/resources";
+import type { SessionMode } from "../../mailbox.js";
+import type { ScreenshotInjector } from "../../screenshot-injector.js";
+import type { AgentSessionConstructorArgs, AgentSessionLike, AgentStreamMessage } from "../session-types.js";
+export type { SDKMessage, SDKUserMessage };
+export type { SystemPromptConfig } from "../session-types.js";
+export declare const COMPACT_USED_PCT_THRESHOLD = 0.5;
+export declare const MAX_BASE64_IMAGE_BLOCKS = 10;
+/**
+ * Wraps the V1 query() API with a long-lived async generator for streaming
+ * input. This allows injecting additional user messages while the agent is
+ * processing (interrupt messages), instead of waiting for the query to
+ * finish before sending the next message.
+ */
+export declare class ClaudeAgentSession implements AgentSessionLike {
+    private config;
+    private buildSystemPrompt;
+    private runtimeSurface;
+    private getDualSessionEnabled;
+    private nativeTools;
+    /** Resolved external MCP servers (playwright, serpapi, etc.) for this runtime. */
+    private externalMcpServers;
+    /** Dynamic MCP servers added at runtime via manage_mcp_servers tool. */
+    private dynamicMcpServers;
+    private currentQuery;
+    private sessionId;
+    private transcriptPath;
+    readonly mode: SessionMode;
+    /**
+     * Pending message queue for the long-lived generator.
+     * When a message is injected, it's pushed here and the waiting
+     * generator is woken up via the resolver.
+     */
+    private pendingMessages;
+    private messageResolver;
+    private generatorClosed;
+    private _orphanedInjections;
+    private lastCompactRequestAtMs;
+    private compactInFlight;
+    private stopRequested;
+    /** Optional: auto-injects screenshots after Playwright tool calls. */
+    private _screenshotInjector;
+    /** AbortController passed to the SDK; aborting it cleanly stops the running query. */
+    private abortController;
+    private lastUsageSnapshot;
+    constructor({ config, buildSystemPrompt, runtimeSurface, sessionContext, }: AgentSessionConstructorArgs);
+    set screenshotInjector(injector: ScreenshotInjector | null);
+    /**
+     * Build a fresh mcpServers record with a new visionclaw tool server instance.
+     * This avoids the "Already connected to a transport" error when the same
+     * McpServer instance is reused across concurrent/sequential query() calls.
+     */
+    private buildMcpServers;
+    private buildNativeToolOptions;
+    /**
+     * Send the initial user message and return the query generator to stream
+     * responses. The underlying async generator stays open so that additional
+     * messages can be injected via injectMessage().
+     */
+    sendAndStream(content: MessageParam["content"]): AsyncIterable<AgentStreamMessage>;
+    /**
+     * Inject a new user message into the running query stream.
+     * The agent will see this as a follow-up user message in the conversation.
+     * Only works while a query is active (between sendAndStream and closeInput).
+     *
+     * @returns true if the message was injected, false if the generator is closed.
+     */
+    injectMessage(content: MessageParam["content"]): boolean;
+    /**
+     * Signal the input generator to close.
+     * Any injected messages still in the pending queue are counted as
+     * orphaned — they were accepted by injectMessage but never delivered
+     * to the SDK.
+     */
+    closeInput(): void;
+    /**
+     * Returns true if injected messages were lost when the generator closed.
+     */
+    get hasOrphanedInjections(): boolean;
+    get isInputClosed(): boolean;
+    /**
+     * Request that the current agent turn be stopped.
+     * Uses the SDK's AbortController to cleanly signal the running query to
+     * stop, then closes the input stream so the loop returns to idle.
+     */
+    requestStop(): void;
+    isStopRequested(): boolean;
+    clearStop(): void;
+    /**
+     * Update the persisted session ID.
+     */
+    captureSessionId(id: string | undefined): void;
+    captureTranscriptPath(p: string | undefined | null): void;
+    getSessionId(): string | null;
+    /**
+     * Proactively request compaction by running the /compact slash command as a
+     * separate one-turn query resumed from the current session.
+     *
+     * This is more reliable than injecting "/compact" into the streaming prompt
+     * because the running query may treat it as ordinary text.
+     */
+    requestCompaction(): Promise<void>;
+    captureUsageSnapshot(snapshot: {
+        usedInputTokens: number;
+        contextWindow: number;
+        usedPct: number;
+    }): void;
+    /**
+     * Update the usage snapshot after the SDK performs mid-query auto-compaction.
+     * Uses `pre_tokens` (the post-compaction token count) and the last known
+     * context window to compute an accurate `usedPct`, preventing the post-query
+     * `maybeCompactByTokens` from triggering a redundant compaction.
+     */
+    capturePostCompactionSnapshot(postCompactionTokens: number): void;
+    maybeCompactByTokens(options?: {
+        usedPctThreshold?: number;
+        cooldownMs?: number;
+    }): Promise<void>;
+    getTranscriptPath(): string | null;
+    getUsageSnapshot(): {
+        usedInputTokens: number;
+        contextWindow: number;
+        usedPct: number;
+        capturedAtMs: number;
+    } | null;
+    /** Returns the live Query object, or null if no query is active. */
+    getCurrentQuery(): Query | null;
+    /** Replace the full set of dynamic MCP servers (used when loading from disk). */
+    setDynamicMcpServers(servers: Record<string, Record<string, unknown>>): void;
+    /** Get the current dynamic MCP servers record. */
+    getDynamicMcpServers(): Record<string, Record<string, unknown>>;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/agent/providers/claude/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/agent/providers/claude/session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EACV,KAAK,UAAU,EACf,KAAK,cAAc,EAOpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAIhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAOpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,OAAO,KAAK,EACV,2BAA2B,EAC3B,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAW7B,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;AAC3C,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,gBAAgB;IACzD,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,qBAAqB,CAAgB;IAC7C,OAAO,CAAC,WAAW,CAAgC;IACnD,kFAAkF;IAClF,OAAO,CAAC,kBAAkB,CAAkC;IAC5D,wEAAwE;IACxE,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,cAAc,CAAuB;IAC7C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAE3B;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,mBAAmB,CAAK;IAEhC,OAAO,CAAC,sBAAsB,CAAK;IAEnC,OAAO,CAAC,eAAe,CAAS;IAEhC,OAAO,CAAC,aAAa,CAAS;IAE9B,sEAAsE;IACtE,OAAO,CAAC,mBAAmB,CAAmC;IAE9D,sFAAsF;IACtF,OAAO,CAAC,eAAe,CAAgC;IAEvD,OAAO,CAAC,iBAAiB,CAOT;gBAEJ,EACV,MAAM,EACN,iBAAiB,EACjB,cAAc,EACd,cAAc,GACf,EAAE,2BAA2B;IAiB9B,IAAI,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,EAEzD;IAED;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,sBAAsB;IAY9B;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,GAAG,aAAa,CAAC,kBAAkB,CAAC;IA2MlF;;;;;;OAMG;IACH,aAAa,CAAC,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,GAAG,OAAO;IAwBxD;;;;;OAKG;IACH,UAAU,IAAI,IAAI;IAalB;;OAEG;IACH,IAAI,qBAAqB,IAAI,OAAO,CAEnC;IAED,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;;OAIG;IACH,WAAW,IAAI,IAAI;IAWnB,eAAe,IAAI,OAAO;IAI1B,SAAS,IAAI,IAAI;IAKjB;;OAEG;IACH,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAO9C,qBAAqB,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,IAAI;IAMzD,YAAY,IAAI,MAAM,GAAG,IAAI;IAI7B;;;;;;OAMG;IACG,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IA+FxC,oBAAoB,CAAC,QAAQ,EAAE;QAC7B,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;KACjB,GAAG,IAAI;IASR;;;;;OAKG;IACH,6BAA6B,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI;IAc3D,oBAAoB,CAAC,OAAO,CAAC,EAAE;QACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDjB,iBAAiB,IAAI,MAAM,GAAG,IAAI;IAIlC,gBAAgB,IAAI;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAIpH,oEAAoE;IACpE,eAAe,IAAI,KAAK,GAAG,IAAI;IAI/B,iFAAiF;IACjF,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI;IAI5E,kDAAkD;IAClD,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAGhE"}

package/dist/agent/providers/claude/session.js

@@ -0,0 +1,525 @@
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { loadSessionId, saveSessionId, loadUsageSnapshot, saveUsageSnapshot, getConfigDir } from "../../../config/index.js";
+import { logger } from "../../../logger.js";
+import { createToolServer } from "../../../tools/index.js";
+import { buildAgentEnv, getModelId } from "../client-factory.js";
+import { getAgentState } from "../../state.js";
+import { createRequire } from "module";
+import path from "path";
+import fs from "fs";
+import { ensureBrowser } from "../../browser-launcher.js";
+import * as imagePrunerUnTyped from "../../image-pruner.js";
+const imagePruner = imagePrunerUnTyped;
+export const COMPACT_USED_PCT_THRESHOLD = 0.5;
+export const MAX_BASE64_IMAGE_BLOCKS = 10;
+/**
+ * Wraps the V1 query() API with a long-lived async generator for streaming
+ * input. This allows injecting additional user messages while the agent is
+ * processing (interrupt messages), instead of waiting for the query to
+ * finish before sending the next message.
+ */
+export class ClaudeAgentSession {
+    config;
+    buildSystemPrompt;
+    runtimeSurface;
+    getDualSessionEnabled;
+    nativeTools;
+    /** Resolved external MCP servers (playwright, serpapi, etc.) for this runtime. */
+    externalMcpServers;
+    /** Dynamic MCP servers added at runtime via manage_mcp_servers tool. */
+    dynamicMcpServers;
+    currentQuery = null;
+    sessionId;
+    transcriptPath = null;
+    mode;
+    /**
+     * Pending message queue for the long-lived generator.
+     * When a message is injected, it's pushed here and the waiting
+     * generator is woken up via the resolver.
+     */
+    pendingMessages = [];
+    messageResolver = null;
+    generatorClosed = true;
+    _orphanedInjections = 0;
+    lastCompactRequestAtMs = 0;
+    compactInFlight = false;
+    stopRequested = false;
+    /** Optional: auto-injects screenshots after Playwright tool calls. */
+    _screenshotInjector = null;
+    /** AbortController passed to the SDK; aborting it cleanly stops the running query. */
+    abortController = null;
+    lastUsageSnapshot = null;
+    constructor({ config, buildSystemPrompt, runtimeSurface, sessionContext, }) {
+        this.config = config;
+        this.buildSystemPrompt = buildSystemPrompt;
+        this.runtimeSurface = runtimeSurface;
+        this.getDualSessionEnabled = sessionContext.getDualSessionEnabled;
+        this.nativeTools = runtimeSurface.nativeTools;
+        this.externalMcpServers = runtimeSurface.externalMcpServers;
+        this.dynamicMcpServers = {};
+        this.mode = sessionContext.mode;
+        this.sessionId = loadSessionId(this.mode);
+        const persisted = loadUsageSnapshot(this.mode);
+        if (persisted && this.sessionId) {
+            this.lastUsageSnapshot = { ...persisted, capturedAtMs: Date.now() };
+        }
+    }
+    set screenshotInjector(injector) {
+        this._screenshotInjector = injector;
+    }
+    /**
+     * Build a fresh mcpServers record with a new visionclaw tool server instance.
+     * This avoids the "Already connected to a transport" error when the same
+     * McpServer instance is reused across concurrent/sequential query() calls.
+     */
+    buildMcpServers() {
+        if (this.runtimeSurface.visionClawToolTransport.transport !== "claude-mcp") {
+            throw new Error("Claude session requires claude-mcp VisionClaw tool transport");
+        }
+        return {
+            ...this.externalMcpServers,
+            ...this.dynamicMcpServers,
+            visionclaw: createToolServer({
+                dualSession: this.getDualSessionEnabled()
+                    && this.runtimeSurface.visionClawToolTransport.supportsSwitchSessionTool,
+            }),
+        };
+    }
+    buildNativeToolOptions() {
+        if (this.nativeTools.kind === "claude-default") {
+            return {
+                tools: { type: "preset", preset: "claude_code" },
+            };
+        }
+        return {};
+    }
+    /**
+     * Send the initial user message and return the query generator to stream
+     * responses. The underlying async generator stays open so that additional
+     * messages can be injected via injectMessage().
+     */
+    sendAndStream(content) {
+        const savedSessionId = this.sessionId;
+        // Resolve the SDK's cli.js path so it works both in dev and bundled mode
+        const _require = createRequire(import.meta.url);
+        const sdkCliPath = path.resolve(path.dirname(_require.resolve("@anthropic-ai/claude-agent-sdk")), "cli.js");
+        const options = {
+            model: getModelId(this.config),
+            pathToClaudeCodeExecutable: sdkCliPath,
+            systemPrompt: this.buildSystemPrompt(),
+            ...this.buildNativeToolOptions(),
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            cwd: getConfigDir(),
+            settingSources: ["project"],
+            mcpServers: this.buildMcpServers(),
+            hooks: {
+                UserPromptSubmit: [
+                    {
+                        hooks: [
+                            (async (input, _toolUseID, { signal }) => {
+                                const up = input;
+                                try {
+                                    this.captureTranscriptPath(up.transcript_path);
+                                    if (signal.aborted)
+                                        return {};
+                                    // Prune aggressively throughout the session to prevent
+                                    // context bloat from accumulated base64 screenshots.
+                                    await imagePruner.pruneSessionImages({
+                                        transcriptPath: up.transcript_path,
+                                        keepLastNBase64Images: MAX_BASE64_IMAGE_BLOCKS,
+                                    });
+                                }
+                                catch (err) {
+                                    logger.warn(`UserPromptSubmit image pruning failed: ${err instanceof Error ? err.message : String(err)}`);
+                                }
+                                return {};
+                            }),
+                        ],
+                        timeout: 120,
+                    },
+                ],
+                PreCompact: [
+                    {
+                        hooks: [
+                            (async (input, _toolUseID, { signal }) => {
+                                const pre = input;
+                                try {
+                                    this.captureTranscriptPath(pre.transcript_path);
+                                    // Best-effort pruning: keep only the last 10 base64 image blocks
+                                    // so compaction does not have to carry large screenshots forward.
+                                    // Abort early if hook is cancelled.
+                                    if (signal.aborted)
+                                        return {};
+                                    const res = await imagePruner.pruneSessionImages({
+                                        transcriptPath: pre.transcript_path,
+                                        keepLastNBase64Images: MAX_BASE64_IMAGE_BLOCKS,
+                                    });
+                                    if (res.fileChanged) {
+                                        logger.system(`Pruned transcript images before compaction: pruned=${res.prunedImageBlocks} resized=${res.resizedImageBlocks} kept=${res.keptImageBlocks} total=${res.totalImageBlocks}`);
+                                    }
+                                }
+                                catch (err) {
+                                    logger.warn(`PreCompact image pruning failed: ${err instanceof Error ? err.message : String(err)}`);
+                                }
+                                return {};
+                            }),
+                        ],
+                        timeout: 120,
+                    },
+                ],
+                PreToolUse: [
+                    {
+                        matcher: "mcp__playwright__.*",
+                        hooks: [
+                            (async (_input) => {
+                                const pre = _input;
+                                logger.debug(`[PreToolUse] ensuring browser for ${pre.tool_name}`);
+                                await ensureBrowser();
+                                return {};
+                            }),
+                        ],
+                        timeout: 30,
+                    },
+                ],
+                PostToolUse: [
+                    {
+                        hooks: [
+                            (async (input, _toolUseID) => {
+                                const post = input;
+                                try {
+                                    const { resizedCount } = await imagePruner.resizeOversizedImagesInToolOutput(post.tool_response);
+                                    if (resizedCount > 0) {
+                                        logger.debug(`[PostToolUse] resized ${resizedCount} oversized image(s) in ${post.tool_name} output`);
+                                        return {
+                                            hookSpecificOutput: {
+                                                hookEventName: "PostToolUse",
+                                                updatedMCPToolOutput: post.tool_response,
+                                            },
+                                        };
+                                    }
+                                }
+                                catch (err) {
+                                    logger.warn(`PostToolUse image resize failed: ${err instanceof Error ? err.message : String(err)}`);
+                                }
+                                if (this._screenshotInjector) {
+                                    try {
+                                        await this._screenshotInjector.onToolComplete(post.tool_name, this);
+                                    }
+                                    catch (err) {
+                                        logger.warn(`PostToolUse screenshot injection failed: ${err instanceof Error ? err.message : String(err)}`);
+                                    }
+                                }
+                                return {};
+                            }),
+                        ],
+                        timeout: 120,
+                    },
+                ],
+            },
+            env: buildAgentEnv(this.config),
+            ...(savedSessionId ? { resume: savedSessionId } : {}),
+        };
+        // Seed the generator with the initial message
+        const initialMessage = {
+            type: "user",
+            session_id: savedSessionId ?? "",
+            message: { role: "user", content },
+            parent_tool_use_id: null,
+        };
+        this.pendingMessages = [initialMessage];
+        this.generatorClosed = false;
+        this._orphanedInjections = 0;
+        const abortController = new AbortController();
+        this.abortController = abortController;
+        // Create a long-lived async generator that yields the initial message
+        // and then waits for additional messages injected via injectMessage().
+        // We capture references to the session's pending queue and resolver
+        // so the generator can read from them without aliasing `this`.
+        const pending = this.pendingMessages;
+        const setResolver = (r) => {
+            this.messageResolver = r;
+        };
+        const isClosed = () => this.generatorClosed;
+        const shiftPending = () => pending.shift();
+        async function* messageStream() {
+            while (!isClosed()) {
+                // Yield all pending messages
+                let next = shiftPending();
+                while (next) {
+                    yield next;
+                    next = shiftPending();
+                }
+                // If generator is still open, wait for the next message
+                if (!isClosed()) {
+                    await new Promise((resolve) => {
+                        setResolver(resolve);
+                    });
+                }
+            }
+        }
+        if (savedSessionId) {
+            logger.system(`Resuming session: ${savedSessionId}`);
+        }
+        else {
+            logger.system("Creating new session...");
+        }
+        this.currentQuery = query({
+            prompt: messageStream(),
+            options: {
+                ...options,
+                abortController,
+                ...(this.config.provider === "bedrock" ? { betas: ["context-1m-2025-08-07"] } : {}),
+            },
+        });
+        return this.currentQuery;
+    }
+    /**
+     * Inject a new user message into the running query stream.
+     * The agent will see this as a follow-up user message in the conversation.
+     * Only works while a query is active (between sendAndStream and closeInput).
+     *
+     * @returns true if the message was injected, false if the generator is closed.
+     */
+    injectMessage(content) {
+        const msg = {
+            type: "user",
+            session_id: this.sessionId ?? "",
+            message: { role: "user", content },
+            parent_tool_use_id: null,
+        };
+        if (this.generatorClosed) {
+            logger.warn("Cannot inject message: generator is closed");
+            return false;
+        }
+        this.pendingMessages.push(msg);
+        logger.info("Injected interrupt message into active session");
+        // Wake the generator if it's waiting
+        if (this.messageResolver) {
+            this.messageResolver();
+            this.messageResolver = null;
+        }
+        return true;
+    }
+    /**
+     * Signal the input generator to close.
+     * Any injected messages still in the pending queue are counted as
+     * orphaned — they were accepted by injectMessage but never delivered
+     * to the SDK.
+     */
+    closeInput() {
+        this._orphanedInjections = this.pendingMessages.length;
+        if (this._orphanedInjections > 0) {
+            logger.warn(`closeInput: ${this._orphanedInjections} injected message(s) orphaned`);
+        }
+        this.pendingMessages = [];
+        this.generatorClosed = true;
+        if (this.messageResolver) {
+            this.messageResolver();
+            this.messageResolver = null;
+        }
+    }
+    /**
+     * Returns true if injected messages were lost when the generator closed.
+     */
+    get hasOrphanedInjections() {
+        return this._orphanedInjections > 0;
+    }
+    get isInputClosed() {
+        return this.generatorClosed;
+    }
+    /**
+     * Request that the current agent turn be stopped.
+     * Uses the SDK's AbortController to cleanly signal the running query to
+     * stop, then closes the input stream so the loop returns to idle.
+     */
+    requestStop() {
+        this.stopRequested = true;
+        if (this.abortController) {
+            this.abortController.abort();
+            logger.system("Stop requested — aborting query via AbortController");
+        }
+        this.closeInput();
+    }
+    isStopRequested() {
+        return this.stopRequested;
+    }
+    clearStop() {
+        this.stopRequested = false;
+        this.abortController = null;
+    }
+    /**
+     * Update the persisted session ID.
+     */
+    captureSessionId(id) {
+        if (id) {
+            this.sessionId = id;
+            saveSessionId(id, this.mode);
+        }
+    }
+    captureTranscriptPath(p) {
+        if (p && typeof p === "string") {
+            this.transcriptPath = p;
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Proactively request compaction by running the /compact slash command as a
+     * separate one-turn query resumed from the current session.
+     *
+     * This is more reliable than injecting "/compact" into the streaming prompt
+     * because the running query may treat it as ordinary text.
+     */
+    async requestCompaction() {
+        if (this.compactInFlight)
+            return;
+        this.compactInFlight = true;
+        // TODO: maybe should use reply map.
+        const sendCompactNotice = (text) => {
+            try {
+                const state = getAgentState();
+                const { ownerConfig, channelManager } = state;
+                const channel = ownerConfig.telegramChatId ? "telegram" : ownerConfig.ownerEmail ? "gmail" : undefined;
+                const recipient = ownerConfig.telegramChatId ? String(ownerConfig.telegramChatId) : ownerConfig.ownerEmail;
+                if (channel && recipient) {
+                    channelManager
+                        .sendMessage(channel, recipient, text)
+                        .catch((err) => {
+                        logger.warn(`Failed to send compaction notification: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                }
+            }
+            catch {
+                // Agent state not yet initialized — skip notification
+            }
+        };
+        try {
+            const savedSessionId = this.sessionId;
+            if (!savedSessionId) {
+                logger.warn("Cannot request /compact: session_id not available yet");
+                return;
+            }
+            // Resolve the SDK's cli.js path so it works both in dev and bundled mode
+            const _require = createRequire(import.meta.url);
+            const sdkCliPath = path.resolve(path.dirname(_require.resolve("@anthropic-ai/claude-agent-sdk")), "cli.js");
+            if (!fs.existsSync(sdkCliPath)) {
+                logger.warn(`Cannot request /compact: sdk cli.js not found at ${sdkCliPath}`);
+                return;
+            }
+            const options = {
+                model: getModelId(this.config),
+                pathToClaudeCodeExecutable: sdkCliPath,
+                systemPrompt: this.buildSystemPrompt(),
+                permissionMode: "bypassPermissions",
+                allowDangerouslySkipPermissions: true,
+                cwd: getConfigDir(),
+                settingSources: ["project"],
+                mcpServers: this.buildMcpServers(),
+                env: buildAgentEnv(this.config),
+                resume: savedSessionId,
+                maxTurns: 1,
+            };
+            logger.system("Requesting /compact...");
+            sendCompactNotice("Context window is getting full — compacting session memory, this may take a minute. I may lose some older details.");
+            logger.debug(`Compaction query options: cli=${sdkCliPath} cwd=${getConfigDir()} resume=${savedSessionId}`);
+            for await (const msg of query({
+                prompt: "/compact",
+                options,
+            })) {
+                if (msg.type === "system" && msg.subtype === "compact_boundary") {
+                    // Capture session id (should remain the same) and log compaction metadata.
+                    if ("session_id" in msg && msg.session_id) {
+                        this.captureSessionId(msg.session_id);
+                    }
+                    const meta = msg.compact_metadata;
+                    logger.system(`Compaction completed (trigger=${meta?.trigger ?? "unknown"}, pre_tokens=${meta?.pre_tokens ?? "?"})`);
+                    if (typeof meta?.pre_tokens === "number") {
+                        this.capturePostCompactionSnapshot(meta.pre_tokens);
+                    }
+                    sendCompactNotice("Session memory compacted. Ready to continue.");
+                }
+            }
+        }
+        catch (err) {
+            logger.warn(`Request /compact failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            this.compactInFlight = false;
+        }
+    }
+    captureUsageSnapshot(snapshot) {
+        this.lastUsageSnapshot = {
+            ...snapshot,
+            capturedAtMs: Date.now(),
+        };
+        saveUsageSnapshot(snapshot, this.mode);
+    }
+    /**
+     * Update the usage snapshot after the SDK performs mid-query auto-compaction.
+     * Uses `pre_tokens` (the post-compaction token count) and the last known
+     * context window to compute an accurate `usedPct`, preventing the post-query
+     * `maybeCompactByTokens` from triggering a redundant compaction.
+     */
+    capturePostCompactionSnapshot(postCompactionTokens) {
+        const contextWindow = this.lastUsageSnapshot?.contextWindow ?? 0;
+        if (contextWindow <= 0 || postCompactionTokens < 0) {
+            this.lastUsageSnapshot = null;
+            return;
+        }
+        this.captureUsageSnapshot({
+            usedInputTokens: postCompactionTokens,
+            contextWindow,
+            usedPct: postCompactionTokens / contextWindow,
+        });
+    }
+    async maybeCompactByTokens(options) {
+        const usedPctThreshold = options?.usedPctThreshold ?? COMPACT_USED_PCT_THRESHOLD;
+        const cooldownMs = options?.cooldownMs ?? 10 * 60 * 1000;
+        const snap = this.lastUsageSnapshot;
+        if (!snap) {
+            logger.debug("[compact] skip: no usage snapshot yet");
+            return;
+        }
+        const nowMs = Date.now();
+        const sinceLastCompactMs = nowMs - this.lastCompactRequestAtMs;
+        if (sinceLastCompactMs <= cooldownMs) {
+            logger.debug(`[compact] skip: cooldown active sinceLast=${sinceLastCompactMs}ms cooldown=${cooldownMs}ms (usedPct=${(snap.usedPct * 100).toFixed(1)}%)`);
+            return;
+        }
+        if (this.compactInFlight) {
+            logger.debug("[compact] skip: compaction already in flight");
+            return;
+        }
+        const snapshotAgeMs = nowMs - snap.capturedAtMs;
+        logger.debug(`[compact] check: usedPct=${(snap.usedPct * 100).toFixed(1)}% threshold=${(usedPctThreshold * 100).toFixed(1)}% used=${snap.usedInputTokens} window=${snap.contextWindow} snapshotAge=${snapshotAgeMs}ms`);
+        if (snap.contextWindow > 0 && snap.usedPct >= usedPctThreshold) {
+            this.lastCompactRequestAtMs = nowMs;
+            logger.system(`Context usage ${(snap.usedPct * 100).toFixed(1)}% (used=${snap.usedInputTokens}, window=${snap.contextWindow}); requesting /compact`);
+            await this.requestCompaction();
+        }
+        else {
+            logger.debug(`[compact] skip: under threshold (usedPct=${(snap.usedPct * 100).toFixed(1)}% threshold=${(usedPctThreshold * 100).toFixed(1)}%)`);
+        }
+    }
+    getTranscriptPath() {
+        return this.transcriptPath;
+    }
+    getUsageSnapshot() {
+        return this.lastUsageSnapshot ? { ...this.lastUsageSnapshot } : null;
+    }
+    /** Returns the live Query object, or null if no query is active. */
+    getCurrentQuery() {
+        return this.currentQuery;
+    }
+    /** Replace the full set of dynamic MCP servers (used when loading from disk). */
+    setDynamicMcpServers(servers) {
+        this.dynamicMcpServers = { ...servers };
+    }
+    /** Get the current dynamic MCP servers record. */
+    getDynamicMcpServers() {
+        return { ...this.dynamicMcpServers };
+    }
+}
+//# sourceMappingURL=session.js.map