@automatalabs/pi-acp 0.1.3 → 0.2.1

package/dist/child-process-registry.d.ts

@@ -0,0 +1,82 @@
+import { type ChildProcess } from "node:child_process";
+import type { BashOperations } from "@earendil-works/pi-coding-agent";
+import type { PiAcpDeps } from "./deps.js";
+interface ChildRecord {
+    pid: number;
+    pgid?: number;
+    child: ChildProcess;
+    leaderClosed: Promise<void>;
+    termination?: Promise<void>;
+    terminationSettled?: boolean;
+}
+export interface ChildProcessRegistryDeps extends Pick<PiAcpDeps, "graceMs" | "sleep"> {
+    platform?: NodeJS.Platform;
+    processGroupState?(pgid: number): "alive" | "gone" | "error";
+    killProcessGroup?(pgid: number): void;
+    taskkillTree?(pid: number, signal: AbortSignal): Promise<void>;
+}
+export interface SpawnLease {
+    register(child: ChildProcess): ChildRecord;
+    failed(): void;
+}
+export declare class ChildCleanupFailure extends Error {
+    readonly remainingChildren: number;
+    constructor(remainingChildren: number);
+}
+export declare function isTaskkillAlreadyGone(output: string): boolean;
+/** One monotonic ownership epoch. A failed drain remains closing and is retryable. */
+export declare class ChildProcessRegistry {
+    private readonly deps;
+    private state;
+    private readonly children;
+    private pendingSpawns;
+    private drain;
+    private generationSignal;
+    private changeWaiters;
+    constructor(deps: ChildProcessRegistryDeps);
+    private get platform();
+    get remainingChildren(): number;
+    get leaderPids(): readonly number[];
+    beginSpawn(): SpawnLease;
+    private registerChild;
+    /** Natural operation completion never proves away a surviving Unix process group. */
+    complete(record: ChildRecord): void;
+    /** Terminate one timed-out/aborted tool tree without closing admission for unrelated tools. */
+    terminateOne(record: ChildRecord): Promise<void>;
+    terminateAll(deadlineSignal: AbortSignal): Promise<void>;
+    private drainGeneration;
+    private groupState;
+    private startTermination;
+    private terminateRecord;
+    private changed;
+    private waitForChange;
+}
+export declare class ChildProcessRegistrySlot {
+    private readonly deps;
+    private epoch;
+    private cleanupFailed;
+    constructor(deps: ChildProcessRegistryDeps);
+    get registry(): ChildProcessRegistry;
+    get childCleanupFailed(): boolean;
+    get remainingChildren(): number;
+    beginSpawn(): SpawnLease;
+    latchFailure(): void;
+    clearFailure(): void;
+    /**
+     * Close admission on the current epoch synchronously and return that exact
+     * epoch with its drain.  Rotation is deliberately a separate commit: a
+     * cancel generation must not publish a fresh spawn epoch until both Pi and
+     * this captured registry are idle.
+     */
+    closeEpoch(deadlineSignal: AbortSignal): {
+        epoch: ChildProcessRegistry;
+        drain: Promise<void>;
+    };
+    commitRotation(captured: ChildProcessRegistry): void;
+    /** Compatibility seam for focused registry tests; production uses the
+     * explicit closeEpoch/commitRotation transaction above. */
+    terminateAll(shouldRotate: () => boolean, deadlineSignal: AbortSignal): Promise<void>;
+}
+export declare function createTrackedBashOperations(slot: ChildProcessRegistrySlot, shellPath: string | undefined, deps: Pick<PiAcpDeps, "graceMs" | "sleep">, onCleanupFailure: () => void): BashOperations;
+export {};
+//# sourceMappingURL=child-process-registry.d.ts.map

package/dist/child-process-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-process-registry.d.ts","sourceRoot":"","sources":["../src/child-process-registry.ts"],"names":[],"mappings":"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"}

package/dist/child-process-registry.js

