pi-warden 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -6,6 +6,23 @@ How to keep this current: add the entry in the same pull request as the change,
 
 ## Unreleased
 
+<!-- Empty. Next release starts here. -->
+
+## 0.26.0
+
+### Added
+
+- OpenRouter as a configurable judgment backend (`typesafeBackend` in user config). Set to `"openrouter"` to route Jev decisions through OpenRouter's decisions API instead of api.typesafe.ai. New `src/backend.ts` module; `OPENROUTER_API_KEY` env var; project overrides cannot redirect judgments.
+
+### Changed
+
+- Bumped pi-typesafe to ^0.6.0 (native `backend` option on `TypeSafeOptions`).
+- Deduplicated `resolveBackend` call in `shape.ts`.
+
+### Fixed
+
+- Host-TUI capability guard: the extension no longer crashes when the host's bundled `pi-tui` lacks the `MouseRegion` component (e.g. omp 18.2.5). A missing named import was a link-time error that silently killed every guard, the `/warden` command, and the shortcut. The import is now a namespace property read (`tuiModule.MouseRegion`), which degrades to `undefined` instead of failing. The status widget renders the same guard text without the clickable wrapper.
+
 ## 0.25.0
 
 ### Added

package/dist/backend.d.ts

@@ -0,0 +1,23 @@
+import type { TypeSafeOptions } from "pi-typesafe";
+/** The judgment backend that receives pi-warden's Jev requests. */
+export type JudgmentBackend = "typesafe" | "openrouter";
+/** The host the consent disclosure names as the destination. */
+export declare function backendHost(backend: JudgmentBackend): string;
+/** Adapt the consent text to the active backend by substituting the destination host. */
+export declare function disclosureFor(backend: JudgmentBackend, disclosure: string): string;
+/**
+ * Whether the right credential exists for the chosen backend.
+ * TypeSafe uses the pi-typesafe keystore; other backends use an environment variable.
+ */
+export declare function keyAvailable(backend: JudgmentBackend, env: Record<string, string | undefined>, keystoreUsable: () => boolean): boolean;
+/**
+ * Build the options forwarded to `createTypeSafe`.
+ * The caller must gate on `keyAvailable` before calling `createTypeSafe`.
+ */
+export declare function judgeOptions(config: {
+    maxRequests: number;
+    timeoutMs: number;
+    typesafeBackend: JudgmentBackend;
+}): TypeSafeOptions;
+/** Resolve the effective backend from a raw config value; invalid values fall back to "typesafe". */
+export declare function resolveBackend(raw: unknown): JudgmentBackend;

package/dist/backend.js

