@clawdbuilder/jig-bedrock 0.0.0-stage → 0.1.1

package/src/doctor.ts

@@ -0,0 +1,172 @@
+import { spawn } from "node:child_process";
+import type { ResolvedConfig } from "./config.ts";
+import { executableExists, usageExecutable } from "./usage.ts";
+
+type CheckStatus = "ready" | "old" | "missing" | "timeout" | "cancelled" | "overflow" | "unrecognized" | "unavailable";
+export interface DependencyCheck {
+    status: CheckStatus;
+    version?: string;
+}
+export interface LocalDependencyHealth {
+    node: DependencyCheck;
+    aws: DependencyCheck;
+    bash: DependencyCheck;
+    jq: DependencyCheck;
+    usage: boolean;
+    platform: NodeJS.Platform;
+}
+interface CheckOptions {
+    signal?: AbortSignal;
+    env?: NodeJS.ProcessEnv;
+    nodeVersion?: string;
+    platform?: NodeJS.Platform;
+    timeout?: number;
+}
+type Tool = "aws" | "bash" | "jq";
+const commands: Record<Tool, string[]> = {
+    aws: ["--version"],
+    bash: ["--noprofile", "--norc", "--version"],
+    jq: ["--version"],
+};
+const patterns: Record<Tool, RegExp> = {
+    aws: /\baws-cli\/(\d{1,6}\.\d{1,6}\.\d{1,6})(?![\d.])/,
+    bash: /\bGNU bash, version (\d{1,6}\.\d{1,6}\.\d{1,6})(?![\d.])/,
+    jq: /\bjq-(\d{1,6}\.\d{1,6}(?:\.\d{1,6})?)(?![\d.])/,
+};
+const atLeast = (version: string, minimum: number[]) => {
+    const parts = version.split(".").map(Number);
+    for (let i = 0; i < minimum.length; i++) {
+        const wanted = minimum[i] ?? 0;
+        if ((parts[i] ?? 0) !== wanted) return (parts[i] ?? 0) > wanted;
+    }
+    return true;
+};
+function versionCheck(version: string | undefined, minimum?: number[]): DependencyCheck {
+    return version
+        ? { status: !minimum || atLeast(version, minimum) ? "ready" : "old", version }
+        : { status: "unrecognized" };
+}
+/** Fixed local version calls. Only numeric versions or closed failure categories leave this function. */
+function probe(tool: Tool, minimum: number[] | undefined, options: CheckOptions): Promise<DependencyCheck> {
+    return new Promise((resolve) => {
+        if (options.signal?.aborted) {
+            resolve({ status: "cancelled" });
+            return;
+        }
+        const source = options.env ?? process.env;
+        const env: NodeJS.ProcessEnv = {
+            PATH: source.PATH ?? "",
+            LANG: "C",
+            LC_ALL: "C",
+            AWS_CLI_AUTO_PROMPT: "off",
+            AWS_PAGER: "",
+            NO_COLOR: "1",
+        };
+        if (source.SystemRoot) env.SystemRoot = source.SystemRoot;
+        let child: ReturnType<typeof spawn>,
+            bytes = 0,
+            settled = false;
+        const output: Buffer[] = [];
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const stop = () => {
+            if (!child?.pid) return;
+            try {
+                process.kill(process.platform === "win32" ? child.pid : -child.pid, "SIGKILL");
+            } catch {}
+        };
+        const finish = (result: DependencyCheck) => {
+            if (settled) return;
+            settled = true;
+            if (timer) clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abort);
+            if (result.status !== "ready" && result.status !== "old") stop();
+            resolve(result);
+        };
+        const abort = () => finish({ status: "cancelled" });
+        try {
+            child = spawn(tool, commands[tool], {
+                shell: false,
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: process.platform !== "win32",
+                windowsHide: true,
+            });
+        } catch {
+            finish({ status: "unavailable" });
+            return;
+        }
+        const collect = (chunk: Buffer) => {
+            if (settled) return;
+            bytes += chunk.length;
+            if (bytes > 16_384) finish({ status: "overflow" });
+            else output.push(chunk);
+        };
+        child.stdout!.on("data", collect);
+        child.stderr!.on("data", collect);
+        child.on("error", (error: NodeJS.ErrnoException) =>
+            finish({ status: error.code === "ENOENT" || error.code === "EACCES" ? "missing" : "unavailable" }),
+        );
+        child.on("close", (code) =>
+            finish(
+                code === 0
+                    ? versionCheck(patterns[tool].exec(Buffer.concat(output).toString("utf8"))?.[1], minimum)
+                    : { status: "unavailable" },
+            ),
+        );
+        options.signal?.addEventListener("abort", abort, { once: true });
+        timer = setTimeout(() => finish({ status: "timeout" }), options.timeout ?? 3_000);
+        timer.unref();
+        if (options.signal?.aborted) abort();
+    });
+}
+export async function checkLocalDependencies(
+    config: ResolvedConfig,
+    options: CheckOptions = {},
+): Promise<LocalDependencyHealth> {
+    const platform = options.platform ?? process.platform;
+    const nodeVersion = /^(\d{1,6}\.\d{1,6}\.\d{1,6})$/.exec(options.nodeVersion ?? process.versions.node)?.[1];
+    const [aws, bash, jq] = await Promise.all([
+        probe("aws", [2, 0, 0], options),
+        probe("bash", [4, 0, 0], options),
+        probe("jq", platform === "darwin" ? [1, 8] : undefined, options),
+    ]);
+    return {
+        node: versionCheck(nodeVersion, [22, 19, 0]),
+        aws,
+        bash,
+        jq,
+        usage: executableExists(usageExecutable(config)),
+        platform,
+    };
+}
+const statusText: Record<CheckStatus, string> = {
+    ready: "ready",
+    old: "upgrade required",
+    missing: "missing",
+    timeout: "version check timed out",
+    cancelled: "version check cancelled",
+    overflow: "version output exceeded limit",
+    unrecognized: "version not recognized",
+    unavailable: "version check failed",
+};
+export function dependencyLines(health: LocalDependencyHealth): string[] {
+    const line = (name: string, check: DependencyCheck, requirement: string) =>
+        `${name}: ${check.version ?? "unknown"} · ${statusText[check.status]}${requirement ? ` (${requirement})` : ""}`;
+    return [
+        line("Node (this Pi process)", health.node, "requires 22.19+"),
+        line("AWS CLI", health.aws, "requires v2"),
+        line("Bash", health.bash, "usage program statistics require 4+"),
+        line(
+            "jq",
+            health.jq,
+            health.platform === "darwin"
+                ? "usage program on macOS requires 1.8+"
+                : "usage program statistics dependency; no documented Linux version floor",
+        ),
+        `usage program executable: ${health.usage ? "found" : "missing"} (optional; not executed by this check)`,
+        ...(health.aws.version && atLeast(health.aws.version, [2, 0, 0]) && !atLeast(health.aws.version, [2, 22, 0])
+            ? ["usage program's tooling check requires AWS CLI 2.22 or later."]
+            : []),
+        "Only local --version output is checked; IAM access and the full usage program toolchain are not verified.",
+    ];
+}