@@ -0,0 +1,408 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { getShellConfig } from "@earendil-works/pi-coding-agent";
+export class ChildCleanupFailure extends Error {
+    remainingChildren;
+    constructor(remainingChildren) {
+        super("child process cleanup failed");
+        this.remainingChildren = remainingChildren;
+        this.name = "ChildCleanupFailure";
+    }
+}
+export function isTaskkillAlreadyGone(output) {
+    return /ERROR:\s+The process "[^"]+" not found\./i.test(output)
+        || /Reason:\s+There is no running instance of the task\./i.test(output);
+}
+/** One monotonic ownership epoch. A failed drain remains closing and is retryable. */
+export class ChildProcessRegistry {
+    deps;
+    state = "open";
+    children = new Map();
+    pendingSpawns = 0;
+    drain;
+    generationSignal;
+    changeWaiters = new Set();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    get platform() { return this.deps.platform ?? process.platform; }
+    get remainingChildren() { return this.children.size; }
+    get leaderPids() { return [...this.children.keys()]; }
+    beginSpawn() {
+        if (this.state !== "open")
+            throw new Error("aborted");
+        this.pendingSpawns += 1;
+        let settled = false;
+        return {
+            failed: () => {
+                if (settled)
+                    return;
+                settled = true;
+                this.pendingSpawns -= 1;
+                this.changed();
+            },
+            register: (child) => {
+                if (settled)
+                    throw new Error("spawn lease already settled");
+                settled = true;
+                this.pendingSpawns -= 1;
+                const record = this.registerChild(child);
+                if (this.state !== "open") {
+                    const signal = this.generationSignal;
+                    if (signal)
+                        this.startTermination(record, signal);
+                }
+                this.changed();
+                return record;
+            },
+        };
+    }
+    registerChild(child) {
+        if (!child.pid)
+            throw new Error("bash child spawned without pid");
+        let closeError;
+        const leaderClosed = new Promise((resolve, reject) => {
+            child.once("error", (error) => {
+                closeError = error;
+                reject(error);
+            });
+            child.once("close", () => closeError === undefined ? resolve() : reject(closeError));
+        });
+        // A rejected leader promise is always observed by normal execution or cleanup.
+        leaderClosed.catch(() => undefined);
+        const record = {
+            pid: child.pid,
+            pgid: this.platform === "win32" ? undefined : child.pid,
+            child,
+            leaderClosed,
+        };
+        this.children.set(record.pid, record);
+        return record;
+    }
+    /** Natural operation completion never proves away a surviving Unix process group. */
+    complete(record) {
+        if (this.children.get(record.pid) !== record)
+            return;
+        // A Windows leader close is not descendant-disappearance proof.  Keep the
+        // ownership record until terminateRecord observes successful taskkill /T
+        // /F as well as leader close.  Unix may discharge ownership with ESRCH for
+        // the process group plus the already-observed leader completion.
+        if (this.platform !== "win32" && this.groupState(record.pgid ?? record.pid) === "gone") {
+            this.children.delete(record.pid);
+            this.changed();
+        }
+    }
+    /** Terminate one timed-out/aborted tool tree without closing admission for unrelated tools. */
+    async terminateOne(record) {
+        if (this.children.get(record.pid) !== record)
+            return;
+        const deadline = new AbortController();
+        const timer = new AbortController();
+        const expiry = this.deps.sleep(this.deps.graceMs, timer.signal).then(() => {
+            deadline.abort(new ChildCleanupFailure(this.children.size));
+            throw new ChildCleanupFailure(this.children.size);
+        });
+        expiry.catch(() => undefined);
+        try {
+            await Promise.race([this.startTermination(record, deadline.signal), expiry]);
+        }
+        finally {
+            timer.abort();
+            if (record.termination) {
+                await record.termination.catch(() => undefined);
+                record.termination = undefined;
+                record.terminationSettled = false;
+            }
+        }
+    }
+    terminateAll(deadlineSignal) {
+        if (this.drain)
+            return this.drain;
+        if (this.state === "closed" && this.children.size === 0 && this.pendingSpawns === 0) {
+            return Promise.resolve();
+        }
+        this.state = "closing";
+        this.generationSignal = deadlineSignal;
+        for (const record of this.children.values()) {
+            record.termination = undefined;
+            record.terminationSettled = false;
+            this.startTermination(record, deadlineSignal);
+        }
+        this.drain = this.drainGeneration(deadlineSignal)
+            .then(() => { this.generationSignal = undefined; })
+            .finally(() => { this.drain = undefined; });
+        return this.drain;
+    }
+    async drainGeneration(deadlineSignal) {
+        while (true) {
+            for (const record of this.children.values())
+                this.startTermination(record, deadlineSignal);
+            if (this.pendingSpawns === 0 && this.children.size === 0) {
+                this.state = "closed";
+                return;
+            }
+            if (deadlineSignal.aborted)
+                throw new ChildCleanupFailure(this.children.size);
+            const terminations = [...this.children.values()]
+                .flatMap((record) => record.termination ? [record.termination] : []);
+            if (this.pendingSpawns === 0 && terminations.length > 0) {
+                await Promise.allSettled(terminations);
+                if (this.children.size > 0) {
+                    if (deadlineSignal.aborted)
+                        throw new ChildCleanupFailure(this.children.size);
+                    // Every admitted record was attempted and at least one proof failed.
+                    const allSettled = [...this.children.values()].every((record) => record.terminationSettled);
+                    if (allSettled)
+                        throw new ChildCleanupFailure(this.children.size);
+                }
+                continue;
+            }
+            try {
+                await Promise.race([this.waitForChange(), abortPromise(deadlineSignal)]);
+            }
+            catch {
+                throw new ChildCleanupFailure(this.children.size);
+            }
+        }
+    }
+    groupState(pgid) {
+        if (this.deps.processGroupState)
+            return this.deps.processGroupState(pgid);
+        try {
+            process.kill(-pgid, 0);
+            return "alive";
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ESRCH")
+                return "gone";
+            if (code === "EPERM")
+                return "alive";
+            return "error";
+        }
+    }
+    startTermination(record, deadlineSignal) {
+        if (record.termination)
+            return record.termination;
+        record.terminationSettled = false;
+        record.termination = this.terminateRecord(record, deadlineSignal)
+            .finally(() => { record.terminationSettled = true; });
+        record.termination.catch(() => undefined);
+        return record.termination;
+    }
+    async terminateRecord(record, deadlineSignal) {
+        if (this.platform === "win32") {
+            const taskkill = this.deps.taskkillTree
+                ? this.deps.taskkillTree(record.pid, deadlineSignal)
+                : new Promise((resolve, reject) => {
+                    const killer = spawn("taskkill", ["/PID", String(record.pid), "/T", "/F"], { windowsHide: true });
+                    let output = "";
+                    killer.stdout?.setEncoding("utf8");
+                    killer.stderr?.setEncoding("utf8");
+                    killer.stdout?.on("data", (chunk) => { output += chunk; });
+                    killer.stderr?.on("data", (chunk) => { output += chunk; });
+                    killer.once("error", reject);
+                    killer.once("close", (code) => code === 0 || isTaskkillAlreadyGone(output)
+                        ? resolve()
+                        : reject(new Error(`taskkill exited ${code}`)));
+                });
+            try {
+                await raceAbort(taskkill, deadlineSignal);
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    throw error;
+            }
+        }
+        else {
+            if (this.deps.killProcessGroup) {
+                this.deps.killProcessGroup(record.pgid ?? record.pid);
+            }
+            else {
+                try {
+                    process.kill(-(record.pgid ?? record.pid), "SIGKILL");
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        throw error;
+                }
+            }
+        }
+        await raceAbort(record.leaderClosed, deadlineSignal);
+        if (this.platform !== "win32") {
+            while (true) {
+                const state = this.groupState(record.pgid ?? record.pid);
+                if (state === "gone")
+                    break;
+                if (state === "error")
+                    throw new Error("child process-group probe failed");
+                await raceAbort(this.deps.sleep(10, deadlineSignal), deadlineSignal);
+            }
+        }
+        this.children.delete(record.pid);
+        this.changed();
+    }
+    changed() {
+        const waiters = this.changeWaiters;
+        this.changeWaiters = new Set();
+        for (const resolve of waiters)
+            resolve();
+    }
+    waitForChange() {
+        return new Promise((resolve) => {
+            this.changeWaiters.add(resolve);
+        });
+    }
+}
+function abortPromise(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(signal.reason);
+        else
+            signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+    });
+}
+async function raceAbort(promise, signal) {
+    promise.catch(() => undefined);
+    return Promise.race([promise, abortPromise(signal)]);
+}
+export class ChildProcessRegistrySlot {
+    deps;
+    epoch;
+    cleanupFailed = false;
+    constructor(deps) {
+        this.deps = deps;
+        this.epoch = new ChildProcessRegistry(deps);
+    }
+    get registry() { return this.epoch; }
+    get childCleanupFailed() { return this.cleanupFailed; }
+    get remainingChildren() { return this.epoch.remainingChildren; }
+    beginSpawn() { return this.epoch.beginSpawn(); }
+    latchFailure() { this.cleanupFailed = true; }
+    clearFailure() { this.cleanupFailed = false; }
+    /**
+     * Close admission on the current epoch synchronously and return that exact
+     * epoch with its drain.  Rotation is deliberately a separate commit: a
+     * cancel generation must not publish a fresh spawn epoch until both Pi and
+     * this captured registry are idle.
+     */
+    closeEpoch(deadlineSignal) {
+        const captured = this.epoch;
+        return { epoch: captured, drain: captured.terminateAll(deadlineSignal) };
+    }
+    commitRotation(captured) {
+        if (this.epoch === captured) {
+            this.epoch = new ChildProcessRegistry(this.deps);
+            this.cleanupFailed = false;
+        }
+    }
+    /** Compatibility seam for focused registry tests; production uses the
+     * explicit closeEpoch/commitRotation transaction above. */
+    async terminateAll(shouldRotate, deadlineSignal) {
+        const { epoch, drain } = this.closeEpoch(deadlineSignal);
+        await drain;
+        if (shouldRotate())
+            this.commitRotation(epoch);
+    }
+}
+class BashCleanupSentinel extends Error {
+}
+export function createTrackedBashOperations(slot, shellPath, deps, onCleanupFailure) {
+    return {
+        async exec(command, cwd, { onData, signal, timeout, env }) {
+            if (signal?.aborted)
+                throw new Error("aborted");
+            if (timeout !== undefined && (!Number.isFinite(timeout) || timeout <= 0)) {
+                throw new Error("Invalid timeout: must be a finite number of seconds");
+            }
+            const timeoutMs = timeout === undefined ? undefined : timeout * 1000;
+            if (timeoutMs !== undefined && timeoutMs > 2_147_483_647) {
+                throw new Error(`Invalid timeout: maximum is ${2_147_483_647 / 1000} seconds`);
+            }
+            try {
+                await access(cwd, constants.F_OK);
+            }
+            catch {
+                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
+            }
+            // access() is asynchronous.  A cancel may have closed the captured
+            // generation while it was pending, so re-check before taking a lease.
+            if (signal?.aborted)
+                throw new Error("aborted");
+            const shell = getShellConfig(shellPath);
+            const stdin = shell.commandTransport === "stdin";
+            const lease = slot.beginSpawn();
+            let child;
+            try {
+                child = spawn(shell.shell, stdin ? shell.args : [...shell.args, command], {
+                    cwd,
+                    detached: process.platform !== "win32",
+                    env,
+                    stdio: [stdin ? "pipe" : "ignore", "pipe", "pipe"],
+                    windowsHide: true,
+                });
+            }
+            catch (error) {
+                lease.failed();
+                throw error;
+            }
+            let record;
+            try {
+                record = lease.register(child);
+            }
+            catch (error) {
+                lease.failed();
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch { /* no PID/tree was admitted */ }
+                throw error;
+            }
+            if (stdin) {
+                child.stdin?.on("error", () => undefined);
+                child.stdin?.end(command);
+            }
+            child.stdout?.on("data", onData);
+            child.stderr?.on("data", onData);
+            const timerController = new AbortController();
+            const timeoutResult = timeoutMs === undefined
+                ? new Promise(() => undefined)
+                : deps.sleep(timeoutMs, timerController.signal).then(() => ({ type: "timeout" }));
+            timeoutResult.catch(() => undefined);
+            const abortResult = signal
+                ? new Promise((resolve) => {
+                    if (signal.aborted)
+                        resolve({ type: "abort" });
+                    else
+                        signal.addEventListener("abort", () => resolve({ type: "abort" }), { once: true });
+                })
+                : new Promise(() => undefined);
+            const exitResult = new Promise((resolve, reject) => {
+                child.once("error", reject);
+                child.once("close", (exitCode) => resolve({ type: "exit", exitCode }));
+            });
+            try {
+                const outcome = await Promise.race([exitResult, abortResult, timeoutResult]);
+                if (outcome.type === "exit") {
+                    slot.registry.complete(record);
+                    return { exitCode: outcome.exitCode };
+                }
+                try {
+                    await slot.registry.terminateOne(record);
+                }
+                catch {
+                    slot.latchFailure();
+                    onCleanupFailure();
+                    throw new BashCleanupSentinel();
+                }
+                if (outcome.type === "abort")
+                    throw new Error("aborted");
+                throw new Error(`timeout:${timeout}`);
+            }
+            finally {
+                timerController.abort();
+            }
+        },
+    };
+}