@@ -0,0 +1,36 @@
+import { authState } from "pi-typesafe";
+const BACKENDS = {
+    typesafe: { host: "api.typesafe.ai" },
+    openrouter: { host: "openrouter.ai", keyEnv: "OPENROUTER_API_KEY" },
+};
+/** The host the consent disclosure names as the destination. */
+export function backendHost(backend) {
+    return BACKENDS[backend].host;
+}
+/** Adapt the consent text to the active backend by substituting the destination host. */
+export function disclosureFor(backend, disclosure) {
+    return backend === "typesafe" ? disclosure : disclosure.replace(BACKENDS.typesafe.host, BACKENDS[backend].host);
+}
+/**
+ * Whether the right credential exists for the chosen backend.
+ * TypeSafe uses the pi-typesafe keystore; other backends use an environment variable.
+ */
+export function keyAvailable(backend, env, keystoreUsable) {
+    const keyEnv = BACKENDS[backend].keyEnv;
+    return keyEnv ? (env[keyEnv]?.trim() ?? "") !== "" : keystoreUsable();
+}
+/**
+ * Build the options forwarded to `createTypeSafe`.
+ * The caller must gate on `keyAvailable` before calling `createTypeSafe`.
+ */
+export function judgeOptions(config) {
+    return {
+        maxRequests: config.maxRequests,
+        timeoutMs: config.timeoutMs,
+        ...(config.typesafeBackend === "typesafe" ? {} : { backend: config.typesafeBackend }),
+    };
+}
+/** Resolve the effective backend from a raw config value; invalid values fall back to "typesafe". */
+export function resolveBackend(raw) {
+    return raw === "typesafe" || raw === "openrouter" ? raw : "typesafe";
+}

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import type { JudgmentBackend } from "./backend.js";
 import type { WidgetConfig } from "./widget.js";
 export interface Threshold {
     /** P(yes) at or above this shows a warning and continues. */
@@ -217,6 +218,8 @@ export interface WardenConfig {
     enabled: boolean;
     /** Consent to send task and action summaries to api.typesafe.ai. Set by /warden enable; never by a project file. */
     typesafe: boolean;
+    /** The decisions service the judgments go to. User file only: a project must not redirect judgments to another vendor. */
+    typesafeBackend: JudgmentBackend;
     /**
      * steer (default): a confirm-level call is held and the agent receives the judgment as its tool result, so it re-plans or asks
      * the user in chat. confirm: open a dialog and let the user decide (falls back to steer without a UI). advise: never hold; report only.

package/dist/config.js

@@ -1,6 +1,7 @@
 import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { resolveBackend } from "./backend.js";
 import { COMMAND_TOOLS } from "./tools.js";
 import { defaultWidgetConfig } from "./widget.js";
 const RECALL_TOOLS = ["auto", "rg", "ag", "ugrep", "git-grep", "grep", "select-string", "findstr", "none"];
@@ -15,6 +16,7 @@ export function defaultConfig() {
     return {
         enabled: true,
         typesafe: false,
+        typesafeBackend: "typesafe",
         mode: "steer",
         timeoutMs: 5000,
         maxRequests: 500,
@@ -404,6 +406,7 @@ export function applyUserOverrides(base, raw) {
     return {
         enabled: boolean(raw.enabled, base.enabled),
         typesafe: boolean(raw.typesafe, base.typesafe),
+        typesafeBackend: resolveBackend(raw.typesafeBackend),
         mode: isMode(raw.mode) ? raw.mode : base.mode,
         ...shared,
         ...applyGuards(base, raw, shared.timeoutMs, "user"),

package/dist/extension.js

@@ -1,6 +1,8 @@
-import { MouseRegion } from "@earendil-works/pi-tui";
+import * as tuiModule from "@earendil-works/pi-tui";
+const MouseRegion = tuiModule.MouseRegion;
 import { authState, createTypeSafe, describeAuth } from "pi-typesafe";
 import { ensureApiKey } from "pi-typesafe/ui";
+import { backendHost, disclosureFor, judgeOptions, keyAvailable, resolveBackend } from "./backend.js";
 import { ActionGuard } from "./action-guard.js";
 import { ArmingTracker, unparseableArmingRules } from "./arming.js";
 import * as configModule from "./config.js";
@@ -290,11 +292,13 @@ export default function wardenExtension(pi) {
     };
     const consentGiven = (config) => config.typesafe || process.env.PI_WARDEN_ENABLED === "1";
     const consentSource = (config) => config.typesafe ? "/warden enable" : process.env.PI_WARDEN_ENABLED === "1" ? "PI_WARDEN_ENABLED" : undefined;
-    /** A consent flag is not proof that judgments happen; ask pi-typesafe for the real key state. */
+    /** A consent flag is not proof that judgments happen; check the key state for the chosen backend. */
     const judgeFor = (config) => {
-        if (!consentGiven(config) || budgetExhausted || !authState().usable)
+        if (!consentGiven(config) || budgetExhausted)
             return undefined;
-        return client ??= createTypeSafe({ maxRequests: config.maxRequests, timeoutMs: config.timeoutMs });
+        if (!keyAvailable(config.typesafeBackend, process.env, () => authState().usable))
+            return undefined;
+        return client ??= createTypeSafe(judgeOptions(config));
     };
     const noteError = (ctx, message, code) => {
         stats.errors++;
@@ -326,12 +330,18 @@ export default function wardenExtension(pi) {
         }
         const entries = [...widget].map(([guard, line]) => ({ guard, line }));
         // A custom component so the lines wrap to the pane and a click (fullscreen mode) opens the trace panel.
-        ctx.ui.setWidget(WIDGET, (_tui, theme) => new MouseRegion(statusWidget(entries, theme), event => {
-            if (event.type !== "click" || event.button !== "left")
-                return undefined;
-            togglePanel(lastUi, config);
-            return { handled: true };
-        }), { placement: config.widget.placement });
+        // When the host TUI lacks MouseRegion (e.g. omp 18.2.5), the extension still loads — the widget
+        // renders the same text, but a click does nothing. A missing named import is a link-time error
+        // that kills the entire extension silently; a missing namespace property is undefined.
+        ctx.ui.setWidget(WIDGET, (_tui, theme) => {
+            const body = statusWidget(entries, theme);
+            return MouseRegion ? new MouseRegion(body, event => {
+                if (event.type !== "click" || event.button !== "left")
+                    return undefined;
+                togglePanel(lastUi, config);
+                return { handled: true };
+            }) : body;
+        }, { placement: config.widget.placement });
     };
     const record = (ctx, config, guard, line, details) => {
         widget.set(guard, line);
@@ -1138,7 +1148,7 @@ export default function wardenExtension(pi) {
                     const usage = client?.getUsage();
                     const guards = [config.action.enabled && "action", config.stuck.enabled && "stuck", config.done.enabled && "done-check", config.slop.enabled && "slop", config.slop.enabled && config.slop.prose.enabled && `prose (${config.slop.prose.audience})`, config.security.enabled && "security", config.rules.enabled && "rules", config.context.enabled && "context", config.runaway.enabled && "runaway", config.subagent.enabled && "subagent triage", config.notify.enabled && "desktop notifications"].filter(Boolean).join(", ");
                     report([
-                        `pi-warden: ${config.enabled ? `guarding ${config.action.tools.join(", ")} (${guards})` : "off"}; mode ${activeMode(config, ctx.hasUI)}; TypeSafe judgments ${source ? `consented via ${source}` : "not consented (run /warden enable)"}; ${auth.text}`,
+                        `pi-warden: ${config.enabled ? `guarding ${config.action.tools.join(", ")} (${guards})` : "off"}; mode ${activeMode(config, ctx.hasUI)}; TypeSafe judgments ${source ? `consented via ${source}` : "not consented (run /warden enable)"}${config.typesafeBackend !== "typesafe" ? ` (${config.typesafeBackend})` : ""}; ${auth.text}`,
                         `Session: ${stats.inspected} inspected, ${stats.judged} judged, ${stats.warned} warned, ${stats.held} held, ${stats.approved} approved on retry, ${stats.offPlan} off plan, ${stats.offTask} off task, ${stats.slop} slop notes, ${stats.ruleViolations}/${stats.ruleChecks} rule violations, ${stats.pathNotes} sensitive-path notes, ${stats.stuck}/${stats.stuckChecks} stuck, ${stats.unverified}/${stats.doneChecks} unverified done, ${stats.proseNudges}/${stats.proseChecks} prose nudges, ${stats.runaway} runaway stops, ${stats.subagentWoken}/${stats.subagentReports} subagent reports woken, ${stats.restatements} restatements, ${stats.errors} TypeSafe errors; ${usage?.requestsStarted ?? 0}/${config.maxRequests} requests. Steers are ${config.steerVisible ? "shown in the transcript" : "hidden from the transcript (trace panel shows them)"}. Steer budget: ${config.steerBudget === 0 ? "off" : `${config.steerBudget} per run`}.`,
                         formatSteers(stats),
                         `Thresholds: irreversible warn ${config.action.irreversible.warn} / hold ${config.action.irreversible.confirm}; off-task warn ${config.action.offTask.warn} / steer ${config.action.offTask.steer} (never holds); intent mismatch ${config.action.intentMismatch} (${config.action.visibleMismatch} on a visible action); stuck same-strategy ${config.stuck.sameStrategy} after ${config.stuck.minFailures} failures; done claims ${config.done.claimsDone}; slop ${config.slop.threshold}, rules ${config.rules.threshold}, prose ${config.slop.prose.threshold} in ${config.slop.prose.trend}/3 replies; runaway ${config.runaway.repeats} repeats (thinking ${config.runaway.thinkingRepeats}), recover ${config.runaway.recover}; failOpen ${config.action.failOpen}.`,
@@ -1225,7 +1235,7 @@ export default function wardenExtension(pi) {
                 }
                 if (action === "test") {
                     const judge = judgeFor(config);
-                    if (judge && ctx.hasUI && !await ctx.ui.confirm("Send one synthetic pi-warden test request?", `A synthetic action ("rm -rf /tmp/pi-warden-demo" for the task "Clean up the demo directory") goes to api.typesafe.ai and may incur charges. ${disclosure}`))
+                    if (judge && ctx.hasUI && !await ctx.ui.confirm("Send one synthetic pi-warden test request?", `A synthetic action ("rm -rf /tmp/pi-warden-demo" for the task "Clean up the demo directory") goes to ${backendHost(config.typesafeBackend)} and may incur charges. ${disclosureFor(config.typesafeBackend, disclosure)}`))
                         return;
                     const verdict = await evaluateAction({ tool: "bash", input: { command: "rm -rf /tmp/pi-warden-demo" }, cwd: ctx.cwd, task: "Clean up the demo directory" }, { config: { ...config.action, enabled: true, tools: ["bash"] }, judge });
                     record(ctx, config, "action", formatVerdict(verdict, config.widget.action), actionDetails(verdict, { mode: activeMode(config, ctx.hasUI) }));