package/src/events.ts

@@ -0,0 +1,46 @@
+// What the provider tells other plugins on Pi's event bus, in the shapes optional Jig display plugins read. Neither is imported:
+// an event nobody listens to does nothing.
+//
+//   jig-theme:segment      { id, label, tone? }                    an optional footer part
+//   jig-lens:model-names   { models: [{ recorded, name, provider }] }   names for recorded models
+import type { Budget } from "./budget.ts";
+import type { TeamBedrockModel } from "./catalog.ts";
+import { JIG_BEDROCK } from "./identity.ts";
+
+export const SEGMENT_EVENT = "jig-theme:segment";
+export const MODEL_NAMES_EVENT = "jig-lens:model-names";
+export const SEGMENT_ID = "bedrock-spend";
+/** The share of the budget from which the part turns to a warning. */
+export const AMBER_FROM = 0.8;
+
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const money = (value: number): string => `$${value >= 10 ? String(Math.round(value)) : value.toFixed(2)}`;
+
+export interface Segment {
+    id: string;
+    label: string;
+    tone?: "normal" | "warning" | "error";
+}
+
+/**
+ * `Oct $203 / $200`; a trailing + on the spend means some usage had no price, so it is a lower bound. A warning from 80% of the
+ * budget, an error at or above it. A figure from another month is not shown (the month rolls over in UTC, as the extension
+ * counts it), and a part with nothing to say has an empty label, which removes it.
+ */
+export function spendSegment(budget: Budget | undefined, now: number): Segment {
+    if (budget === undefined || new Date(now).toISOString().slice(0, 7) !== budget.monthUtc) {
+        return { id: SEGMENT_ID, label: "" };
+    }
+    const month = MONTHS[Number(budget.monthUtc.slice(5)) - 1] ?? budget.monthUtc;
+    const limit = budget.limitUsd !== undefined && budget.limitUsd > 0 ? budget.limitUsd : undefined;
+    const label = `${month} ${money(budget.spentUsd)}${budget.unpriced ? "+" : ""}${limit === undefined ? "" : ` / ${money(limit)}`}`;
+    const used = limit === undefined ? 0 : budget.spentUsd / limit;
+    return { id: SEGMENT_ID, label, tone: used >= 1 ? "error" : used >= AMBER_FROM ? "warning" : "normal" };
+}
+
+/** Pi records a reply under the inference profile's ARN, which says nothing to a reader: this names it by the model's id. */
+export function modelNames(models: readonly TeamBedrockModel[]): {
+    models: Array<{ recorded: string; name: string; provider: string }>;
+} {
+    return { models: models.map((model) => ({ recorded: model.arn, name: model.id, provider: JIG_BEDROCK })) };
+}