package/dist/config.d.ts

@@ -1,7 +1,18 @@
 import type { SessionConfigOption } from "@agentclientprotocol/sdk";
 import type { AgentSession, ModelRuntime } from "@earendil-works/pi-coding-agent";
-export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+import { type Api, type Model, type ModelThinkingLevel } from "@earendil-works/pi-ai";
+export type ThinkingLevel = ModelThinkingLevel;
+/** Additive ACP metadata understood by AgentPrism's generic config validator. */
+export declare const CONFIG_OPTION_META_NAMESPACE = "@automatalabs/agentprism";
+/**
+ * Pi's complete, ordered domain, derived once from pi's own model-aware helper.
+ * This is intentionally not a hardcoded mirror of pi's module-private ladder.
+ */
+export declare const RECOGNIZED_THINKING_LEVELS: readonly ModelThinkingLevel[];
 export declare function thinkingLevelOption(session: AgentSession): SessionConfigOption;
-export declare function applyConfig(session: AgentSession, modelRuntime: ModelRuntime, configId: string, value: string | boolean): Promise<SessionConfigOption[]>;
+export declare function modelOption(session: AgentSession, availableModels: readonly Model<Api>[]): SessionConfigOption;
+export declare function applyConfig(session: AgentSession, modelRuntime: ModelRuntime, _availableModels: readonly Model<Api>[], configId: string, value: string | boolean): Promise<{
+    configOptions: SessionConfigOption[];
+    availableModels: readonly Model<Api>[];
+}>;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGlF,eAAO,MAAM,eAAe,sEAAuE,CAAC;AACpG,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,mBAAmB,CAS9E;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,YAAY,EACrB,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GAAG,OAAO,GACtB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA4BhC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAClF,OAAO,EAGL,KAAK,GAAG,EACR,KAAK,KAAK,EACV,KAAK,kBAAkB,EACxB,MAAM,uBAAuB,CAAC;AAG/B,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC;AAE/C,iFAAiF;AACjF,eAAO,MAAM,4BAA4B,6BAA6B,CAAC;AASvE;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,kBAAkB,EAEnE,CAAC;AAOF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,mBAAmB,CAe9E;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,mBAAmB,CAS9G;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,YAAY,EACrB,YAAY,EAAE,YAAY,EAC1B,gBAAgB,EAAE,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,EACvC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GAAG,OAAO,GACtB,OAAO,CAAC;IAAE,aAAa,EAAE,mBAAmB,EAAE,CAAC;IAAC,eAAe,EAAE,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,CAAA;CAAE,CAAC,CAwC3F"}

