@fleetagent/pi-coding-agent 0.0.1

package/dist/core/pi-agent.js

@@ -0,0 +1,655 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Agent } from "@fleetagent/pi-agent-core";
+import { clampThinkingLevel, streamSimple } from "@fleetagent/pi-ai";
+import chalk from "chalk";
+import { getAgentDir } from "../config.js";
+import { InteractiveMode, runPrintMode, runRpcMode } from "../modes/index.js";
+import { stopThemeWatcher } from "../modes/interactive/theme/theme.js";
+import { AgentSession } from "./agent-session.js";
+import { formatNoModelsAvailableMessage } from "./auth-guidance.js";
+import { AuthStorage } from "./auth-storage.js";
+import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { emitSessionShutdownEvent } from "./extensions/runner.js";
+import { convertToLlm } from "./messages.js";
+import { ModelRegistry } from "./model-registry.js";
+import { findInitialModel } from "./model-resolver.js";
+import { restoreStdout, takeOverStdout } from "./output-guard.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { assertSessionCwdExists } from "./session-cwd.js";
+import { getDefaultSessionDir, LocalSessionManager, } from "./session-manager.js";
+import { SettingsManager } from "./settings-manager.js";
+import { isInstallTelemetryEnabled } from "./telemetry.js";
+import { printTimings, time } from "./timings.js";
+export class SessionImportFileNotFoundError extends Error {
+    filePath;
+    constructor(filePath) {
+        super(`File not found: ${filePath}`);
+        this.name = "SessionImportFileNotFoundError";
+        this.filePath = filePath;
+    }
+}
+function extractUserMessageText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("");
+}
+function getAttributionHeaders(model, settingsManager) {
+    if (!isInstallTelemetryEnabled(settingsManager)) {
+        return undefined;
+    }
+    if (model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai")) {
+        return {
+            "HTTP-Referer": "https://pi.dev",
+            "X-OpenRouter-Title": "pi",
+            "X-OpenRouter-Categories": "cli-agent",
+        };
+    }
+    if (model.provider === "cloudflare-workers-ai" ||
+        model.provider === "cloudflare-ai-gateway" ||
+        model.baseUrl.includes("api.cloudflare.com") ||
+        model.baseUrl.includes("gateway.ai.cloudflare.com")) {
+        return {
+            "User-Agent": "pi-coding-agent",
+        };
+    }
+    return undefined;
+}
+function applyExtensionFlagValues(resourceLoader, extensionFlagValues) {
+    if (!extensionFlagValues) {
+        return [];
+    }
+    const diagnostics = [];
+    const extensionsResult = resourceLoader.getExtensions();
+    const registeredFlags = new Map();
+    for (const extension of extensionsResult.extensions) {
+        for (const [name, flag] of extension.flags) {
+            registeredFlags.set(name, { type: flag.type });
+        }
+    }
+    const unknownFlags = [];
+    for (const [name, value] of extensionFlagValues) {
+        const flag = registeredFlags.get(name);
+        if (!flag) {
+            unknownFlags.push(name);
+            continue;
+        }
+        if (flag.type === "boolean") {
+            extensionsResult.runtime.flagValues.set(name, true);
+            continue;
+        }
+        if (typeof value === "string") {
+            extensionsResult.runtime.flagValues.set(name, value);
+            continue;
+        }
+        diagnostics.push({
+            type: "error",
+            message: `Extension flag "--${name}" requires a value`,
+        });
+    }
+    if (unknownFlags.length > 0) {
+        diagnostics.push({
+            type: "error",
+            message: `Unknown option${unknownFlags.length === 1 ? "" : "s"}: ${unknownFlags.map((name) => `--${name}`).join(", ")}`,
+        });
+    }
+    return diagnostics;
+}
+/**
+ * Application-level composition root for pi's coding agent runtime.
+ *
+ * PiAgent owns common app services, the session lifecycle backend, and the
+ * current active AgentSession. Conversation behavior stays in AgentSession;
+ * session lifecycle/discovery stays in SessionManager implementations.
+ */
+export class PiAgent {
+    initialCwd;
+    agentDir;
+    sessionManager;
+    authStorage;
+    options;
+    _mode;
+    _session;
+    _services;
+    _diagnostics = [];
+    _modelFallbackMessage;
+    rebindSession;
+    beforeSessionInvalidate;
+    constructor(options, resolved) {
+        this.options = options;
+        this._mode = options.mode ?? "embedded";
+        this.initialCwd = resolved.cwd;
+        this.agentDir = resolved.agentDir;
+        this.sessionManager = resolved.sessionManager;
+        this.authStorage = resolved.authStorage;
+    }
+    static setupStdio(options) {
+        if (options.mode !== "embedded" && options.mode !== "interactive") {
+            takeOverStdout();
+        }
+    }
+    static async create(options = {}) {
+        const cwd = options.cwd ?? process.cwd();
+        const agentDir = options.agentDir ?? getAgentDir();
+        const sessionManager = options.sessionManager ?? new LocalSessionManager({ cwd, sessionDir: getDefaultSessionDir(cwd, agentDir) });
+        const authStorage = options.authStorage ?? AuthStorage.create(join(agentDir, "auth.json"));
+        return new PiAgent(options, { cwd, agentDir, sessionManager, authStorage });
+    }
+    get mode() {
+        return this._mode;
+    }
+    get cwd() {
+        return this._services?.cwd ?? this.initialCwd;
+    }
+    async readPipedStdin() {
+        if (this._mode === "embedded" || this._mode === "rpc" || process.stdin.isTTY) {
+            return undefined;
+        }
+        const stdinContent = await new Promise((resolve) => {
+            let data = "";
+            process.stdin.setEncoding("utf8");
+            process.stdin.on("data", (chunk) => {
+                data += chunk;
+            });
+            process.stdin.on("end", () => {
+                resolve(data.trim() || undefined);
+            });
+            process.stdin.resume();
+        });
+        if (stdinContent !== undefined && this._mode === "interactive") {
+            this._mode = "print";
+        }
+        return stdinContent;
+    }
+    async createServices(cwd) {
+        const settingsManager = this.options.settingsManager ?? SettingsManager.create(cwd, this.agentDir);
+        const modelRegistry = this.options.modelRegistry ?? ModelRegistry.create(this.authStorage, join(this.agentDir, "models.json"));
+        const resourceLoader = this.options.resourceLoader ??
+            new DefaultResourceLoader({
+                ...(this.options.resourceLoaderOptions ?? {}),
+                cwd,
+                agentDir: this.agentDir,
+                settingsManager,
+            });
+        await resourceLoader.reload();
+        const diagnostics = [];
+        const extensionsResult = resourceLoader.getExtensions();
+        for (const { name, config, extensionPath } of extensionsResult.runtime.pendingProviderRegistrations) {
+            try {
+                modelRegistry.registerProvider(name, config);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                diagnostics.push({
+                    type: "error",
+                    message: `Extension "${extensionPath}" error: ${message}`,
+                });
+            }
+        }
+        extensionsResult.runtime.pendingProviderRegistrations = [];
+        diagnostics.push(...applyExtensionFlagValues(resourceLoader, this.options.extensionFlagValues));
+        return {
+            cwd,
+            agentDir: this.agentDir,
+            authStorage: this.authStorage,
+            settingsManager,
+            modelRegistry,
+            resourceLoader,
+            diagnostics,
+        };
+    }
+    async buildAgentSession(activeSession, sessionStartEvent) {
+        const services = await this.createServices(activeSession.getCwd());
+        const diagnostics = [
+            ...services.diagnostics,
+            ...services.resourceLoader.getExtensions().errors.map(({ path, error }) => ({
+                type: "error",
+                message: `Failed to load extension "${path}": ${error}`,
+            })),
+        ];
+        const resolvedOptions = (await this.options.resolveSessionOptions?.({ services, session: activeSession, sessionStartEvent })) ?? {};
+        diagnostics.push(...(resolvedOptions.diagnostics ?? []));
+        const sessionOptions = {
+            model: resolvedOptions.model ?? this.options.model,
+            thinkingLevel: resolvedOptions.thinkingLevel ?? this.options.thinkingLevel,
+            scopedModels: resolvedOptions.scopedModels ?? this.options.scopedModels,
+            tools: resolvedOptions.tools ?? this.options.tools,
+            noTools: resolvedOptions.noTools ?? this.options.noTools,
+            customTools: resolvedOptions.customTools ?? this.options.customTools,
+        };
+        const existingSession = activeSession.buildSessionContext();
+        const hasExistingSession = existingSession.messages.length > 0;
+        const hasThinkingEntry = activeSession.getBranch().some((entry) => entry.type === "thinking_level_change");
+        let model = sessionOptions.model;
+        let modelFallbackMessage;
+        if (model) {
+            model = services.modelRegistry.find(model.provider, model.id) ?? model;
+        }
+        if (!model && hasExistingSession && existingSession.model) {
+            const restoredModel = services.modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
+            if (restoredModel && services.modelRegistry.hasConfiguredAuth(restoredModel)) {
+                model = restoredModel;
+            }
+            if (!model) {
+                modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
+            }
+        }
+        if (!model) {
+            const result = await findInitialModel({
+                scopedModels: [],
+                isContinuing: hasExistingSession,
+                defaultProvider: services.settingsManager.getDefaultProvider(),
+                defaultModelId: services.settingsManager.getDefaultModel(),
+                defaultThinkingLevel: services.settingsManager.getDefaultThinkingLevel(),
+                modelRegistry: services.modelRegistry,
+            });
+            model = result.model;
+            if (!model) {
+                modelFallbackMessage = formatNoModelsAvailableMessage();
+            }
+            else if (modelFallbackMessage) {
+                modelFallbackMessage += `. Using ${model.provider}/${model.id}`;
+            }
+        }
+        let thinkingLevel = sessionOptions.thinkingLevel;
+        if (thinkingLevel === undefined && hasExistingSession) {
+            thinkingLevel = hasThinkingEntry
+                ? existingSession.thinkingLevel
+                : (services.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL);
+        }
+        if (thinkingLevel === undefined) {
+            thinkingLevel = services.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+        }
+        thinkingLevel = model ? clampThinkingLevel(model, thinkingLevel) : "off";
+        const defaultActiveToolNames = ["read", "bash", "edit", "write"];
+        const allowedToolNames = sessionOptions.tools ?? (sessionOptions.noTools === "all" ? [] : undefined);
+        const initialActiveToolNames = sessionOptions.tools
+            ? [...sessionOptions.tools]
+            : sessionOptions.noTools
+                ? []
+                : defaultActiveToolNames;
+        const extensionRunnerRef = {};
+        const convertToLlmWithBlockImages = (messages) => {
+            const converted = convertToLlm(messages);
+            if (!services.settingsManager.getBlockImages()) {
+                return converted;
+            }
+            return converted.map((msg) => {
+                if (msg.role === "user" || msg.role === "toolResult") {
+                    const content = msg.content;
+                    if (Array.isArray(content)) {
+                        const hasImages = content.some((c) => c.type === "image");
+                        if (hasImages) {
+                            const filteredContent = content
+                                .map((c) => c.type === "image" ? { type: "text", text: "Image reading is disabled." } : c)
+                                .filter((c, i, arr) => !(c.type === "text" &&
+                                c.text === "Image reading is disabled." &&
+                                i > 0 &&
+                                arr[i - 1].type === "text" &&
+                                arr[i - 1].text === "Image reading is disabled."));
+                            return { ...msg, content: filteredContent };
+                        }
+                    }
+                }
+                return msg;
+            });
+        };
+        const agent = new Agent({
+            initialState: {
+                systemPrompt: "",
+                model,
+                thinkingLevel,
+                tools: [],
+            },
+            convertToLlm: convertToLlmWithBlockImages,
+            streamFn: async (model, context, options) => {
+                const auth = await services.modelRegistry.getApiKeyAndHeaders(model);
+                if (!auth.ok) {
+                    throw new Error(auth.error);
+                }
+                const providerRetrySettings = services.settingsManager.getProviderRetrySettings();
+                const attributionHeaders = getAttributionHeaders(model, services.settingsManager);
+                return streamSimple(model, context, {
+                    ...options,
+                    apiKey: auth.apiKey,
+                    timeoutMs: options?.timeoutMs ?? providerRetrySettings.timeoutMs,
+                    maxRetries: options?.maxRetries ?? providerRetrySettings.maxRetries,
+                    maxRetryDelayMs: options?.maxRetryDelayMs ?? providerRetrySettings.maxRetryDelayMs,
+                    headers: attributionHeaders || auth.headers || options?.headers
+                        ? { ...attributionHeaders, ...auth.headers, ...options?.headers }
+                        : undefined,
+                });
+            },
+            onPayload: async (payload) => {
+                const runner = extensionRunnerRef.current;
+                if (!runner?.hasHandlers("before_provider_request")) {
+                    return payload;
+                }
+                return runner.emitBeforeProviderRequest(payload);
+            },
+            onResponse: async (response) => {
+                const runner = extensionRunnerRef.current;
+                if (!runner?.hasHandlers("after_provider_response")) {
+                    return;
+                }
+                await runner.emit({
+                    type: "after_provider_response",
+                    status: response.status,
+                    headers: response.headers,
+                });
+            },
+            sessionId: activeSession.getSessionId(),
+            transformContext: async (messages) => {
+                const runner = extensionRunnerRef.current;
+                return runner ? runner.emitContext(messages) : messages;
+            },
+            steeringMode: services.settingsManager.getSteeringMode(),
+            followUpMode: services.settingsManager.getFollowUpMode(),
+            transport: services.settingsManager.getTransport(),
+            thinkingBudgets: services.settingsManager.getThinkingBudgets(),
+            maxRetryDelayMs: services.settingsManager.getProviderRetrySettings().maxRetryDelayMs,
+        });
+        if (hasExistingSession) {
+            agent.state.messages = existingSession.messages;
+            if (!hasThinkingEntry) {
+                activeSession.appendThinkingLevelChange(thinkingLevel);
+            }
+        }
+        else {
+            if (model) {
+                activeSession.appendModelChange(model.provider, model.id);
+            }
+            activeSession.appendThinkingLevelChange(thinkingLevel);
+        }
+        return {
+            session: new AgentSession({
+                agent,
+                session: activeSession,
+                settingsManager: services.settingsManager,
+                cwd: services.cwd,
+                scopedModels: sessionOptions.scopedModels,
+                resourceLoader: services.resourceLoader,
+                customTools: sessionOptions.customTools,
+                modelRegistry: services.modelRegistry,
+                initialActiveToolNames,
+                allowedToolNames,
+                extensionRunnerRef,
+                sessionStartEvent,
+            }),
+            services,
+            diagnostics,
+            modelFallbackMessage,
+        };
+    }
+    apply(result) {
+        this._session = result.session;
+        this._services = result.services;
+        this._diagnostics = result.diagnostics;
+        this._modelFallbackMessage = result.modelFallbackMessage;
+    }
+    async createAgentSession(options = {}) {
+        const initialSession = options.session ?? (await this.sessionManager.create());
+        assertSessionCwdExists(initialSession, initialSession.getCwd());
+        this.apply(await this.buildAgentSession(initialSession, options.sessionStartEvent));
+        return this.session;
+    }
+    get runtime() {
+        if (!this._session) {
+            throw new Error("PiAgent session has not been created. Call createAgentSession() first.");
+        }
+        return this;
+    }
+    get services() {
+        if (!this._services) {
+            throw new Error("PiAgent services have not been created. Call createAgentSession() first.");
+        }
+        return this._services;
+    }
+    get session() {
+        if (!this._session) {
+            throw new Error("PiAgent session has not been created. Call createAgentSession() first.");
+        }
+        return this._session;
+    }
+    get modelFallbackMessage() {
+        return this._modelFallbackMessage;
+    }
+    get settingsManager() {
+        return this.services.settingsManager;
+    }
+    get modelRegistry() {
+        return this.services.modelRegistry;
+    }
+    get resourceLoader() {
+        return this.services.resourceLoader;
+    }
+    get diagnostics() {
+        return this._diagnostics;
+    }
+    get currentCwd() {
+        return this.services.cwd;
+    }
+    setRebindSession(rebindSession) {
+        this.rebindSession = rebindSession;
+    }
+    setBeforeSessionInvalidate(beforeSessionInvalidate) {
+        this.beforeSessionInvalidate = beforeSessionInvalidate;
+    }
+    async emitBeforeSwitch(reason, targetSessionFile) {
+        const runner = this.session.extensionRunner;
+        if (!runner.hasHandlers("session_before_switch")) {
+            return { cancelled: false };
+        }
+        const result = await runner.emit({
+            type: "session_before_switch",
+            reason,
+            targetSessionFile,
+        });
+        return { cancelled: result?.cancel === true };
+    }
+    async emitBeforeFork(entryId, options) {
+        const runner = this.session.extensionRunner;
+        if (!runner.hasHandlers("session_before_fork")) {
+            return { cancelled: false };
+        }
+        const result = await runner.emit({
+            type: "session_before_fork",
+            entryId,
+            ...options,
+        });
+        return { cancelled: result?.cancel === true };
+    }
+    async flushActiveSession() {
+        const flushPendingSync = this.session.session.flushPendingSync;
+        if (flushPendingSync) {
+            await flushPendingSync.call(this.session.session);
+        }
+    }
+    async teardownCurrent(reason, targetSessionFile) {
+        await emitSessionShutdownEvent(this.session.extensionRunner, {
+            type: "session_shutdown",
+            reason,
+            targetSessionFile,
+        });
+        await this.flushActiveSession();
+        this.beforeSessionInvalidate?.();
+        this.session.dispose();
+    }
+    async finishSessionReplacement(withSession) {
+        if (this.rebindSession) {
+            await this.rebindSession(this.session);
+        }
+        if (withSession) {
+            await withSession(this.session.createReplacedSessionContext());
+        }
+    }
+    async switchSession(sessionPath, options) {
+        const beforeResult = await this.emitBeforeSwitch("resume", sessionPath);
+        if (beforeResult.cancelled) {
+            return beforeResult;
+        }
+        const previousSessionFile = this.session.sessionFile;
+        const nextSession = await this.sessionManager.openReference(sessionPath, { cwdOverride: options?.cwdOverride });
+        assertSessionCwdExists(nextSession, this.services.cwd);
+        await this.teardownCurrent("resume", nextSession.getSessionReference());
+        this.apply(await this.buildAgentSession(nextSession, { type: "session_start", reason: "resume", previousSessionFile }));
+        await this.finishSessionReplacement(options?.withSession);
+        return { cancelled: false };
+    }
+    async newSession(options) {
+        const beforeResult = await this.emitBeforeSwitch("new");
+        if (beforeResult.cancelled) {
+            return beforeResult;
+        }
+        const previousSessionFile = this.session.sessionFile;
+        const nextSession = await this.sessionManager.create({ id: options?.id, parentSession: options?.parentSession });
+        await this.teardownCurrent("new", nextSession.getSessionReference());
+        this.apply(await this.buildAgentSession(nextSession, { type: "session_start", reason: "new", previousSessionFile }));
+        if (options?.setup) {
+            await options.setup(this.session.session);
+            this.session.agent.state.messages = this.session.session.buildSessionContext().messages;
+        }
+        await this.finishSessionReplacement(options?.withSession);
+        return { cancelled: false };
+    }
+    async fork(entryId, options) {
+        const position = options?.position ?? "before";
+        const beforeResult = await this.emitBeforeFork(entryId, { position });
+        if (beforeResult.cancelled) {
+            return { cancelled: true };
+        }
+        let targetLeafId;
+        let selectedText;
+        const selectedEntry = this.session.session.getEntry(entryId);
+        if (!selectedEntry) {
+            throw new Error("Invalid entry ID for forking");
+        }
+        if (position === "at") {
+            targetLeafId = selectedEntry.id;
+        }
+        else {
+            if (selectedEntry.type !== "message" || selectedEntry.message.role !== "user") {
+                throw new Error("Invalid entry ID for forking");
+            }
+            targetLeafId = selectedEntry.parentId;
+            selectedText = extractUserMessageText(selectedEntry.message.content);
+        }
+        const previousSessionFile = this.session.sessionFile;
+        const nextSession = await this.sessionManager.forkSession(this.session.session, targetLeafId);
+        await this.teardownCurrent("fork", nextSession.getSessionReference());
+        this.apply(await this.buildAgentSession(nextSession, { type: "session_start", reason: "fork", previousSessionFile }));
+        await this.finishSessionReplacement(options?.withSession);
+        return { cancelled: false, selectedText };
+    }
+    async importFromJsonl(inputPath, cwdOverride) {
+        const resolvedPath = resolve(inputPath);
+        if (!existsSync(resolvedPath)) {
+            throw new SessionImportFileNotFoundError(resolvedPath);
+        }
+        const beforeResult = await this.emitBeforeSwitch("resume", resolvedPath);
+        if (beforeResult.cancelled) {
+            return beforeResult;
+        }
+        const previousSessionFile = this.session.sessionFile;
+        const nextSession = await this.sessionManager.importJsonl(resolvedPath, { cwdOverride: cwdOverride });
+        assertSessionCwdExists(nextSession, this.services.cwd);
+        await this.teardownCurrent("resume", nextSession.getSessionReference());
+        this.apply(await this.buildAgentSession(nextSession, { type: "session_start", reason: "resume", previousSessionFile }));
+        await this.finishSessionReplacement();
+        return { cancelled: false };
+    }
+    async runMode(options = {}) {
+        const mode = options.mode ?? this._mode;
+        if (mode === "embedded") {
+            return;
+        }
+        if (mode !== "interactive" && !this.session.model) {
+            console.error(chalk.red(formatNoModelsAvailableMessage()));
+            process.exit(1);
+        }
+        if (options.startupBenchmark && mode !== "interactive") {
+            console.error(chalk.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode"));
+            process.exit(1);
+        }
+        if (mode === "rpc") {
+            printTimings();
+            await runRpcMode(this);
+            return;
+        }
+        if (mode === "interactive") {
+            const interactiveMode = new InteractiveMode(this, {
+                migratedProviders: options.migratedProviders,
+                modelFallbackMessage: this.modelFallbackMessage,
+                initialMessage: options.initialMessage,
+                initialImages: options.initialImages,
+                initialMessages: options.initialMessages,
+                verbose: options.verbose,
+            });
+            if (options.startupBenchmark) {
+                await interactiveMode.init();
+                time("interactiveMode.init");
+                printTimings();
+                interactiveMode.stop();
+                stopThemeWatcher();
+                if (process.stdout.writableLength > 0) {
+                    await new Promise((resolve) => process.stdout.once("drain", resolve));
+                }
+                if (process.stderr.writableLength > 0) {
+                    await new Promise((resolve) => process.stderr.once("drain", resolve));
+                }
+                return;
+            }
+            printTimings();
+            await interactiveMode.run();
+            return;
+        }
+        printTimings();
+        const exitCode = await runPrintMode(this, {
+            mode: mode === "json" ? "json" : "text",
+            messages: options.initialMessages,
+            initialMessage: options.initialMessage,
+            initialImages: options.initialImages,
+        });
+        stopThemeWatcher();
+        restoreStdout();
+        if (exitCode !== 0) {
+            process.exitCode = exitCode;
+        }
+    }
+    createSession() {
+        return this.sessionManager.create();
+    }
+    openSessionReference(reference) {
+        return this.sessionManager.openReference(reference);
+    }
+    continueRecentSession() {
+        return this.sessionManager.continueRecent();
+    }
+    forkSessionFrom(reference) {
+        return this.sessionManager.forkFrom(reference);
+    }
+    async listSessions() {
+        return this.sessionManager.list();
+    }
+    async listAllSessions() {
+        return this.sessionManager.listAll();
+    }
+    async dispose() {
+        if (!this._session) {
+            return;
+        }
+        await emitSessionShutdownEvent(this.session.extensionRunner, {
+            type: "session_shutdown",
+            reason: "quit",
+        });
+        await this.flushActiveSession();
+        this.beforeSessionInvalidate?.();
+        this.session.dispose();
+        this._session = undefined;
+    }
+}
+//# sourceMappingURL=pi-agent.js.map