pi-session-mcp 0.0.0-stage → 0.6.2

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

@@ -0,0 +1,75 @@
+import { type AgentSessionEvent, type CreateAgentSessionOptions, type CreateAgentSessionResult, DefaultResourceLoader, ModelRuntime, type PromptOptions, SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { PermissionProfile, ResolvedExecutionProfile, ThinkingLevel } from "./execution-profile.js";
+import { type McpConnectionFactory } from "./mcp-session-tools.js";
+import { type PiSessionAdapter, type PiSessionCreationErrorCode, type PiSessionHandle, type PiTurnOutcome } from "./pi-adapter.js";
+type CreateSession = (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
+export declare const AUTH_OPERATION_TIMEOUT_MS = 5000;
+/** Server-side bound for SDK session construction. The SDK does not document cancellation. */
+export declare const SESSION_CREATION_TIMEOUT_MS = 10000;
+export interface SdkPiAdapterDiagnostic {
+    readonly level: "error";
+    readonly event: "pi_session_creation_failed";
+    readonly stage: "runtime" | "provider" | "model" | "check_auth" | "get_auth" | "availability" | "resource_loader" | "mcp_tools" | "create_session" | "postcheck";
+    readonly code: PiSessionCreationErrorCode;
+    readonly executionProfile: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly thinkingLevel: ThinkingLevel;
+    readonly serverAlias?: string;
+    readonly toolAlias?: string;
+    readonly discoveredToolCount?: number;
+}
+export interface SdkPiSessionAdapterOptions {
+    readonly modelRuntimeFactory?: () => Promise<ModelRuntime>;
+    readonly createSession?: CreateSession;
+    readonly diagnosticSink?: (diagnostic: SdkPiAdapterDiagnostic) => void;
+    readonly mcpConnectionFactory?: McpConnectionFactory;
+}
+type SdkAssistantMessage = Extract<Extract<AgentSessionEvent, {
+    type: "message_end";
+}>["message"], {
+    role: "assistant";
+}>;
+/** Derived from the root-exported `AgentSessionEvent`; the SDK root does not export `StopReason`. */
+export type SdkStopReason = SdkAssistantMessage["stopReason"];
+/**
+ * Projects the final assistant message of a prompt onto a turn outcome.
+ *
+ * The switch is exhaustive on purpose: a stop reason added by a future SDK fails the
+ * typecheck (and therefore the Pi SDK canary) instead of being mapped silently. Runtime
+ * values outside the SDK union, a missing stop reason included, fail closed.
+ */
+export declare function normalizeAssistantOutcome(message: unknown): PiTurnOutcome;
+export declare const PROFILE_TOOLS: Readonly<Record<PermissionProfile, readonly string[]>>;
+/** Derived from the root-exported `PromptOptions`; the SDK does not export the union itself. */
+export type PromptDisposition = Parameters<NonNullable<PromptOptions["preflightResult"]>>[0];
+/**
+ * Whether an SDK prompt disposition admits a public turn. The SDK reports how an accepted
+ * prompt was dispatched and does not call the hook on rejection: `prompt()` rejects instead,
+ * which the registry already projects as `prompt_rejected`.
+ *
+ * The switch is exhaustive on purpose: a disposition added by a future SDK fails the
+ * typecheck (and therefore the Pi SDK canary) instead of being mapped silently.
+ */
+export declare function admitsTurn(disposition: PromptDisposition): boolean;
+export declare function createPhase0ResourceLoader(cwd: string): Promise<{
+    resourceLoader: DefaultResourceLoader;
+    settingsManager: SettingsManager;
+}>;
+export declare class SdkPiSessionAdapter implements PiSessionAdapter {
+    private runtimePromise;
+    private readonly modelRuntimeFactory;
+    private readonly createSession;
+    private readonly diagnosticSink;
+    private readonly mcpConnectionFactory;
+    constructor(options?: SdkPiSessionAdapterOptions);
+    create(input: {
+        cwd: string;
+        executionProfile: ResolvedExecutionProfile;
+        signal?: AbortSignal;
+    }): Promise<PiSessionHandle>;
+    private createSessionWithDeadline;
+    private getRuntime;
+    private failure;
+}
+export {};

package/dist/sdk-pi-adapter.js

@@ -0,0 +1,410 @@
+import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { classifyMcpStartupError, connectSessionMcpTools, } from "./mcp-session-tools.js";
+import { createStdioMcpConnection } from "./mcp-stdio-client.js";
+import { PiSessionCreationError, } from "./pi-adapter.js";
+export const AUTH_OPERATION_TIMEOUT_MS = 5_000;
+/** Server-side bound for SDK session construction. The SDK does not document cancellation. */
+export const SESSION_CREATION_TIMEOUT_MS = 10_000;
+class AuthDeadlineError extends Error {
+    constructor() {
+        super("authentication operation timed out");
+        this.name = "AuthDeadlineError";
+    }
+}
+class SessionCreationDeadlineError extends Error {
+    constructor() {
+        super("Pi session creation timed out");
+        this.name = "SessionCreationDeadlineError";
+    }
+}
+function disposeSdkSession(session) {
+    try {
+        session.dispose();
+    }
+    catch { /* SDK cleanup is best effort and never exposes internals. */ }
+}
+async function withAuthDeadline(operation) {
+    const controller = new AbortController();
+    let timeout;
+    const operationPromise = Promise.resolve().then(() => operation(controller.signal));
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+            controller.abort();
+            reject(new AuthDeadlineError());
+        }, AUTH_OPERATION_TIMEOUT_MS);
+    });
+    try {
+        return await Promise.race([operationPromise, timeoutPromise]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        controller.abort();
+    }
+}
+/**
+ * Projects the final assistant message of a prompt onto a turn outcome.
+ *
+ * The switch is exhaustive on purpose: a stop reason added by a future SDK fails the
+ * typecheck (and therefore the Pi SDK canary) instead of being mapped silently. Runtime
+ * values outside the SDK union, a missing stop reason included, fail closed.
+ */
+export function normalizeAssistantOutcome(message) {
+    if (!isAssistantMessage(message))
+        return { status: "failed" };
+    const stopReason = message.stopReason;
+    switch (stopReason) {
+        case "stop":
+        // Cut off by the output limit; the truncated text is still the turn's answer.
+        case "length":
+        // The agent loop ends on a tool call only when the tool batch terminated the run.
+        case "toolUse":
+            return { status: "completed", assistantText: message.content.filter(isTextBlock).map((block) => block.text).join("") };
+        case "aborted":
+            return { status: "aborted" };
+        case "error":
+        // Not a finished answer: `pending` marks a message still streaming, `deferred` a
+        // response the provider has not delivered yet.
+        case "pending":
+        case "deferred":
+            return { status: "failed" };
+        default: {
+            const unhandled = stopReason;
+            void unhandled;
+            return { status: "failed" };
+        }
+    }
+}
+export const PROFILE_TOOLS = {
+    "read-only": ["read", "grep", "find", "ls"],
+    coding: ["read", "bash", "edit", "write", "grep", "find", "ls"],
+};
+/**
+ * Whether an SDK prompt disposition admits a public turn. The SDK reports how an accepted
+ * prompt was dispatched and does not call the hook on rejection: `prompt()` rejects instead,
+ * which the registry already projects as `prompt_rejected`.
+ *
+ * The switch is exhaustive on purpose: a disposition added by a future SDK fails the
+ * typecheck (and therefore the Pi SDK canary) instead of being mapped silently.
+ */
+export function admitsTurn(disposition) {
+    switch (disposition) {
+        case "started":
+            return true;
+        // Only while streaming with `streamingBehavior`; Pi Session MCP never passes it and serializes turns.
+        case "queued":
+        // An extension command or input handler consumed the prompt without a model turn. The
+        // isolated resource loader (`noExtensions`) makes this unreachable; no public turn exists.
+        case "handled":
+            return false;
+        default: {
+            const unhandled = disposition;
+            void unhandled;
+            return false;
+        }
+    }
+}
+class SdkHandle {
+    session;
+    appliedSelection;
+    mcpTools;
+    disposed = false;
+    disposal;
+    subscriptions = new Set();
+    constructor(session, appliedSelection, mcpTools) {
+        this.session = session;
+        this.appliedSelection = appliedSelection;
+        this.mcpTools = mcpTools;
+    }
+    get sdkSessionId() { return this.session.sessionId; }
+    prompt(text, preflight, onActivity) {
+        if (this.disposed)
+            return Promise.resolve({ status: "failed" });
+        let finalAssistant;
+        /** Observer failures must never disturb SDK event handling or the turn outcome. */
+        const reportActivity = () => {
+            if (!onActivity)
+                return;
+            try {
+                onActivity();
+            }
+            catch { /* Liveness reporting is best effort and content-free. */ }
+        };
+        const unsubscribe = this.session.subscribe((event) => {
+            if (event.type === "tool_execution_end")
+                reportActivity();
+            else if (event.type === "message_end" && isAssistantMessage(event.message)) {
+                finalAssistant = event.message;
+                reportActivity();
+            }
+        });
+        let preflightSeen = false;
+        let cleaned = false;
+        const signalPreflight = (accepted) => {
+            if (preflightSeen || this.disposed)
+                return;
+            preflightSeen = true;
+            preflight(accepted);
+        };
+        const cleanup = () => {
+            if (cleaned)
+                return;
+            cleaned = true;
+            this.subscriptions.delete(cleanup);
+            try {
+                unsubscribe();
+            }
+            catch { /* subscription cleanup is best effort */ }
+        };
+        this.subscriptions.add(cleanup);
+        let promptResult;
+        try {
+            promptResult = this.session.prompt(text, { preflightResult: (disposition) => signalPreflight(admitsTurn(disposition)) });
+        }
+        catch {
+            cleanup();
+            throw new Error("Pi prompt failed");
+        }
+        return promptResult.then(() => (this.disposed ? { status: "failed" } : normalizeAssistantOutcome(finalAssistant)), () => ({ status: "failed" })).finally(cleanup);
+    }
+    abort() { return this.session.abort(); }
+    dispose() {
+        if (this.disposal)
+            return this.disposal;
+        this.disposed = true;
+        let finish;
+        // Publish the shared promise before synchronous cleanup can re-enter dispose().
+        this.disposal = new Promise((resolve) => { finish = resolve; });
+        const closed = this.mcpTools.close();
+        for (const cleanup of [...this.subscriptions])
+            cleanup();
+        disposeSdkSession(this.session);
+        void closed.then(finish, finish);
+        return this.disposal;
+    }
+}
+function isAssistantMessage(message) {
+    if (!message || typeof message !== "object")
+        return false;
+    const candidate = message;
+    return candidate.role === "assistant" && Array.isArray(candidate.content);
+}
+function isTextBlock(block) {
+    if (!block || typeof block !== "object")
+        return false;
+    const candidate = block;
+    return candidate.type === "text" && typeof candidate.text === "string";
+}
+export async function createPhase0ResourceLoader(cwd) {
+    const settingsManager = SettingsManager.inMemory(undefined, { projectTrusted: false });
+    const resourceLoader = new DefaultResourceLoader({
+        cwd,
+        agentDir: cwd,
+        settingsManager,
+        noExtensions: true,
+        noSkills: true,
+        noPromptTemplates: true,
+        noThemes: true,
+        noContextFiles: false,
+        systemPrompt: "phase-0-system-prompt-disabled",
+        appendSystemPrompt: [],
+        systemPromptOverride: () => undefined,
+        appendSystemPromptOverride: () => [],
+    });
+    await resourceLoader.reload();
+    return { resourceLoader, settingsManager };
+}
+export class SdkPiSessionAdapter {
+    runtimePromise;
+    modelRuntimeFactory;
+    createSession;
+    diagnosticSink;
+    mcpConnectionFactory;
+    constructor(options = {}) {
+        this.modelRuntimeFactory = options.modelRuntimeFactory ?? (() => ModelRuntime.create({ refreshOnCreate: false }));
+        this.createSession = options.createSession ?? createAgentSession;
+        this.diagnosticSink = options.diagnosticSink ?? (() => undefined);
+        this.mcpConnectionFactory = options.mcpConnectionFactory ?? createStdioMcpConnection;
+    }
+    async create(input) {
+        const { executionProfile } = input;
+        let runtime;
+        try {
+            runtime = await this.getRuntime();
+        }
+        catch {
+            throw this.failure(executionProfile, "runtime", "pi_session_creation_failed");
+        }
+        let provider;
+        try {
+            provider = runtime.getProvider(executionProfile.provider);
+        }
+        catch {
+            throw this.failure(executionProfile, "provider", "pi_session_creation_failed");
+        }
+        if (!provider)
+            throw this.failure(executionProfile, "provider", "unknown_provider");
+        let model;
+        try {
+            model = runtime.getModel(executionProfile.provider, executionProfile.model);
+        }
+        catch {
+            throw this.failure(executionProfile, "model", "pi_session_creation_failed");
+        }
+        if (!model)
+            throw this.failure(executionProfile, "model", "unknown_model");
+        let authenticated;
+        try {
+            authenticated = Boolean(await withAuthDeadline((signal) => runtime.checkAuth(executionProfile.provider, { signal })));
+        }
+        catch {
+            throw this.failure(executionProfile, "check_auth", "local_authentication_unavailable");
+        }
+        if (!authenticated)
+            throw this.failure(executionProfile, "check_auth", "local_authentication_missing");
+        try {
+            // AuthResult can contain credentials, so reduce it immediately.
+            authenticated = Boolean(await withAuthDeadline((signal) => runtime.getAuth(model, { signal })));
+        }
+        catch {
+            throw this.failure(executionProfile, "get_auth", "local_authentication_unavailable");
+        }
+        if (!authenticated)
+            throw this.failure(executionProfile, "get_auth", "local_authentication_missing");
+        let available;
+        try {
+            available = await withAuthDeadline((signal) => runtime.getAvailable(executionProfile.provider, { signal }));
+        }
+        catch {
+            throw this.failure(executionProfile, "availability", "pi_session_creation_failed");
+        }
+        if (!available.some((candidate) => candidate.provider === executionProfile.provider && candidate.id === executionProfile.model)) {
+            throw this.failure(executionProfile, "availability", "model_unavailable");
+        }
+        let resourceLoader;
+        let settingsManager;
+        try {
+            ({ resourceLoader, settingsManager } = await createPhase0ResourceLoader(input.cwd));
+        }
+        catch {
+            throw this.failure(executionProfile, "resource_loader", "pi_session_creation_failed");
+        }
+        let mcpTools;
+        try {
+            mcpTools = await connectSessionMcpTools(executionProfile.mcpServers ?? {}, executionProfile.permissionProfile, input.cwd, this.mcpConnectionFactory, input.signal === undefined ? {} : { signal: input.signal });
+        }
+        catch (error) {
+            const failure = classifyMcpStartupError(error);
+            throw this.failure(executionProfile, "mcp_tools", failure?.code ?? "external_mcp_unavailable", failure);
+        }
+        const tools = [...PROFILE_TOOLS[executionProfile.permissionProfile], ...mcpTools.tools.map((tool) => tool.name)];
+        let session;
+        try {
+            ({ session } = await this.createSessionWithDeadline({
+                cwd: input.cwd,
+                modelRuntime: runtime,
+                model,
+                thinkingLevel: executionProfile.thinkingLevel,
+                sessionManager: SessionManager.inMemory(input.cwd),
+                settingsManager,
+                resourceLoader,
+                // With an explicit tools list, Pi also needs custom tool names here to activate them.
+                tools,
+                ...(mcpTools.tools.length === 0 ? {} : { customTools: mcpTools.tools }),
+            }));
+        }
+        catch {
+            await mcpTools.close();
+            throw this.failure(executionProfile, "create_session", "pi_session_creation_failed");
+        }
+        try {
+            if (session.model?.provider !== executionProfile.provider || session.model.id !== executionProfile.model) {
+                throw this.failure(executionProfile, "postcheck", "execution_selection_mismatch");
+            }
+            if (session.thinkingLevel !== executionProfile.thinkingLevel) {
+                throw this.failure(executionProfile, "postcheck", "thinking_level_unavailable");
+            }
+            if (mcpTools.tools.length > 0) {
+                const active = new Set(session.getActiveToolNames());
+                if (active.size !== tools.length || tools.some((name) => !active.has(name))) {
+                    throw this.failure(executionProfile, "postcheck", "external_mcp_activation_mismatch");
+                }
+            }
+            return new SdkHandle(session, {
+                provider: session.model.provider,
+                model: session.model.id,
+                thinkingLevel: session.thinkingLevel,
+            }, mcpTools);
+        }
+        catch (error) {
+            disposeSdkSession(session);
+            await mcpTools.close();
+            if (error instanceof PiSessionCreationError)
+                throw error;
+            throw this.failure(executionProfile, "postcheck", "pi_session_creation_failed");
+        }
+    }
+    async createSessionWithDeadline(options) {
+        let creation;
+        try {
+            creation = Promise.resolve(this.createSession(options));
+        }
+        catch {
+            throw new SessionCreationDeadlineError();
+        }
+        let timedOut = false;
+        // This continuation is installed immediately and owns late cleanup. Its rejection
+        // branch is required even when the deadline wins the race.
+        const observed = creation.then((result) => {
+            if (timedOut)
+                disposeSdkSession(result.session);
+            return result;
+        }, (error) => { throw error; });
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                timedOut = true;
+                reject(new SessionCreationDeadlineError());
+            }, SESSION_CREATION_TIMEOUT_MS);
+        });
+        try {
+            return await Promise.race([observed, timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    getRuntime() {
+        if (!this.runtimePromise) {
+            const pending = this.modelRuntimeFactory();
+            this.runtimePromise = pending;
+            void pending.catch(() => {
+                if (this.runtimePromise === pending)
+                    this.runtimePromise = undefined;
+            });
+        }
+        return this.runtimePromise;
+    }
+    failure(executionProfile, stage, code, metadata) {
+        try {
+            this.diagnosticSink({
+                level: "error",
+                event: "pi_session_creation_failed",
+                stage,
+                code,
+                executionProfile: executionProfile.alias,
+                provider: executionProfile.provider,
+                model: executionProfile.model,
+                thinkingLevel: executionProfile.thinkingLevel,
+                ...(metadata?.serverAlias === undefined ? {} : { serverAlias: metadata.serverAlias }),
+                ...(metadata?.toolAlias === undefined ? {} : { toolAlias: metadata.toolAlias }),
+                ...(metadata?.discoveredToolCount === undefined ? {} : { discoveredToolCount: metadata.discoveredToolCount }),
+            });
+        }
+        catch {
+            // Diagnostics are never allowed to influence session safety.
+        }
+        return new PiSessionCreationError(code);
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { type ConfigurationMetadata } from "./config.js";
+import { type ConfiguredExecutionProfile } from "./execution-profile.js";
+import { type SessionRegistry } from "./session-registry.js";
+export declare function createServer(registry: SessionRegistry, workspaces: ReadonlyMap<string, string>, executionProfiles: ReadonlyMap<string, ConfiguredExecutionProfile>, defaultExecutionProfile: string, configuration: ConfigurationMetadata): McpServer;

package/dist/server.js

@@ -0,0 +1,102 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { z } from "zod";
+import packageMetadata from "../package.json" with { type: "json" };
+import { projectCapabilities } from "./capabilities.js";
+import { CONFIGURATION_FINGERPRINT_PATTERN, RELOAD_POLICY } from "./config.js";
+import { PiSessionCreationError } from "./pi-adapter.js";
+import { ALIAS_PATTERN, toResolvedExecutionProfile } from "./execution-profile.js";
+import { RegistryError } from "./session-registry.js";
+const thinkingLevelSchema = z.enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const viewSchema = z.object({
+    id: z.string(), workspace: z.string(), executionProfile: z.string(), profile: z.enum(["read-only", "coding"]),
+    provider: z.string(), model: z.string(), thinkingLevel: thinkingLevelSchema,
+    state: z.enum(["idle", "running", "failed", "closing", "closed"]), createdAt: z.string(), updatedAt: z.string(),
+    lastError: z.string().optional(),
+});
+const aliasSchema = z.string().regex(ALIAS_PATTERN);
+const successSchema = z.object({ ok: z.literal(true), session: viewSchema });
+const turnBase = { turnId: z.string().uuid(), sessionId: z.string().uuid(), startedAt: z.string(), updatedAt: z.string() };
+const turnSchema = z.discriminatedUnion("state", [
+    z.object({ ...turnBase, state: z.literal("running") }),
+    z.object({ ...turnBase, state: z.literal("completed"), completedAt: z.string(), assistantText: z.string(), truncated: z.boolean() }),
+    z.object({ ...turnBase, state: z.literal("failed"), completedAt: z.string(), error: z.object({ code: z.literal("turn_failed"), message: z.literal("Pi turn failed") }) }),
+    z.object({ ...turnBase, state: z.literal("aborted"), completedAt: z.string() }),
+]);
+const promptSuccessSchema = z.object({ ok: z.literal(true), session: viewSchema, turn: turnSchema });
+const turnSuccessSchema = z.object({ ok: z.literal(true), turn: turnSchema });
+const listSchema = z.object({ ok: z.literal(true), sessions: z.array(viewSchema) });
+const errorSchema = z.object({ ok: z.literal(false), error: z.object({ code: z.string(), message: z.string() }) });
+const capabilitiesSchema = z.object({
+    ok: z.literal(true),
+    server: z.object({ name: z.literal(packageMetadata.name), version: z.literal(packageMetadata.version) }).strict(),
+    configuration: z.object({
+        fingerprint: z.string().regex(CONFIGURATION_FINGERPRINT_PATTERN),
+        reloadPolicy: z.literal(RELOAD_POLICY),
+    }).strict(),
+    workspaces: z.array(z.object({ alias: aliasSchema }).strict()),
+    executionProfiles: z.array(z.object({
+        alias: aliasSchema,
+        default: z.boolean(),
+        permissionProfile: z.enum(["read-only", "coding"]),
+        provider: z.string(),
+        model: z.string(),
+        thinkingLevel: thinkingLevelSchema,
+    }).strict()),
+}).strict();
+function result(value, isError = false) {
+    return { content: [{ type: "text", text: JSON.stringify(value) }], structuredContent: value, ...(isError ? { isError: true } : {}) };
+}
+async function safe(action) {
+    try {
+        return result(await action());
+    }
+    catch (error) {
+        const known = error instanceof RegistryError || error instanceof PiSessionCreationError;
+        return result({ ok: false, error: { code: known ? error.code : "internal_error", message: known ? error.message : "Operation failed" } }, true);
+    }
+}
+export function createServer(registry, workspaces, executionProfiles, defaultExecutionProfile, configuration) {
+    const server = new McpServer({ name: packageMetadata.name, version: packageMetadata.version }, { capabilities: { tools: {} } });
+    server.registerTool("pi_capabilities_get", {
+        description: "List configured workspace and execution-profile aliases. This reports configured intent, not provider or runtime availability.",
+        inputSchema: z.object({}).strict(),
+        outputSchema: capabilitiesSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, () => result(projectCapabilities(workspaces, executionProfiles, configuration)));
+    server.registerTool("pi_session_start", {
+        description: "Start a managed embedded Pi session for a configured workspace alias.",
+        inputSchema: z.object({ workspace: aliasSchema, executionProfile: aliasSchema.optional() }).strict(), outputSchema: z.union([successSchema, errorSchema]),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    }, ({ workspace, executionProfile }) => safe(async () => {
+        const alias = executionProfile ?? defaultExecutionProfile;
+        const configured = executionProfiles.get(alias);
+        if (!configured)
+            throw new RegistryError("unknown_execution_profile");
+        return { ok: true, session: await registry.start(workspace, toResolvedExecutionProfile(configured)) };
+    }));
+    server.registerTool("pi_session_list", {
+        description: "List local Pi sessions and their state.", inputSchema: z.object({}).strict(), outputSchema: z.union([listSchema, errorSchema]),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, () => safe(() => ({ ok: true, sessions: registry.list() })));
+    server.registerTool("pi_session_get", {
+        description: "Get one local Pi session by ID.", inputSchema: z.object({ sessionId: z.string().uuid() }).strict(), outputSchema: z.union([successSchema, errorSchema]),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, ({ sessionId }) => safe(() => ({ ok: true, session: registry.get(sessionId) })));
+    server.registerTool("pi_session_prompt", {
+        description: "Accept a prompt after Pi preflight and run the turn in the background.", inputSchema: z.object({ sessionId: z.string().uuid(), prompt: z.string().min(1).max(100_000) }).strict(), outputSchema: z.union([promptSuccessSchema, errorSchema]),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    }, ({ sessionId, prompt }) => safe(async () => ({ ok: true, ...(await registry.prompt(sessionId, prompt)) })));
+    server.registerTool("pi_session_abort", {
+        description: "Abort a running Pi turn; idle sessions are unchanged.", inputSchema: z.object({ sessionId: z.string().uuid() }).strict(), outputSchema: z.union([successSchema, errorSchema]),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    }, ({ sessionId }) => safe(async () => ({ ok: true, session: await registry.abort(sessionId) })));
+    server.registerTool("pi_session_close", {
+        description: "Abort if needed, dispose, and remove a Pi session.", inputSchema: z.object({ sessionId: z.string().uuid() }).strict(), outputSchema: z.union([successSchema, errorSchema]),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    }, ({ sessionId }) => safe(async () => ({ ok: true, session: await registry.close(sessionId) })));
+    server.registerTool("pi_turn_get", {
+        description: "Get the normalized observable result of a Pi turn.", inputSchema: z.object({ sessionId: z.string().uuid(), turnId: z.string().uuid() }).strict(), outputSchema: z.union([turnSuccessSchema, errorSchema]),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, ({ sessionId, turnId }) => safe(() => ({ ok: true, turn: registry.getTurn(sessionId, turnId) })));
+    return server;
+}