package/dist/config.js

@@ -1,38 +1,79 @@
+import { clampThinkingLevel, getSupportedThinkingLevels, } from "@earendil-works/pi-ai";
 import { adapterError } from "./errors.js";
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+/** Additive ACP metadata understood by AgentPrism's generic config validator. */
+export const CONFIG_OPTION_META_NAMESPACE = "@automatalabs/agentprism";
+const SYNTHETIC_ALL_THINKING_MODEL = {
+    reasoning: {},
+    thinkingLevelMap: new Proxy({}, {
+        get: (_target, property) => typeof property === "string" ? property : undefined,
+    }),
+};
+/**
+ * Pi's complete, ordered domain, derived once from pi's own model-aware helper.
+ * This is intentionally not a hardcoded mirror of pi's module-private ladder.
+ */
+export const RECOGNIZED_THINKING_LEVELS = Object.freeze(getSupportedThinkingLevels(SYNTHETIC_ALL_THINKING_MODEL));
+function supportedThinkingLevels(model) {
+    // With no selected model, the pi-derived domain is the only safe best-effort catalog.
+    return model ? getSupportedThinkingLevels(model) : RECOGNIZED_THINKING_LEVELS;
+}
 export function thinkingLevelOption(session) {
+    const supported = supportedThinkingLevels(session.model);
     return {
         id: "thinkingLevel",
         name: "Thinking level",
         type: "select",
         category: "thought_level",
         currentValue: session.thinkingLevel,
-        options: THINKING_LEVELS.map((value) => ({ value, name: value })),
+        options: supported.map((value) => ({ value, name: value })),
+        _meta: {
+            [CONFIG_OPTION_META_NAMESPACE]: {
+                recognizedValues: RECOGNIZED_THINKING_LEVELS,
+            },
+        },
     };
 }
