@peakflo/agent-harness 0.0.0-stage → 0.2.2-rc.1

package/dist/adapters/opencode-config.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Utilities for reading OpenCode configuration and auth files,
+ * and merging auth keys into provider configs so custom providers
+ * (e.g. routerAI) are correctly authenticated when the server starts.
+ *
+ * The OpenCode server reads `opencode.json` for provider definitions but
+ * does NOT automatically merge API keys from `auth.json` into custom
+ * config-based providers.  When we spawn the server we pass the merged
+ * config via `OPENCODE_CONFIG_CONTENT` so every provider has its key.
+ */
+import type { ModelGatewayConfigSource } from './model-gateway';
+export interface OpencodeAuthEntry {
+    type: string;
+    key?: string;
+    refresh?: string;
+    access?: string;
+    expires?: number;
+}
+/**
+ * Reads the user's `~/.config/opencode/opencode.json`.
+ * Returns the parsed object or an empty object on any failure.
+ */
+export declare function readOpencodeConfig(): Record<string, unknown>;
+/**
+ * Reads the user's `~/.local/share/opencode/auth.json`.
+ * Returns a map of provider-id -> auth entry, or empty on failure.
+ */
+export declare function readOpencodeAuth(): Record<string, OpencodeAuthEntry>;
+/**
+ * Builds a complete config object suitable for `OPENCODE_CONFIG_CONTENT`.
+ *
+ * 1. Reads the user's `opencode.json`
+ * 2. Reads `auth.json`
+ * 3. For every provider defined in the config that has a matching auth entry
+ *    but no `apiKey` in its options, injects the key from auth.json.
+ * 4. Merges any `extraConfig` on top (e.g. plugin paths from the adapter).
+ *
+ * This ensures custom providers like routerAI — whose API key lives only
+ * in auth.json — are included by the server in its `/config/providers` response.
+ */
+export declare function buildMergedOpencodeConfig(extraConfig?: Record<string, unknown>, gateway?: ModelGatewayConfigSource): Record<string, unknown>;