package/src/identity.ts

@@ -0,0 +1,3 @@
+export const JIG_BEDROCK = "jig-bedrock";
+export const isJigBedrock = (model: { provider?: string } | undefined) =>
+    model?.provider === JIG_BEDROCK || model?.provider === "amazon-bedrock";

package/src/index.ts

@@ -0,0 +1,33 @@
+// Pi entry point of the Bedrock provider. The factory only registers: no network, no processes, no timers and no file
+// writes. jig-core must load before this extension for its `bedrock` section to apply (Jig's own order); in plain Pi the
+// provider reads ~/.pi/agent/bedrock.json and the JIG_BEDROCK_* environment. AWS, the usage program and the browser are
+// touched once a session starts, on a request, or by a command the user types.
+import type { ExtensionAPI, ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import { validateBedrock } from "./config.ts";
+import { jigApi, withJig } from "./jig/client.ts";
+import type { BedrockOptions } from "./provider.ts";
+import { createJigBedrock } from "./provider.ts";
+
+export type { BedrockOptions };
+
+/** The extension. `options` replace the parts of the machine a test fakes: the catalog, the budget, the SSO recovery. */
+export function jigBedrock(options: BedrockOptions = {}): ExtensionFactory {
+    return async (pi: ExtensionAPI) => {
+        // jig-core must already be loaded for its section to apply; a later load only registers the section, because
+        // the provider has read its settings by then. Plain Pi uses bedrock.json and the JIG_BEDROCK_* environment.
+        const api = jigApi();
+        withJig((loaded) => {
+            loaded.config.registerSection("bedrock", validateBedrock);
+            if (api === undefined)
+                pi.on("session_start", (_event, ctx) =>
+                    ctx.ui.notify(
+                        "jig-core loaded after the Bedrock provider, so its bedrock section is ignored this session; reload Pi to apply it.",
+                        "warning",
+                    ),
+                );
+        });
+        await createJigBedrock({ ...options, ...(api === undefined ? {} : { api }) })(pi).catch(() => undefined);
+    };
+}
+
+export default jigBedrock();

package/src/jig/client.ts

@@ -0,0 +1,63 @@
+// How the Bedrock provider reaches jig-core at run time. A copy of jig-core's client.ts (plugins/jig-core/src/client.ts in Jig),
+// kept identical apart from the import below: jig-core publishes its API on a process-wide symbol when it loads, and a provider
+// keeps its own copy of this lookup instead of importing jig-core, so it loads in either order and can be split out.
+// test/client.test.ts compares this file with the checkout in JIG_DIR, so a change in Jig's copy fails there.
+import type { JigApi } from "./types.ts";
+
+const API = Symbol.for("jig.core.api/v1");
+const PENDING = Symbol.for("jig.core.pending/v1");
+
+type Slot = typeof globalThis & {
+    [API]?: JigApi;
+    [PENDING]?: Array<(api: JigApi) => void>;
+};
+
+const slot = globalThis as Slot;
+
+/** The API when jig-core has already loaded; undefined in plain Pi. */
+export function jigApi(): JigApi | undefined {
+    return slot[API];
+}
+
+/** jig-core's API. Throws when jig-core is not loaded, so a Jig tool fails closed instead of running
+ *  ungoverned. */
+export function jig(): JigApi {
+    const api = slot[API];
+    if (api === undefined) throw new Error("jig-core is not loaded: enable jig-core, which governs every Jig tool");
+    return api;
+}
+
+/** Runs `use` now if jig-core is loaded, otherwise as soon as it loads. */
+export function withJig(use: (api: JigApi) => void): void {
+    const api = slot[API];
+    if (api !== undefined) {
+        use(api);
+        return;
+    }
+    const pending = slot[PENDING] ?? [];
+    slot[PENDING] = pending;
+    pending.push(use);
+}
+
+/** For jig-core only: publishes the API and runs what plugins queued before it loaded. One plugin's failing
+ *  callback does not stop the others: every callback runs, and the errors come back for jig-core to report. */
+export function publishJig(api: JigApi): unknown[] {
+    slot[API] = api;
+    const pending = slot[PENDING] ?? [];
+    slot[PENDING] = [];
+    const errors: unknown[] = [];
+    for (const use of pending) {
+        try {
+            use(api);
+        } catch (error) {
+            errors.push(error);
+        }
+    }
+    return errors;
+}
+
+/** For jig-core only: withdraws the API when its runtime ends (reload, session replacement, exit), so a plugin
+ *  loading into the next runtime waits for the new jig-core instead of declaring into the old one. */
+export function withdrawJig(api: JigApi): void {
+    if (slot[API] === api) delete slot[API];
+}

package/src/jig/types.ts

@@ -0,0 +1,12 @@
+// The small part of Jig's runtime API this package uses. The package works without Jig; when Jig is present, `jig()` reads
+// this through the process-wide slot in ./client.ts.
+export interface JigApi {
+    readonly config: {
+        registerSection(
+            name: string,
+            validate: (value: unknown) => string[],
+            options?: { union?: readonly string[]; replace?: readonly string[] },
+        ): void;
+        section(name: string): unknown;
+    };
+}

package/src/login.ts

@@ -0,0 +1,176 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { closeSync, lstatSync, mkdirSync, openSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { atomicCache } from "./cache.ts";
+import { boundedRegular } from "./catalog.ts";
+import { profilePattern, type ResolvedConfig } from "./config.ts";
+import { type Recover, SsoRecoveryError, shareRecovery } from "./sso.ts";
+import { loginEnvironment, systemWsl, type WslDeps } from "./wsl.ts";
+/** Never create an inherited system runtime path or repair unrelated permissions. */
+export function ssoRuntime(env: NodeJS.ProcessEnv = process.env): string {
+    const safe = (path: string, privateMode = false) => {
+        try {
+            const meta = lstatSync(path);
+            return (
+                meta.isDirectory() &&
+                !meta.isSymbolicLink() &&
+                meta.uid === process.getuid?.() &&
+                (meta.mode & (privateMode ? 0o077 : 0o022)) === 0
+            );
+        } catch {
+            return false;
+        }
+    };
+    if (env.XDG_RUNTIME_DIR?.startsWith("/") && safe(env.XDG_RUNTIME_DIR, true)) return env.XDG_RUNTIME_DIR;
+    const home = env.HOME;
+    if (!home?.startsWith("/") || !safe(home)) throw new SsoRecoveryError("runtime");
+    let path = home;
+    for (const component of [".local", "state", "jig-bedrock", "sso-runtime"]) {
+        path = join(path, component);
+        try {
+            mkdirSync(path, { mode: 0o700 });
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw new SsoRecoveryError("runtime");
+        }
+        if (!safe(path)) throw new SsoRecoveryError("runtime");
+    }
+    if (!safe(path, true)) throw new SsoRecoveryError("runtime");
+    return path;
+}
+/** What a test replaces in the sign-in: the program that starts the login, the lock, the time, the environment, WSL, the notices. */
+export interface RecoveryOptions {
+    /** How the login program is started. */
+    start?: typeof spawn;
+    /** The lock file, instead of one in the private runtime folder. */
+    lock?: string;
+    timeoutMs?: number;
+    /** The environment the login starts from (default: Pi's own, read when the login starts). */
+    env?: NodeJS.ProcessEnv;
+    wsl?: WslDeps;
+    /** Where the one-line notice of a repair goes (see wsl.ts). */
+    say?: (line: string) => void;
+}
+
+export function createRecovery(config: ResolvedConfig, options: RecoveryOptions = {}): Recover {
+    const { start = spawn, lock: explicitLock, timeoutMs = 300_000, wsl = systemWsl, say = () => {} } = options;
+    return shareRecovery(async (profile, signal) => {
+        if (!profilePattern.test(profile)) throw new Error("Invalid AWS profile");
+        const runtime = explicitLock ? undefined : ssoRuntime();
+        const lock = explicitLock ?? join(runtime!, "bedrock-sso.lock");
+        const deadline = Date.now() + timeoutMs;
+        let waited: string | undefined;
+        const token = randomUUID();
+        while (true) {
+            signal?.throwIfAborted();
+            if (Date.now() >= deadline) throw new SsoRecoveryError("timeout");
+            try {
+                const fd = openSync(lock, "wx", 0o600);
+                writeFileSync(fd, JSON.stringify({ pid: process.pid, profile, token }));
+                closeSync(fd);
+                break;
+            } catch (e) {
+                if ((e as NodeJS.ErrnoException).code !== "EEXIST") throw new SsoRecoveryError("runtime");
+                try {
+                    const owner = JSON.parse(boundedRegular(lock, 1024, true) || "{}");
+                    if (!Number.isInteger(owner.pid) || owner.pid <= 0) throw new Error("invalid lock");
+                    try {
+                        process.kill(owner.pid, 0);
+                    } catch (err) {
+                        if ((err as NodeJS.ErrnoException).code === "ESRCH") {
+                            unlinkSync(lock);
+                            continue;
+                        }
+                    }
+                    waited = owner.profile === profile && typeof owner.token === "string" ? owner.token : undefined;
+                } catch {
+                    try {
+                        const meta = lstatSync(lock);
+                        if (!meta.isFile() || meta.isSymbolicLink()) throw new SsoRecoveryError("runtime");
+                        if (Date.now() - meta.mtimeMs > timeoutMs + 1000) {
+                            unlinkSync(lock);
+                            continue;
+                        }
+                    } catch (error) {
+                        if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+                        throw error;
+                    }
+                }
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                // A completed same-profile login is reused by waiting sessions.
+                try {
+                    lstatSync(lock);
+                } catch {
+                    if (waited) {
+                        signal?.throwIfAborted();
+                        try {
+                            const result = JSON.parse(boundedRegular(`${lock}.result`, 1024, true) || "{}");
+                            if (result.token === waited && result.ok === true) return;
+                        } catch {}
+                        throw new Error("Shared SSO login did not complete; run /aws-login");
+                    }
+                }
+            }
+        }
+        let succeeded = false;
+        try {
+            // The login's environment: Pi's own, the private runtime folder, and on WSL a browser that opens and an interop
+            // socket that answers (wsl.ts). The probe takes up to two seconds, under the lock, and only when a login starts.
+            const login = await loginEnvironment(
+                { browser: config.browser },
+                { ...(options.env ?? process.env), ...(runtime ? { XDG_RUNTIME_DIR: runtime } : {}) },
+                wsl,
+            );
+            for (const line of login.notes) say(line);
+            signal?.throwIfAborted();
+            await new Promise<void>((resolve, reject) => {
+                const argv = config.ssoLoginCommand.map((s) => s.replaceAll("{profile}", profile));
+                const child = start(argv[0] ?? "", argv.slice(1), { detached: true, stdio: "ignore", env: login.env });
+                let stopped = false;
+                let timedOut = false;
+                const stop = () => {
+                    if (stopped) return;
+                    stopped = true;
+                    if (child.pid) {
+                        try {
+                            process.kill(-child.pid, "SIGTERM");
+                        } catch {}
+                        const kill = setTimeout(() => {
+                            try {
+                                process.kill(-child.pid!, "SIGKILL");
+                            } catch {}
+                        }, 500);
+                        kill.unref();
+                    }
+                };
+                const timer = setTimeout(
+                    () => {
+                        timedOut = true;
+                        stop();
+                    },
+                    Math.max(1, deadline - Date.now()),
+                );
+                signal?.addEventListener("abort", stop, { once: true });
+                const finish = (ok: boolean) => {
+                    clearTimeout(timer);
+                    signal?.removeEventListener("abort", stop);
+                    ok && !stopped
+                        ? resolve()
+                        : reject(new SsoRecoveryError(signal?.aborted ? "cancelled" : timedOut ? "timeout" : "login"));
+                };
+                child.once("error", () => finish(false));
+                child.once("close", (code) => finish(code === 0));
+                if (signal?.aborted) stop();
+            });
+            succeeded = true;
+        } finally {
+            try {
+                atomicCache(`${lock}.result`, { token, ok: succeeded });
+            } finally {
+                try {
+                    unlinkSync(lock);
+                } catch {}
+            }
+        }
+    });
+}

package/src/messages.ts

@@ -0,0 +1,45 @@
+// Per-model facts for Bedrock's Anthropic Messages route. Bedrock asks for the newer thinking shape on the Claude 5.5
+// generation (adaptive, with output_config.effort) and refuses Pi's `thinking: {type: "disabled"}` on Sonnet 5.5, asking for
+// `between_tools` instead; older Claude models still take budget thinking. Nothing here guesses beyond the generation the real
+// run covered: a model only gets a rewrite when its family is listed below.
+const ANTHROPIC = /^(?:[a-z0-9-]+\.)?anthropic\./;
+const CLAUDE_55 = /^(?:[a-z0-9-]+\.)?anthropic\.claude-(?:sonnet|opus|haiku)-5-5$/;
+// Sonnet 5.5 is the one model the real run proved needs between_tools when thinking is off; Opus and Haiku have not been
+// tested with thinking off, so they stay as Pi sends them.
+const BETWEEN_TOOLS = /^(?:[a-z0-9-]+\.)?anthropic\.claude-sonnet-5-5$/;
+// Opus 5.5 cannot turn thinking off at all: the real run got the adaptive error on off. Pi reads a null level as "not
+// available", so off leaves the picker and a saved off clamps to the lowest level Pi has.
+const NO_OFF = /^(?:[a-z0-9-]+\.)?anthropic\.claude-opus-5-5$/;
+
+/** A foundation model served by Bedrock's Anthropic Messages route. Anything else stays on its own route. */
+export function isAnthropicModel(foundationModelId: string): boolean {
+    return ANTHROPIC.test(foundationModelId);
+}
+
+/** The Claude generation that wants adaptive thinking; the older ones keep Pi's budget thinking. */
+export function usesAdaptiveThinking(foundationModelId: string): boolean {
+    return CLAUDE_55.test(foundationModelId);
+}
+
+/** Whether thinking-off is sent as `between_tools`. */
+export function needsBetweenTools(foundationModelId: string): boolean {
+    return BETWEEN_TOOLS.test(foundationModelId);
+}
+
+/** Whether the model has no thinking-off at all, which Pi expresses as a null entry in its thinking level map. */
+export function noThinkingOff(foundationModelId: string): boolean {
+    return NO_OFF.test(foundationModelId);
+}
+
+/**
+ * Pi sends `thinking: {type: "disabled"}` when the level is off. Sonnet 5.5 answers with a 400 naming `between_tools`, so the
+ * payload is rewritten for that model only; every other payload and model is returned as it came.
+ */
+export function rewriteThinkingOff(
+    payload: Record<string, unknown>,
+    foundationModelId: string,
+): Record<string, unknown> {
+    const thinking = payload.thinking as { type?: unknown } | undefined;
+    if (thinking?.type !== "disabled" || !needsBetweenTools(foundationModelId)) return payload;
+    return { ...payload, thinking: { type: "between_tools" } };
+}

package/src/pi-host.ts

@@ -0,0 +1,54 @@
+// Where Pi is installed, to load the AWS SDK the way Pi's own Bedrock provider does. Pi gives an extension its own packages but not
+// the SDK behind them, which sits in Pi's install; `createRequire` from there finds it. The old toolkit used
+// PI_HOST_DIR, else the global npm install next to this Node. This keeps both and tries a third first: the install the running
+// `pi` command belongs to, found by walking up from the real path of the script Node was started with.
+import { readFileSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+const PI_PACKAGE = "@earendil-works/pi-coding-agent";
+
+function isPi(dir: string): boolean {
+    try {
+        return (
+            (JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8")) as { name?: unknown }).name === PI_PACKAGE
+        );
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Pi's package folder. `PI_HOST_DIR` wins when it is set (it is the folder, taken as it is). Otherwise the folder above the script
+ * Node started (`argv1`, with links followed) that is Pi's package, then the global npm install beside `execPath`. Undefined when
+ * none is Pi.
+ */
+export function findPiHost(
+    env: NodeJS.ProcessEnv = process.env,
+    execPath: string = process.execPath,
+    argv1: string | undefined = process.argv[1],
+): string | undefined {
+    if (env.PI_HOST_DIR) return env.PI_HOST_DIR;
+    if (argv1) {
+        try {
+            for (let dir = path.dirname(realpathSync(argv1)); dir !== path.dirname(dir); dir = path.dirname(dir)) {
+                if (isPi(dir)) return dir;
+            }
+        } catch {
+            // The script is gone or unreadable: try the next place.
+        }
+    }
+    const beside = path.resolve(path.dirname(execPath), "../lib/node_modules", PI_PACKAGE);
+    return isPi(beside) ? beside : undefined;
+}
+
+/** What the SDK's `defaultProvider` takes and gives: a function that resolves the profile's credentials when called. */
+export type CredentialProvider = (init: { profile: string }) => () => Promise<unknown>;
+
+/** `defaultProvider` of the SDK in Pi's install. Throws when Pi or the SDK cannot be found. */
+export function loadCredentialProvider(host: string | undefined): CredentialProvider {
+    if (!host) throw new Error("Pi's install was not found");
+    const require = createRequire(path.join(host, "package.json"));
+    const { defaultProvider } = require("@aws-sdk/credential-provider-node") as { defaultProvider: CredentialProvider };
+    return defaultProvider;
+}

package/src/prompt-cache.ts

@@ -0,0 +1,50 @@
+export type PromptCache = { short: number; long?: number };
+
+const REGION_PREFIX = /^(?:us|eu|apac|au|jp|in|global|us-gov)\./;
+/**
+ * Prompt-cache lifetimes in seconds, from Bedrock's "Supported models and explicit caching limits" table: Claude 4.5 and later
+ * accept a 5-minute or 1-hour checkpoint, older Claude and Nova only the 5-minute one (a `ttl` on those fails validation).
+ * Pi sends cache points only to Claude models; Nova relies on implicit caching and AWS caps its cache at 20K tokens, so for
+ * Nova the lifetime is informative (footer, /session) and Pi's warming economics never select it. Models Bedrock does not
+ * list stay undeclared, which keeps them out of Pi's cache warming.
+ */
+export function promptCacheFor(foundationModelId: string): PromptCache | undefined {
+    const id = foundationModelId.toLowerCase().replace(REGION_PREFIX, "");
+    if (/^amazon\.nova-(?:2-)?(?:micro|lite|pro)(?![a-z0-9])/.test(id)) return { short: 300 };
+    if (!id.startsWith("anthropic.claude")) return undefined;
+    // anthropic.claude-sonnet-4-6, claude-haiku-4-5-20251001-v1:0, claude-opus-5; the 8-digit date is not a minor version.
+    const version = /^anthropic\.claude-(?:opus|sonnet|haiku|fable|mythos)-(\d+)(?:-(\d{1,2})(?!\d))?/.exec(id);
+    if (!version) return { short: 300 };
+    const major = Number(version[1]),
+        minor = Number(version[2] ?? 0);
+    return major > 4 || (major === 4 && minor >= 5) ? { short: 300, long: 3600 } : { short: 300 };
+}
+
+export type Retention = "short" | "long";
+export type Cost = {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    tiers?: readonly { input: number; cacheWrite: number; inputTokensAbove: number }[];
+};
+
+/** `PI_CACHE_RETENTION=long` makes Pi's Bedrock stream write 1-hour cache points; anything else is the 5-minute default. */
+export const retentionOf = (env: NodeJS.ProcessEnv = process.env): Retention =>
+    env.PI_CACHE_RETENTION === "long" ? "long" : "short";
+
+/**
+ * Price per million tokens of writing the prompt cache for a request of `tokens` input tokens. The 5-minute write is the
+ * model's cacheWrite rate; Pi bills a 1-hour write at twice the base input rate (calculateCost in pi-ai), in the pricing
+ * tier the request size falls into.
+ */
+export function cacheWriteRate(cost: Cost, tokens: number, retention: Retention): number {
+    let rates: { input: number; cacheWrite: number } = cost,
+        above = -1;
+    for (const tier of cost.tiers ?? [])
+        if (tokens > tier.inputTokensAbove && tier.inputTokensAbove > above) {
+            rates = tier;
+            above = tier.inputTokensAbove;
+        }
+    return retention === "long" ? rates.input * 2 : rates.cacheWrite;
+}