-export async function applyConfig(session, modelRuntime, configId, value) {
+export function modelOption(session, availableModels) {
+    return {
+        id: "model",
+        name: "Model",
+        type: "select",
+        category: "model",
+        currentValue: session.model ? `${session.model.provider}/${session.model.id}` : "",
+        options: availableModels.map((model) => ({ value: `${model.provider}/${model.id}`, name: model.name })),
+    };
+}
+export async function applyConfig(session, modelRuntime, _availableModels, configId, value) {
     if (configId !== "thinkingLevel" && configId !== "model") {
         throw adapterError("unknown_config_option");
     }
     if (typeof value !== "string")
         throw adapterError("invalid_config_type");
     if (configId === "thinkingLevel") {
-        if (!THINKING_LEVELS.includes(value)) {
+        if (!RECOGNIZED_THINKING_LEVELS.includes(value)) {
             throw adapterError("invalid_config_value");
         }
-        session.setThinkingLevel(value);
-        return [thinkingLevelOption(session)];
+        const requested = value;
+        const supported = supportedThinkingLevels(session.model);
+        const effective = session.model && !supported.includes(requested)
+            ? clampThinkingLevel(session.model, requested)
+            : requested;
+        const availableModels = [...await modelRuntime.getAvailable()];
+        session.setThinkingLevel(effective);
+        return {
+            configOptions: [thinkingLevelOption(session), modelOption(session, availableModels)],
+            availableModels,
+        };
     }
     const separator = value.indexOf("/");
     if (separator <= 0 || separator === value.length - 1)
         throw adapterError("invalid_model");
     const provider = value.slice(0, separator);
     const modelId = value.slice(separator + 1);
-    const model = modelRuntime.getModel(provider, modelId);
+    const availableModels = [...await modelRuntime.getAvailable()];
+    const model = availableModels.find((candidate) => candidate.provider === provider && candidate.id === modelId);
     if (!model)
         throw adapterError("invalid_model");
-    if (!modelRuntime.hasConfiguredAuth(model.provider))
-        throw adapterError("auth_error");
     try {
         await session.setModel(model);
     }
@@ -42,5 +83,8 @@ export async function applyConfig(session, modelRuntime, configId, value) {
         }
         throw error;
     }
-    return [thinkingLevelOption(session)];
+    return {
+        configOptions: [thinkingLevelOption(session), modelOption(session, availableModels)],
+        availableModels,
+    };
 }

package/dist/deps.d.ts

@@ -1,6 +1,6 @@
 import { ModelRuntime, SessionManager, type CreateAgentSessionOptions, type CreateAgentSessionResult, type NewSessionOptions, type SessionInfo } from "@earendil-works/pi-coding-agent";
-import type { McpServerStdio } from "@agentclientprotocol/sdk";
-import { type McpClientHandle } from "./mcp-bridge.js";
+import type { McpServer } from "@agentclientprotocol/sdk";
+import { type McpClientHandle, type McpSessionBinding } from "./mcp-bridge.js";
 export interface PiAcpDeps {
     createAgentSession(opts: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;
     sessions: {
@@ -12,7 +12,7 @@ export interface PiAcpDeps {
     };
     modelRuntime: ModelRuntime;
     sessionDir?: string;
-    connectMcpClient(server: McpServerStdio, signal: AbortSignal): Promise<McpClientHandle>;
+    connectMcpClient(server: McpServer, signal: AbortSignal, binding?: McpSessionBinding): Promise<McpClientHandle>;
     sleep(ms: number, signal: AbortSignal): Promise<void>;
     graceMs: number;
     mcpTimeoutMs: number;

package/dist/deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../src/deps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,cAAc,EAEd,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,WAAW,EACjB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEhF,MAAM,WAAW,SAAS;IACxB,kBAAkB,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACvF,QAAQ,EAAE;QACR,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,cAAc,CAAC;QACtF,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;QAC9E,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,cAAc,CAAC;QAClH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/D,OAAO,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;KACtD,CAAC;IACF,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IACxF,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBxE;AAED,wBAAsB,WAAW,CAAC,OAAO,GAAE,OAAO,CAAC,SAAS,CAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAuBtF"}
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../src/deps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,cAAc,EAEd,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,WAAW,EACjB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,SAAS;IACxB,kBAAkB,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACvF,QAAQ,EAAE;QACR,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,cAAc,CAAC;QACtF,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;QAC9E,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,cAAc,CAAC;QAClH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/D,OAAO,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;KACtD,CAAC;IACF,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CACd,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,eAAe,CAAC,CAAC;IAC5B,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBxE;AAED,wBAAsB,WAAW,CAAC,OAAO,GAAE,OAAO,CAAC,SAAS,CAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAuBtF"}

package/dist/deps.js

@@ -1,6 +1,6 @@
 import { ModelRuntime, SessionManager, createAgentSession, } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { connectDefaultMcpClient } from "./mcp-bridge.js";
+import { connectDefaultMcpClient, } from "./mcp-bridge.js";
 export function realSleep(ms, signal) {
     return new Promise((resolve, reject) => {
         if (signal.aborted) {
@@ -34,6 +34,6 @@ export async function resolveDeps(partial = {}) {
         graceMs: partial.graceMs ?? 5_000,
         mcpTimeoutMs,
         connectMcpClient: partial.connectMcpClient ??
-            ((server, signal) => connectDefaultMcpClient(server, signal, mcpTimeoutMs, sleep)),
+            ((server, signal, binding) => connectDefaultMcpClient(server, signal, mcpTimeoutMs, sleep, binding)),
     };
 }