package/dist/adapters/opencode-config.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Utilities for reading OpenCode configuration and auth files,
+ * and merging auth keys into provider configs so custom providers
+ * (e.g. routerAI) are correctly authenticated when the server starts.
+ *
+ * The OpenCode server reads `opencode.json` for provider definitions but
+ * does NOT automatically merge API keys from `auth.json` into custom
+ * config-based providers.  When we spawn the server we pass the merged
+ * config via `OPENCODE_CONFIG_CONTENT` so every provider has its key.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOpencodeConfig = readOpencodeConfig;
+exports.readOpencodeAuth = readOpencodeAuth;
+exports.buildMergedOpencodeConfig = buildMergedOpencodeConfig;
+/**
+ * Extracted verbatim from 20x `src/main/utils/opencode-config.ts`.
+ * CHANGED: the enterprise-AI-gateway dependency is now injected.
+ * `readEnterpriseAiGatewayConfig(db)` (which lives in an Electron-only module
+ * because it decrypts via `safeStorage`) is replaced by
+ * `gateway?.readModelGatewayConfig() ?? null`, and the second parameter of
+ * `buildMergedOpencodeConfig` changed from `Pick<DatabaseManager,'getSetting'>`
+ * to `ModelGatewayConfigSource`. All surrounding logic is untouched.
+ * Source formatting (no semicolons) preserved.
+ */
+const fs_1 = require("fs");
+const url_1 = require("url");
+const path_1 = require("path");
+const os_1 = require("os");
+const model_gateway_1 = require("./model-gateway");
+/** Paths used by the OpenCode CLI to store config & auth. */
+const OPENCODE_CONFIG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.config', 'opencode', 'opencode.json');
+const OPENCODE_AUTH_PATH = (0, path_1.join)((0, os_1.homedir)(), '.local', 'share', 'opencode', 'auth.json');
+/**
+ * Reads the user's `~/.config/opencode/opencode.json`.
+ * Returns the parsed object or an empty object on any failure.
+ */
+function readOpencodeConfig() {
+    try {
+        if ((0, fs_1.existsSync)(OPENCODE_CONFIG_PATH)) {
+            return JSON.parse((0, fs_1.readFileSync)(OPENCODE_CONFIG_PATH, 'utf-8'));
+        }
+    }
+    catch (e) {
+        console.log('[opencode-config] Could not read opencode.json:', e);
+    }
+    return {};
+}
+/**
+ * Reads the user's `~/.local/share/opencode/auth.json`.
+ * Returns a map of provider-id -> auth entry, or empty on failure.
+ */
+function readOpencodeAuth() {
+    try {
+        if ((0, fs_1.existsSync)(OPENCODE_AUTH_PATH)) {
+            return JSON.parse((0, fs_1.readFileSync)(OPENCODE_AUTH_PATH, 'utf-8'));
+        }
+    }
+    catch (e) {
+        console.log('[opencode-config] Could not read auth.json:', e);
+    }
+    return {};
+}
+function is20xRuntimePluginPath(value) {
+    return typeof value === 'string' &&
+        (value.endsWith('/.opencode/plugins/20x-tilldone.js') ||
+            value.endsWith('/.opencode/plugins/20x-secret-injector.js'));
+}
+function pluginPathExists(pluginPath) {
+    try {
+        return (0, fs_1.existsSync)(pluginPath.startsWith('file://') ? (0, url_1.fileURLToPath)(pluginPath) : pluginPath);
+    }
+    catch {
+        return false;
+    }
+}
+function removeMissing20xRuntimePlugins(config) {
+    if (!Array.isArray(config.plugin))
+        return;
+    const plugins = config.plugin.filter((pluginPath) => {
+        if (!is20xRuntimePluginPath(pluginPath))
+            return true;
+        return pluginPathExists(pluginPath);
+    });
+    if (plugins.length > 0) {
+        config.plugin = plugins;
+    }
+    else {
+        delete config.plugin;
+    }
+}
+/**
+ * Builds a complete config object suitable for `OPENCODE_CONFIG_CONTENT`.
+ *
+ * 1. Reads the user's `opencode.json`
+ * 2. Reads `auth.json`
+ * 3. For every provider defined in the config that has a matching auth entry
+ *    but no `apiKey` in its options, injects the key from auth.json.
+ * 4. Merges any `extraConfig` on top (e.g. plugin paths from the adapter).
+ *
+ * This ensures custom providers like routerAI — whose API key lives only
+ * in auth.json — are included by the server in its `/config/providers` response.
+ */
+function buildMergedOpencodeConfig(extraConfig, gateway) {
+    const config = readOpencodeConfig();
+    const auth = readOpencodeAuth();
+    removeMissing20xRuntimePlugins(config);
+    // Inject auth keys into providers that lack an inline apiKey
+    const providers = config.provider;
+    if (providers && typeof providers === 'object') {
+        for (const [providerId, providerCfg] of Object.entries(providers)) {
+            if (!providerCfg || typeof providerCfg !== 'object')
+                continue;
+            const options = (providerCfg.options ?? {});
+            // Skip if the provider already has an apiKey in its options
+            if (options.apiKey)
+                continue;
+            // Check auth.json for a matching key
+            const authEntry = auth[providerId];
+            if (authEntry?.key) {
+                providerCfg.options = { ...options, apiKey: authEntry.key };
+                console.log(`[opencode-config] Injected API key for provider "${providerId}" from auth.json`);
+            }
+        }
+    }
+    const enterpriseAiGatewayConfig = gateway?.readModelGatewayConfig() ?? null;
+    if (enterpriseAiGatewayConfig) {
+        const existingProviders = config.provider ?? {};
+        config.provider = {
+            ...existingProviders,
+            ...(0, model_gateway_1.buildEnterpriseAiGatewayProviderConfig)(enterpriseAiGatewayConfig)
+        };
+    }
+    // NOTE: OpenCode's `external_directory` permission defaults to "ask".
+    // Permissions are now surfaced in the 20x UI via the OpenCode adapter's
+    // SSE event subscription and getPendingApproval()/respondToApproval()
+    // methods — no need to auto-allow here.
+    // Merge extra config (e.g. plugin paths) on top
+    if (extraConfig) {
+        for (const [key, value] of Object.entries(extraConfig)) {
+            if (value !== undefined) {
+                config[key] = value;
+            }
+        }
+    }
+    return config;
+}

package/dist/adapters/opencode-server-policy.d.ts

