pi-advisor-flow 0.11.2 → 0.11.3-dev.1

package/src/ui/jev-setup-support.ts

@@ -0,0 +1,173 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { noul } from "@typesafe-ai/sdk";
+
+import type { JevTransport } from "../config/types.ts";
+import { jevClientFromCredentials } from "../jev/client.ts";
+import { OPENAI_DECISIONS_MODEL } from "../jev/decisions-client.ts";
+import {
+  clearKeyTypeSafeKey,
+  removeTypeSafeKeyFromAdvisorJson,
+  writeKeyTypeSafeKey,
+} from "../jev/key-store.ts";
+import {
+  clearOpenAIDecisionsKey,
+  writeOpenAIDecisionsKey,
+} from "../jev/openai-key-store.ts";
+import {
+  resolveJevTransport,
+  resolveJevTransportFor,
+} from "../jev/transport.ts";
+import type { JevCredentials, JevTransportKind } from "../jev/transport.ts";
+import { redactSecrets } from "../redaction.ts";
+import type {
+  JevSetupDeps,
+  JevSetupSelection,
+  RenderRequester,
+} from "./types.ts";
+
+export interface JevSetupSubmenuOptions {
+  afterSelection?: () => void;
+  currentTransport: JevTransport;
+  currentValue: string;
+  done: (selectedValue?: string) => void;
+  onSelection?: (selection: JevSetupSelection) => boolean;
+  setupDeps?: JevSetupDeps;
+  theme: Theme;
+  tui: RenderRequester;
+}
+
+export type JevSetupOverrides = JevSetupDeps;
+export type SetupMode =
+  | "menu"
+  | "key-entry"
+  | "resolving"
+  | "verifying"
+  | "clearing";
+export type SetupAction =
+  | JevTransportKind
+  | "clear-stored-key"
+  | "disable"
+  | "done"
+  | "enter-key";
+
+export interface JevSetupViewState {
+  canEnterKey: boolean;
+  credentials: JevCredentials | undefined;
+  filterEnabled: boolean;
+  mode: SetupMode;
+  notice: string | undefined;
+  selectedIndex: number;
+  selectedTransport: JevTransportKind | undefined;
+}
+
+export const fireAndForget = async (
+  action: Promise<unknown>,
+  onError: (message: string) => void
+): Promise<void> => {
+  try {
+    await action;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    onError(redactSecrets(message));
+  }
+};
+
+export const providerName = (transport: JevTransportKind): string => {
+  if (transport === "typesafe") {
+    return "TypeSafe Jev";
+  }
+  if (transport === "openrouter") {
+    return "OpenRouter (Pi login)";
+  }
+  return `OpenAI Decisions (${OPENAI_DECISIONS_MODEL})`;
+};
+
+export const transportLabel = (credentials: JevCredentials): string => {
+  if (credentials.transport === "openrouter") {
+    return "OpenRouter (reusing Pi login)";
+  }
+  if (credentials.transport === "openai-decisions") {
+    let source = "verified API key";
+    switch (credentials.source) {
+      case "openai-bun-secrets": {
+        source = "Bun.secrets";
+        break;
+      }
+      case "openai-env": {
+        source = "OPENAI_API_KEY";
+        break;
+      }
+      case "openai-file": {
+        source = "stored file, mode 0600";
+        break;
+      }
+      case "openai-provider-credential": {
+        source = "Pi stored API key";
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+    return `OpenAI Decisions (${OPENAI_DECISIONS_MODEL}; key: ${source})`;
+  }
+  switch (credentials.source) {
+    case "advisor-json": {
+      return "TypeSafe (key: advisor.json — plaintext, not recommended)";
+    }
+    case "bun-secrets": {
+      return "TypeSafe (key: Bun.secrets)";
+    }
+    case "file": {
+      return "TypeSafe (key: stored file, mode 0600)";
+    }
+    default: {
+      return "TypeSafe (key: TYPESAFE_API_KEY)";
+    }
+  }
+};
+
+export const canClearCredential = (credentials: JevCredentials) =>
+  credentials.source === "bun-secrets" ||
+  credentials.source === "file" ||
+  credentials.source === "openai-bun-secrets" ||
+  credentials.source === "openai-file";
+
+export const canReplaceWithEnteredKey = (credentials: JevCredentials) =>
+  credentials.transport === "typesafe" ||
+  (credentials.transport === "openai-decisions" &&
+    (credentials.source === "openai-bun-secrets" ||
+      credentials.source === "openai-file"));
+
+export const defaultVerify = async (credentials: JevCredentials) => {
+  const client = jevClientFromCredentials(credentials);
+  try {
+    await client.ask(
+      { purpose: "pi-advisor setup verification" },
+      { verified: noul("Answer yes.") }
+    );
+    return { ok: true };
+  } catch (error) {
+    return {
+      message: error instanceof Error ? error.message : String(error),
+      ok: false,
+    };
+  }
+};
+
+export const defaultSetupDeps: Required<JevSetupDeps> = {
+  clearStoredKey: (transport) =>
+    transport === "openai-decisions"
+      ? clearOpenAIDecisionsKey()
+      : clearKeyTypeSafeKey(),
+  removePlaintextKey: removeTypeSafeKeyFromAdvisorJson,
+  resolveTransport: (transport) =>
+    transport ? resolveJevTransportFor(transport) : resolveJevTransport(),
+  verify: defaultVerify,
+  writeKey: (key, transport) =>
+    transport === "openai-decisions"
+      ? writeOpenAIDecisionsKey(key)
+      : writeKeyTypeSafeKey(key),
+};
+
+export { consumePlaintextKeyWarning as consumeSetupPlaintextWarning } from "../jev/key-store.ts";

package/src/ui/settings-items.ts

@@ -33,6 +33,8 @@ import { FALLBACK_ADVISOR_MODEL_DISABLED } from "./types.ts";
 import type {
   AdvisorSettings,
   ContextPreset,
+  JevSetupDeps,
+  JevSetupSelection,
   RenderRequester,
 } from "./types.ts";
 
@@ -42,6 +44,9 @@ export interface SettingsItemsOptions {
   modelWhitelist: SettingItem;
   presets: ContextPreset[];
   settings: AdvisorSettings;
+  afterJevSetup?: () => void;
+  jevSetupDeps?: JevSetupDeps;
+  onJevSetup?: (selection: JevSetupSelection) => boolean;
   theme: Theme;
   tui: RenderRequester;
 }
@@ -78,16 +83,28 @@ const scoutTimeoutItem = (settings: AdvisorSettings): SettingItem => {
 const jevItems = (
   settings: AdvisorSettings,
   theme: Theme,
-  tui: RenderRequester
+  tui: RenderRequester,
+  jevSetupDeps?: JevSetupDeps,
+  onJevSetup?: (selection: JevSetupSelection) => boolean,
+  afterJevSetup?: () => void
 ): SettingItem[] => [
   {
     currentValue: settingValue(settings.jevFilterEnabled, false),
     description:
-      "Screen low-stakes ask_advisor consultations with Jev; guided setup verifies credentials.",
+      "Screen low-stakes ask_advisor consultations with Jev/Decisions; guided setup verifies credentials.",
     id: "jevFilter",
-    label: "Jev consultation filter",
+    label: "Jev/Decisions consultation filter",
     submenu: (currentValue, done) =>
-      new JevSetupSubmenu({ currentValue, done, theme, tui }),
+      new JevSetupSubmenu({
+        afterSelection: afterJevSetup,
+        currentTransport: settings.jevTransport ?? DEFAULT_JEV_TRANSPORT,
+        currentValue,
+        done,
+        onSelection: onJevSetup,
+        setupDeps: jevSetupDeps,
+        theme,
+        tui,
+      }),
   },
   {
     currentValue: String(
@@ -170,7 +187,7 @@ const jevItems = (
       settings.jevPricePerMtok ?? DEFAULT_JEV_PRICE_PER_MTOK
     ),
     description:
-      "Assumed TypeSafe price per million input tokens for cost lines.",
+      "TypeSafe/OpenRouter estimated input price per million tokens; ignored for OpenAI Decisions, whose cost is unavailable.",
     id: "jevPricePerMtok",
     label: "Jev price/Mtok",
     values: numericValues(
@@ -187,7 +204,7 @@ const jevItems = (
     description:
       "Proactively consult the Advisor every N turns without a consultation (0 = off).",
     id: "jevTurnGateEveryTurns",
-    label: "Jev turn gate",
+    label: "Jev/Decisions turn gate",
     values: [
       "Off",
       "every 3 turns",
@@ -203,24 +220,12 @@ const jevItems = (
     description:
       "Jev confidence required before the turn gate interrupts with advice.",
     id: "jevTurnGateNoulThreshold",
-    label: "Jev turn-gate threshold",
+    label: "Jev/Decisions turn-gate threshold",
     values: numericValues(
       settings.jevTurnGateNoulThreshold ?? DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD,
       [0.6, 0.7, 0.8, 0.85, 0.9, 0.95]
     ),
   },
-  {
-    currentValue: settings.jevTransport ?? DEFAULT_JEV_TRANSPORT,
-    description:
-      "How Jev calls travel: auto reuses an OpenRouter login when no TypeSafe key is set.",
-    id: "jevTransport",
-    label: "Jev transport",
-    values: withCurrentValue(settings.jevTransport ?? DEFAULT_JEV_TRANSPORT, [
-      "auto",
-      "typesafe",
-      "openrouter",
-    ]),
-  },
 ];
 
 export const advisorFallbackModelItem = (
@@ -290,6 +295,9 @@ export const createSettingsItems = ({
   modelWhitelist,
   presets,
   settings,
+  afterJevSetup,
+  jevSetupDeps,
+  onJevSetup,
   theme,
   tui,
 }: SettingsItemsOptions): SettingItem[] => {
@@ -591,7 +599,7 @@ export const createSettingsItems = ({
       settings.outcomeLogging,
       false
     ),
-    ...jevItems(settings, theme, tui)
+    ...jevItems(settings, theme, tui, jevSetupDeps, onJevSetup, afterJevSetup)
   );
   return items;
 };

package/src/ui/settings-mutations.ts

@@ -183,11 +183,6 @@ const applyJevMutation = (
       settings.jevPricePerMtok = Number(value);
       return true;
     }
-    case "jevTransport": {
-      // SAFETY: value comes from the fixed jevTransport options of the settings list.
-      settings.jevTransport = value as AdvisorSettings["jevTransport"];
-      return true;
-    }
     default: {
       return false;
     }

package/src/ui/settings-selector.ts

@@ -17,6 +17,7 @@ import type {
   AdvisorSettings,
   AdvisorSettingsSelectorOptions,
   ContextPreset,
+  JevSetupSelection,
 } from "./types.ts";
 
 export class AdvisorSettingsSelector implements Component, Focusable {
@@ -112,9 +113,15 @@ export class AdvisorSettingsSelector implements Component, Focusable {
       this.options.tui
     );
     const items = createSettingsItems({
+      afterJevSetup: () => {
+        this.settingsList = this.createSettingsList("jevFilter");
+        this.options.tui.requestRender();
+      },
       effortLevels: this.options.effortLevels,
       fallbackModel,
+      jevSetupDeps: this.options.jevSetupDeps,
       modelWhitelist,
+      onJevSetup: (selection) => this.applyJevSetup(selection),
       presets: this.presets,
       settings: this.settings,
       theme: this.options.theme,
@@ -135,6 +142,28 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     return adapter;
   }
 
+  private applyJevSetup(selection: JevSetupSelection): boolean {
+    const updated: AdvisorSettings = {
+      ...this.settings,
+      jevFilterEnabled: selection.enabled,
+      jevTransport: selection.transport,
+      showUsageDetails: this.settings.showUsageDetails ?? true,
+      toolPolicies: { ...this.settings.toolPolicies },
+    };
+    try {
+      const result = this.options.onJevSetup
+        ? this.options.onJevSetup(selection, updated)
+        : (this.options.onChange ?? this.options.onSave)?.(updated);
+      if (result === false) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+    Object.assign(this.settings, updated);
+    return true;
+  }
+
   private startSimpleModeGradient(): void {
     this.stopSimpleModeGradient();
     this.simpleModeGradientStartedAt = Date.now();

package/src/ui/types.ts

@@ -1,8 +1,10 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { KeybindingsManager, TUI } from "@earendil-works/pi-tui";
 
-import type { GateFailureMode } from "../config/types.ts";
+import type { GateFailureMode, JevTransport } from "../config/types.ts";
 import type { GitContextLevel } from "../git.ts";
+import type { JevKeyStoreResult } from "../jev/key-store.ts";
+import type { JevCredentials, JevTransportKind } from "../jev/transport.ts";
 
 export interface RenderRequester {
   requestRender: () => void;
@@ -93,7 +95,7 @@ export interface AdvisorSettings {
   jevModel?: string;
   jevPricePerMtok?: number;
   jevTimeoutMs?: number;
-  jevTransport?: "auto" | "typesafe" | "openrouter";
+  jevTransport?: "auto" | "typesafe" | "openrouter" | "openai-decisions";
   jevTurnGateEveryTurns?: number;
   jevTurnGateNoulThreshold?: number;
   loopThreshold?: number;
@@ -115,6 +117,29 @@ export interface AdvisorSettings {
   untrackedContent?: boolean;
 }
 
+export interface JevSetupSelection {
+  enabled: boolean;
+  transport: JevTransport;
+}
+
+export interface JevSetupResult {
+  message?: string;
+  ok: boolean;
+}
+
+export interface JevSetupDeps {
+  clearStoredKey?: (transport: JevTransportKind) => Promise<JevKeyStoreResult>;
+  removePlaintextKey?: () => JevKeyStoreResult;
+  resolveTransport?: (
+    transport?: JevTransportKind
+  ) => Promise<JevCredentials | undefined>;
+  verify?: (credentials: JevCredentials) => Promise<JevSetupResult>;
+  writeKey?: (
+    key: string,
+    transport: JevTransportKind
+  ) => Promise<JevKeyStoreResult>;
+}
+
 export interface AdvisorSettingsSelectorOptions {
   effortLevels: string[];
   initial: AdvisorSettings;
@@ -125,6 +150,11 @@ export interface AdvisorSettingsSelectorOptions {
   /** @deprecated Use onChange; retained for extensions embedding this component. */
   onSave?: (settings: AdvisorSettings) => void;
   presets: ContextPreset[];
+  jevSetupDeps?: JevSetupDeps;
+  onJevSetup?: (
+    selection: JevSetupSelection,
+    settings: AdvisorSettings
+  ) => boolean;
   theme: Theme;
   tui: RenderRequester;
 }