@@ -0,0 +1,82 @@
+import { RunnerRuntime } from '../types';
+/**
+ * The well-known port a DESKTOP opencode server listens on.
+ *
+ * It is well known precisely because a human may already be using it. That is
+ * why it belongs to exactly one policy — `shared` — and why nothing in this
+ * module ever kills a process bound to it.
+ */
+export declare const SHARED_SERVER_URL = "http://localhost:4096";
+/**
+ * WHO OWNS THE OPENCODE SERVER THIS RUNNER TALKS TO.
+ *
+ * This is the ONE place that encodes the decision, deliberately mirroring
+ * `createCredentialStore` in `credential-store.ts`: a property of the RUNTIME,
+ * resolved once, so a future runtime has a single line to change and cannot
+ * silently inherit the wrong policy.
+ *
+ * WHY THIS EXISTS AT ALL. Until now every runtime went to
+ * `http://localhost:4096` and ADOPTED whatever answered. On a developer's
+ * laptop that is the human's own long-lived server: its session lifetime, its
+ * pruning and its state are outside the harness's control, and the agent's
+ * sessions share a pool with the human's own work. Measured on the owner's
+ * machine, that server had been up for four days and held 100 sessions from
+ * every use of opencode on that machine.
+ *
+ *   - `sandbox`     -> owned. The machine exists only to run this harness.
+ *   - `self-hosted` -> owned. A customer VM the harness was installed on; the
+ *                      customer may well also use opencode there, and taking
+ *                      over their server would be exactly the same trespass.
+ *   - `desktop`     -> shared. 20x is a DIFFERENT case: the user may
+ *                      legitimately want one opencode server behind both the
+ *                      desktop app and the agent, and that behaviour ships
+ *                      today. It is not regressed here.
+ */
+export type OpencodeServerPolicy = {
+    readonly kind: 'owned';
+    /**
+     * opencode's state directory, honoured through `XDG_DATA_HOME`.
+     *
+     * MEASURED, not assumed: two opencode servers pointed at ONE state
+     * directory create sessions that the other can immediately read, and a
+     * session created before a server is killed is still readable after a
+     * fresh server starts on the same directory. So the unit of resumability
+     * is the STATE DIRECTORY, not the process and not the port.
+     */
+    readonly stateDir: string;
+} | {
+    readonly kind: 'shared';
+    readonly url: string;
+};
+export declare function createOpencodeServerPolicy(runtime: RunnerRuntime, workspaceRoot: string): OpencodeServerPolicy;
+/**
+ * The identity of the backend instance that can honour a checkpoint.
+ *
+ * WHY A CHECKPOINT NEEDS ONE. `coding_agent_sessions.backend_name` already
+ * records that "a checkpoint is only meaningful to the backend that created
+ * it" — but it stops one level short. An opencode session id is not meaningful
+ * to *opencode*; it is meaningful to the opencode STATE DIRECTORY that minted
+ * it. Handing `ses_...` to a different opencode server is handing it a string.
+ *
+ * This is not hypothetical. On the owner's machine one conversation was leased
+ * alternately to a laptop runner and to a cloud-sandbox runner reached over
+ * ngrok. Each minted a session on its own opencode, the control plane stored
+ * the id unqualified, and the next turn on the other machine was handed an id
+ * its server had never issued — so it logged "Session no longer exists on
+ * server" and replayed the entire history. Every turn. Silently.
+ *
+ * The id is a random UUID written once into the state directory, so:
+ *   - two harness processes sharing a state directory agree (which is why
+ *     three successive runner restarts on one laptop DID resume correctly),
+ *   - it survives a harness restart and an opencode restart,
+ *   - and two different machines can never collide.
+ */
+export declare function backendInstanceId(policy: OpencodeServerPolicy): string;
+/**
+ * A free loopback port, asked of the kernel rather than guessed.
+ *
+ * Binding to port 0 and reading back the assignment is the only way to pick a
+ * port without a race against a range someone else also scans, and without
+ * ever landing on a well-known one a human might be using.
+ */
+export declare function ephemeralLoopbackPort(): Promise<number>;

package/dist/adapters/opencode-server-policy.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARED_SERVER_URL = void 0;
+exports.createOpencodeServerPolicy = createOpencodeServerPolicy;
+exports.backendInstanceId = backendInstanceId;
+exports.ephemeralLoopbackPort = ephemeralLoopbackPort;
+const node_crypto_1 = require("node:crypto");
+const node_net_1 = require("node:net");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * The well-known port a DESKTOP opencode server listens on.
+ *
+ * It is well known precisely because a human may already be using it. That is
+ * why it belongs to exactly one policy — `shared` — and why nothing in this
+ * module ever kills a process bound to it.
+ */
+exports.SHARED_SERVER_URL = 'http://localhost:4096';
+function createOpencodeServerPolicy(runtime, workspaceRoot) {
+    if (runtime === 'desktop') {
+        return { kind: 'shared', url: exports.SHARED_SERVER_URL };
+    }
+    /*
+     * NOT inside a session's workspace directory. A session workspace now lives
+     * until the session ends, but backend state has a different owner and must
+     * also survive an explicit workspace wipe.
+     */
+    return { kind: 'owned', stateDir: (0, node_path_1.join)(workspaceRoot, 'opencode-state') };
+}
+/**
+ * One id per state directory per process, so concurrent turns cannot disagree.
+ *
+ * The harness builds a NEW adapter for every turn and may run several turns at
+ * once, so this is called repeatedly and concurrently. Without the cache each
+ * call re-reads the file, and two callers that both miss would both mint.
+ */
+const instanceIdCache = new Map();
+/**
+ * The identity of the backend instance that can honour a checkpoint.
+ *
+ * WHY A CHECKPOINT NEEDS ONE. `coding_agent_sessions.backend_name` already
+ * records that "a checkpoint is only meaningful to the backend that created
+ * it" — but it stops one level short. An opencode session id is not meaningful
+ * to *opencode*; it is meaningful to the opencode STATE DIRECTORY that minted
+ * it. Handing `ses_...` to a different opencode server is handing it a string.
+ *
+ * This is not hypothetical. On the owner's machine one conversation was leased
+ * alternately to a laptop runner and to a cloud-sandbox runner reached over
+ * ngrok. Each minted a session on its own opencode, the control plane stored
+ * the id unqualified, and the next turn on the other machine was handed an id
+ * its server had never issued — so it logged "Session no longer exists on
+ * server" and replayed the entire history. Every turn. Silently.
+ *
+ * The id is a random UUID written once into the state directory, so:
+ *   - two harness processes sharing a state directory agree (which is why
+ *     three successive runner restarts on one laptop DID resume correctly),
+ *   - it survives a harness restart and an opencode restart,
+ *   - and two different machines can never collide.
+ */
+function backendInstanceId(policy) {
+    const dir = policy.kind === 'owned' ? policy.stateDir : sharedStateDirectory();
+    const cached = instanceIdCache.get(dir);
+    if (cached)
+        return cached;
+    const marker = (0, node_path_1.join)(dir, '.pf-backend-instance-id');
+    const readExisting = () => {
+        try {
+            const existing = (0, node_fs_1.readFileSync)(marker, 'utf8').trim();
+            return existing || null;
+        }
+        catch {
+            // Not written yet, or unreadable. Both mean "try to mint".
+            return null;
+        }
+    };
+    const existing = readExisting();
+    if (existing) {
+        instanceIdCache.set(dir, existing);
+        return existing;
+    }
+    /*
+     * MINTED WITH AN EXCLUSIVE CREATE, NOT A PLAIN WRITE.
+     *
+     * Read-then-write is not atomic: two processes sharing a state directory —
+     * two harnesses on one machine, or a harness restarting beside itself — can
+     * both see no file and both write, and the second silently overwrites the
+     * first. They would then disagree about who owns every session in that
+     * directory, which is the very confusion this id exists to prevent.
+     *
+     * `wx` makes the create the arbitration point: exactly one caller wins, and
+     * every loser re-reads and adopts the winner's id.
+     */
+    const minted = (0, node_crypto_1.randomUUID)();
+    try {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true, mode: 0o700 });
+        (0, node_fs_1.writeFileSync)(marker, minted, { flag: 'wx', mode: 0o600 });
+        instanceIdCache.set(dir, minted);
+        return minted;
+    }
+    catch (error) {
+        if (error?.code === 'EEXIST') {
+            // Somebody else won the race. Their id is the directory's id.
+            const winner = readExisting();
+            if (winner) {
+                instanceIdCache.set(dir, winner);
+                return winner;
+            }
+        }
+        /*
+         * A state directory we cannot write is a state directory whose sessions we
+         * cannot trust to be ours. Returning the un-persisted id is correct and
+         * fails SAFE: it matches no stored checkpoint, so the next turn replays
+         * once instead of resuming something that may belong to someone else.
+         *
+         * NOT cached, so a directory that becomes writable later still settles on
+         * one persisted id rather than being stuck on a per-process invention.
+         */
+        return minted;
+    }
+}
+/** Where a SHARED (desktop) opencode server keeps its state. */
+function sharedStateDirectory() {
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    return (0, node_path_1.join)(home, '.local', 'share', 'opencode');
+}
+/**
+ * A free loopback port, asked of the kernel rather than guessed.
+ *
+ * Binding to port 0 and reading back the assignment is the only way to pick a
+ * port without a race against a range someone else also scans, and without
+ * ever landing on a well-known one a human might be using.
+ */
+async function ephemeralLoopbackPort() {
+    return new Promise((resolve, reject) => {
+        const probe = (0, node_net_1.createServer)();
+        probe.unref();
+        probe.on('error', reject);
+        probe.listen(0, '127.0.0.1', () => {
+            const address = probe.address();
+            if (typeof address === 'string' || address === null) {
+                probe.close(() => reject(new Error('Could not read an ephemeral port')));
+                return;
+            }
+            const { port } = address;
+            probe.close(() => resolve(port));
+        });
+    });
+}

package/dist/adapters/pi-adapter.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Pi coding-agent adapter.
+ *
+ * Pi exposes a JSONL RPC protocol over stdin/stdout. The harness keeps one Pi
+ * process per live turn and converts Pi events to the shared adapter shape.
+ */
+import type { CodingAgentAdapter, MessagePart, SessionConfig, SessionMessage, SessionStatus } from './coding-agent-adapter';
+import { type ModelGatewayConfigSource } from './model-gateway';
+/**
+ * Most model providers cap function/tool `name` at 64 characters. Pi forwards
+ * MCP tools as `<server>_<tool>`-style names, so a long MCP server name (e.g.
+ * "[Workflo] Organisation Workspace") plus a long tool name overflows the
+ * limit and the whole turn fails with "name must be at most 64 characters".
+ * Keep server slugs short to leave room for the tool suffix.
+ */
+export declare const MAX_PI_NAME_LENGTH = 64;
+export declare const MAX_PI_MCP_SERVER_SLUG_LENGTH = 24;
+/**
+ * Electron's main macOS executable belongs to the foreground application
+ * bundle. Reusing it as Node makes LaunchServices register every Pi process as
+ * another foreground 20x application, which adds a Dock icon. Electron's
+ * standard Helper.app is an LSUIElement and exposes the same bundled Node
+ * runtime without participating in the Dock.
+ */
+export declare function findPiNodeRuntime(platform: NodeJS.Platform, electronExecutable: string, pathExists?: (path: string) => boolean): string | null;
+/**
+ * Short Pi-side aliases for MCP servers whose display names are too long to
+ * fit the provider 64-char tool-name limit. The alias is only used in the
+ * Pi `--mcp-config` file — display names in settings, docs, and other
+ * backends are untouched.
+ */
+export declare const PI_MCP_SERVER_ALIASES: Record<string, string>;
+export declare function sanitizePiSessionName(taskId: string): string;
+export declare function sanitizePiMcpServerName(name: string, used: Set<string>): string;
+export declare function withProviderNameLimitHint(error: string): string;
+/**
+ * Build the pi-mcp-adapter document used by Peakflo harness sessions.
+ *
+ * Keep MCP servers behind namespace proxy tools (`mcp__<server>`). Direct MCP
+ * tools concatenate the server and tool names; a 24-character server slug and
+ * a 50-character generated workflow tool already produce a 76-character name.
+ * Providers commonly reject the entire request when any tool exceeds 64
+ * characters, before the model can call a tool.
+ */
+export declare function buildPiMcpConfigDocument(servers: NonNullable<SessionConfig['mcpServers']>, onRename?: (name: string, slug: string) => void): Record<string, unknown>;
+export declare class PiAdapter implements CodingAgentAdapter {
+    private modelGateway;
+    private sessions;
+    private piExecutablePath;
+    onDataAvailable?: (sessionId: string) => void;
+    constructor(modelGateway: ModelGatewayConfigSource);
+    private agentDirectory;
+    /** Identity of the Pi session store that can honour native session files. */
+    backendInstanceId(): string;
+    initialize(): Promise<void>;
+    private findPiExecutable;
+    /**
+     * Install or update the Peakflo provider in Pi's normal models file. The key
+     * remains an environment reference; the harness supplies the session-scoped
+     * value only to the child process.
+     */
+    private installPeakfloGateway;
+    private buildMcpConfig;
+    private installPermissionExtension;
+    private processEnv;
+    private buildSkillFiles;
+    /**
+     * Pi's npm launcher uses `#!/usr/bin/env node`. Launching it directly would
+     * therefore make Pi depend on whichever Node happens to be first on the
+     * desktop app's PATH. Recent Pi releases require Node >=22.19 and use zstd
+     * APIs that are absent from older runtimes. On Linux, run the launcher with
+     * Electron's main executable. On macOS, use Electron's LSUIElement helper;
+     * launching the foreground app executable creates another Dock icon for
+     * every Pi session. Both expose the same bundled Node runtime.
+     *
+     * Windows npm launchers are .cmd files, so they must continue to run through
+     * the shell.
+     */
+    private piInvocation;
+    private createSessionState;
+    private splitModel;
+    private applySelection;
+    private spawnSession;
+    createSession(config: SessionConfig): Promise<string>;
+    resumeSession(sessionId: string, config: SessionConfig): Promise<SessionMessage[]>;
+    private attachProcess;
+    private consumeStdout;
+    private handleJsonlLine;
+    private rejectPending;
+    private handleEvent;
+    private handleExtensionUiRequest;
+    private uiRequestMessage;
+    private cancelPendingUiRequests;
+    private handleMessageUpdate;
+    private reconcileAssistantMessage;
+    private handleToolEvent;
+    private command;
+    private sendRecord;
+    sendPrompt(sessionId: string, parts: MessagePart[], _config: SessionConfig): Promise<void>;
+    /**
+     * THE LONG-TURNS SOFT WARNING'S DELIVERY MECHANISM.
+     *
+     * Reuses exactly the `streamingBehavior: 'steer'` path `sendPrompt` already
+     * takes for a message sent while Pi is busy — Pi delivers it after the
+     * current tool finishes and before the next model call. Deliberately does
+     * NOT touch `session.status`/`sawAgentActivity`/`promptMayBeCommandOnly`:
+     * those are `sendPrompt`'s own bookkeeping for a NEW prompt, and a steer
+     * into an already-running turn must not reset them.
+     */
+    steerTurn(sessionId: string, text: string, _config: SessionConfig): Promise<boolean>;
+    getStatus(sessionId: string, _config: SessionConfig): Promise<SessionStatus>;
+    private settlePendingTurnError;
+    pollMessages(sessionId: string): Promise<MessagePart[]>;
+    getPendingApproval(sessionId: string): {
+        requestId: string;
+        toolCallId: string;
+        question: string;
+        options: Array<{
+            optionId: string;
+            name: string;
+            kind: string;
+        }>;
+    } | null;
+    respondToApproval(sessionId: string, approved: boolean, _optionId?: string, requestId?: string): Promise<boolean>;
+    respondToQuestion(sessionId: string, answers: Record<string, string>, _config: SessionConfig, requestId?: string): Promise<boolean | {
+        handled: false;
+        resolutionPart: MessagePart;
+    }>;
+    getRunningTools(sessionId: string): Promise<Array<{
+        partId: string;
+        toolName: string;
+        input?: Record<string, unknown>;
+    }>>;
+    private convertMessages;
+    getAllMessages(sessionId: string): Promise<SessionMessage[]>;
+    abortPrompt(sessionId: string): Promise<void>;
+    private terminateProcess;
+    destroySession(sessionId: string): Promise<void>;
+    /**
+     * SessionRunner creates one adapter per turn. Stop every process owned by
+     * this adapter after the turn while leaving Pi's session files intact for
+     * native resume on the next turn.
+     */
+    stopServer(): Promise<void>;
+    registerMcpServer(_serverName: string, _mcpConfig: {
+        type: 'local' | 'remote';
+        command?: string[];
+        args?: string[];
+        url?: string;
+        headers?: Record<string, string>;
+        environment?: Record<string, string>;
+    }, _workspaceDir?: string): Promise<void>;
+    checkHealth(): Promise<{
+        available: boolean;
+        reason?: string;
+    }>;
+    getProviders(_serverUrl?: string, directory?: string): Promise<{
+        providers: Array<{
+            id: string;
+            name: string;
+            models: Array<{
+                id: string;
+                name: string;
+            }>;
+        }>;
+        default: Record<string, string>;
+    }>;
+}