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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-advisor-flow",
-  "version": "0.11.2",
+  "version": "0.11.3-dev.1",
   "description": "Advanced Executor/Advisor flow for Pi, fully configurable and extendable.",
   "keywords": [
     "advisor",
@@ -51,21 +51,21 @@
     "format:check": "oxfmt --check"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "1.0.2",
-    "@earendil-works/pi-coding-agent": "1.0.2",
-    "@earendil-works/pi-tui": "1.0.2",
-    "@oxlint/plugins": "1.86.0",
+    "@earendil-works/pi-ai": "1.0.4",
+    "@earendil-works/pi-coding-agent": "1.0.4",
+    "@earendil-works/pi-tui": "1.0.4",
+    "@oxlint/plugins": "1.87.0",
     "@types/node": "^26.6.4",
     "@typesafe-ai/sdk": "^0.6.0",
     "bun-types": "1.4.2",
     "husky": "^9.1.7",
-    "knip": "6.39.0",
+    "knip": "6.40.0",
     "lint-staged": "^17.6.0",
-    "oxfmt": "0.71.0",
-    "oxlint": "1.86.0",
-    "typebox": "^1.3.34",
+    "oxfmt": "0.72.0",
+    "oxlint": "1.87.0",
+    "typebox": "^1.3.36",
     "typescript": "^7.0.2",
-    "ultracite": "7.12.2"
+    "ultracite": "7.12.4"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^1.0.0",

package/src/commands/settings-commands.ts

@@ -5,6 +5,10 @@ import {
   setAlwaysOnRef,
 } from "../config/state.ts";
 import { saveConfig } from "../config/storage.ts";
+import {
+  resolveJevTransport,
+  resolveJevTransportFor,
+} from "../jev/transport.ts";
 import { AdvisorSettingsSelector } from "../ui/settings-selector.ts";
 import { loadCommandConfig } from "./activation-preparation.ts";
 import {
@@ -30,6 +34,12 @@ export const registerSettingsCommands = (runtime: CommandRuntime) => {
           new AdvisorSettingsSelector({
             effortLevels: EFFORT_LEVELS,
             initial,
+            jevSetupDeps: {
+              resolveTransport: (transport) =>
+                transport
+                  ? resolveJevTransportFor(transport, ctx)
+                  : resolveJevTransport(ctx),
+            },
             keybindings,
             modelRefs: getConfiguredModelRefs(ctx),
             onCancel: () => done(undefined),
@@ -47,6 +57,39 @@ export const registerSettingsCommands = (runtime: CommandRuntime) => {
                 );
               }
             },
+            onJevSetup: (selection, settings) => {
+              try {
+                saveAdvisorSettings(
+                  ctx,
+                  {
+                    ...settings,
+                    jevFilterEnabled: selection.enabled,
+                    jevTransport: selection.transport,
+                  },
+                  { skipOutcomeLogging: true }
+                );
+              } catch (error) {
+                const message =
+                  error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(
+                  `Could not save Advisor settings: ${message}`,
+                  "error"
+                );
+                return false;
+              }
+              try {
+                runtime.updateSameModelNotice(ctx);
+                runtime.updateAdvisorUsageStatus(ctx);
+              } catch (error) {
+                const message =
+                  error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(
+                  `Advisor settings were saved, but the status refresh failed: ${message}`,
+                  "warning"
+                );
+              }
+              return true;
+            },
             presets: CONTEXT_PRESETS,
             theme,
             tui,

package/src/commands/settings-persistence.ts

@@ -141,9 +141,14 @@ const applyAdvisorSettings = (settings: AdvisorSettings) => {
   applyDisclosureSettings(settings);
 };
 
+export interface SaveAdvisorSettingsOptions {
+  skipOutcomeLogging?: boolean;
+}
+
 export const saveAdvisorSettings = (
   ctx: ExtensionContext,
-  settings: AdvisorSettings
+  settings: AdvisorSettings,
+  options: SaveAdvisorSettingsOptions = {}
 ) => {
   const previous = getAdvisorSettings();
   try {
@@ -153,7 +158,9 @@ export const saveAdvisorSettings = (
       persistAdvisor: Boolean(persisted.advisor),
       persistExecutor: Boolean(persisted.executor),
     });
-    saveGlobalOutcomeLogging(settings.outcomeLogging ?? false);
+    if (!options.skipOutcomeLogging) {
+      saveGlobalOutcomeLogging(settings.outcomeLogging ?? false);
+    }
   } catch (error) {
     applyAdvisorSettings(previous);
     throw error;

package/src/config/types.ts

@@ -32,12 +32,17 @@ export const DEFAULT_JEV_FILTER_NOUL_MARGIN = 0.35;
 export const DEFAULT_JEV_FILTER_OVERRIDE_WINDOW = 10;
 export const DEFAULT_JEV_TURN_GATE_EVERY_TURNS = 0;
 export const DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD = 0.8;
-export type JevTransport = "auto" | "typesafe" | "openrouter";
+export type JevTransport =
+  | "auto"
+  | "typesafe"
+  | "openrouter"
+  | "openai-decisions";
 export const DEFAULT_JEV_TRANSPORT: JevTransport = "auto";
 export const JEV_TRANSPORTS: JevTransport[] = [
   "auto",
   "typesafe",
   "openrouter",
+  "openai-decisions",
 ];
 
 export type AdvisorToolPolicy = "full" | "summary" | "exclude";

package/src/jev/client.ts

@@ -8,6 +8,16 @@ import {
 import { isNumber, isRecord, isRecordOf, isString } from "../content-utils.ts";
 import type { JsonValue, RecordValue } from "../content-utils.ts";
 import { redactSecrets } from "../redaction.ts";
+import {
+  buildDecisionsRequest,
+  OPENAI_DECISIONS_ENDPOINT,
+  OPENAI_DECISIONS_MODEL,
+} from "./decisions-client.ts";
+import type { DecisionsQuestion } from "./decisions-client.ts";
+import {
+  normalizeDecisionsResponse,
+  parseDecisionsApiResponse,
+} from "./decisions-response.ts";
 import { JevFailureError } from "./failure.ts";
 import type { JevErrorCategory } from "./failure.ts";
 import type { JevCredentials, JevTransportKind } from "./transport.ts";
@@ -16,7 +26,7 @@ export type { JevErrorCategory } from "./failure.ts";
 export { JevFailureError as JevFailure } from "./failure.ts";
 
 export interface JevUsage {
-  cost: number;
+  cost?: number;
   inputTokens: number;
   outputTokens: number;
 }
@@ -37,6 +47,7 @@ export interface JevClientOptions {
 }
 
 const ENDPOINTS: Record<JevTransportKind, string> = {
+  "openai-decisions": OPENAI_DECISIONS_ENDPOINT,
   openrouter: "https://openrouter.ai/api/alpha/decisions",
   typesafe: "https://api.typesafe.ai/v1/systemone",
 };
@@ -71,12 +82,32 @@ const statusCategory = (status: number): JevErrorCategory => {
   return "error";
 };
 
-const isObjectLike = <Value>(value: Value): value is Value & object =>
-  typeof value === "object";
-
 const openRouterModelId = (model: string) =>
   model.includes("/") ? model : `~typesafe/${model}`;
 
+interface ClientRequest {
+  body: string;
+  decisionQuestions?: DecisionsQuestion[];
+}
+
+const buildClientRequest = (
+  transport: JevTransportKind,
+  model: string,
+  state: EntryType,
+  questions: Questions
+): ClientRequest => {
+  if (transport === "openai-decisions") {
+    const request = buildDecisionsRequest(state, questions);
+    return {
+      body: JSON.stringify(request),
+      decisionQuestions: request.questions,
+    };
+  }
+  return {
+    body: JSON.stringify({ model, questions, state }),
+  };
+};
+
 interface AttemptOutcome {
   answers?: RecordValue;
   failure?: JevFailureError;
@@ -116,9 +147,7 @@ const sleepWithAbort = (signal: AbortSignal, ms: number): Promise<void> => {
   });
 };
 
-/** One systemone client for both transports with a total wall deadline so
- * retries can never stall a tool call; errors are classified and redacted on
- * every path. */
+/** Shared Jev client with a total deadline, bounded retries, and redacted errors for every provider. */
 export class JevClient {
   readonly #apiKey: string;
   readonly #endpoint: string;
@@ -126,6 +155,7 @@ export class JevClient {
   readonly #model: string;
   readonly #pricePerMtok: number | undefined;
   readonly #timeoutMs: number;
+  readonly #transport: JevTransportKind;
 
   constructor({
     apiKey,
@@ -139,9 +169,16 @@ export class JevClient {
     this.#endpoint = ENDPOINTS[transport];
     // SAFETY: the bound global fetch satisfies the SDK Fetch signature; binding keeps the receiver correct.
     this.#fetch = fetch ?? (globalThis.fetch.bind(globalThis) as Fetch);
-    this.#model = transport === "openrouter" ? openRouterModelId(model) : model;
+    if (transport === "openai-decisions") {
+      this.#model = OPENAI_DECISIONS_MODEL;
+    } else if (transport === "openrouter") {
+      this.#model = openRouterModelId(model);
+    } else {
+      this.#model = model;
+    }
     this.#pricePerMtok = pricePerMtok;
     this.#timeoutMs = timeoutMs;
+    this.#transport = transport;
   }
 
   async ask(
@@ -149,6 +186,12 @@ export class JevClient {
     questions: Questions,
     signal?: AbortSignal
   ): Promise<JevAskResult> {
+    const { body, decisionQuestions } = buildClientRequest(
+      this.#transport,
+      this.#model,
+      state,
+      questions
+    );
     const deadline = new AbortController();
     const abortFromCaller = () => deadline.abort(signal?.reason);
     signal?.addEventListener("abort", abortFromCaller, { once: true });
@@ -161,16 +204,11 @@ export class JevClient {
       deadline.abort(new Error("Jev wall-time budget elapsed"));
     }, this.#timeoutMs);
     timer.unref?.();
-    const body = JSON.stringify({
-      model: this.#model,
-      questions,
-      state,
-    });
     try {
       let outcome: AttemptOutcome = {};
       for (let attempt = 1; ; attempt += 1) {
         // The retry loop is bounded to one backoff by the deadline controller.
-        outcome = await this.#attempt(body, deadline.signal);
+        outcome = await this.#attempt(body, deadline.signal, decisionQuestions);
         if (
           !outcome.retryable ||
           attempt >= MAX_ATTEMPTS ||
@@ -229,7 +267,11 @@ export class JevClient {
     throw new JevFailureError("error", "Jev call failed.");
   }
 
-  async #attempt(body: string, signal: AbortSignal): Promise<AttemptOutcome> {
+  async #attempt(
+    body: string,
+    signal: AbortSignal,
+    decisionQuestions?: DecisionsQuestion[]
+  ): Promise<AttemptOutcome> {
     if (signal.aborted) {
       return { retryable: false };
     }
@@ -254,7 +296,7 @@ export class JevClient {
       };
     }
     if (response.ok) {
-      return this.#parseSuccess(response);
+      return this.#parseSuccess(response, decisionQuestions);
     }
     const failure = await this.#failureFromStatus(response);
     return {
@@ -279,10 +321,32 @@ export class JevClient {
   }
 
   #transportLabel(): string {
-    return this.#endpoint === ENDPOINTS.openrouter ? "OpenRouter" : "TypeSafe";
+    if (this.#transport === "openrouter") {
+      return "OpenRouter";
+    }
+    return this.#transport === "openai-decisions"
+      ? "OpenAI Decisions"
+      : "TypeSafe";
   }
 
-  async #parseSuccess(response: Response): Promise<AttemptOutcome> {
+  async #parseSuccess(
+    response: Response,
+    decisionQuestions?: DecisionsQuestion[]
+  ): Promise<AttemptOutcome> {
+    if (this.#transport === "openai-decisions") {
+      const normalized = normalizeDecisionsResponse(
+        await parseDecisionsApiResponse(response),
+        decisionQuestions ?? []
+      );
+      return {
+        answers: normalized.answers,
+        model: normalized.model,
+        usage: {
+          input_tokens: normalized.usage.inputTokens,
+          output_tokens: normalized.usage.outputTokens,
+        },
+      };
+    }
     let parsed: unknown;
     try {
       parsed = await response.json();
@@ -294,7 +358,7 @@ export class JevClient {
         ),
       };
     }
-    if (!isRecord(parsed) || !parsed.answers || !isObjectLike(parsed.answers)) {
+    if (!isRecord(parsed) || !isRecord(parsed.answers)) {
       return {
         failure: new JevFailureError(
           "malformed",
@@ -303,8 +367,7 @@ export class JevClient {
       };
     }
     return {
-      // SAFETY: the response contract guarantees an answers object; the shape is re-validated per key by consumers.
-      answers: parsed.answers as RecordValue,
+      answers: parsed.answers,
       model: isString(parsed.model) ? parsed.model : this.#model,
       usage: isRecordOf(parsed.usage)
         ? {
@@ -324,7 +387,10 @@ export class JevClient {
       answers: outcome.answers ?? {},
       model: outcome.model ?? this.#model,
       usage: {
-        cost: (inputTokens / 1_000_000) * price,
+        cost:
+          this.#transport === "openai-decisions"
+            ? undefined
+            : (inputTokens / 1_000_000) * price,
         inputTokens,
         outputTokens,
       },

package/src/jev/decisions-client.ts

@@ -0,0 +1,124 @@
+import type { EntryType, Questions } from "@typesafe-ai/sdk";
+
+import { isRecordOf, isString } from "../content-utils.ts";
+import { JevFailureError } from "./failure.ts";
+
+export const OPENAI_DECISIONS_ENDPOINT = "https://api.openai.com/v1/decisions";
+export const OPENAI_DECISIONS_MODEL = "gpt-6-luna";
+
+export interface DecisionsPredicateQuestion {
+  instructions: string;
+  name: string;
+  type: "predicate";
+}
+
+export interface DecisionsScoreLevel {
+  description: string;
+  label: string;
+}
+
+export interface DecisionsScoreQuestion {
+  instructions: string;
+  levels: DecisionsScoreLevel[];
+  name: string;
+  type: "score";
+}
+
+export type DecisionsQuestion =
+  | DecisionsPredicateQuestion
+  | DecisionsScoreQuestion;
+
+export interface DecisionsRequest {
+  input: string;
+  model: typeof OPENAI_DECISIONS_MODEL;
+  questions: DecisionsQuestion[];
+}
+
+const formatEntry = (entry: EntryType | undefined): string => {
+  if (isString(entry)) {
+    return entry;
+  }
+  return entry === undefined ? "" : JSON.stringify(entry);
+};
+
+const predicateInstructions = (question: Questions[string]): string => {
+  const parts = [formatEntry(question.instructions)];
+  if (question.type === "noul") {
+    if (question.criteria?.true !== undefined) {
+      parts.push(`A true answer means: ${formatEntry(question.criteria.true)}`);
+    }
+    if (question.criteria?.false !== undefined) {
+      parts.push(
+        `A false answer means: ${formatEntry(question.criteria.false)}`
+      );
+    }
+  }
+  return parts.filter(Boolean).join("\n\n");
+};
+
+const scoreLevelLabel = (description: EntryType, index: number): string => {
+  const text = formatEntry(description);
+  const colon = text.indexOf(":");
+  const label = (colon === -1 ? text : text.slice(0, colon)).trim();
+  return label || `Level ${index}`;
+};
+
+const decisionQuestion = (
+  name: string,
+  question: Questions[string]
+): DecisionsQuestion => {
+  if (question.type === "noul") {
+    return {
+      instructions: predicateInstructions(question),
+      name,
+      type: "predicate",
+    };
+  }
+  if (question.type === "score") {
+    const labels = new Set<string>();
+    const levels = question.criteria.map((description, index) => {
+      const label = scoreLevelLabel(description, index);
+      if (labels.has(label)) {
+        throw new JevFailureError(
+          "malformed",
+          `Jev score question ${name} has duplicate level labels.`
+        );
+      }
+      labels.add(label);
+      return { description: formatEntry(description), label };
+    });
+    return {
+      instructions: formatEntry(question.instructions),
+      levels,
+      name,
+      type: "score",
+    };
+  }
+  throw new JevFailureError(
+    "malformed",
+    `Jev question ${name} has an unsupported type.`
+  );
+};
+
+export const formatDecisionsInput = (state: EntryType): string => {
+  if (isString(state)) {
+    return state;
+  }
+  return JSON.stringify(state, null, 2);
+};
+
+export const buildDecisionsRequest = (
+  state: EntryType,
+  questions: Questions
+): DecisionsRequest => {
+  if (!isRecordOf(questions) || Object.keys(questions).length === 0) {
+    throw new JevFailureError("malformed", "Jev questions are empty.");
+  }
+  return {
+    input: formatDecisionsInput(state),
+    model: OPENAI_DECISIONS_MODEL,
+    questions: Object.entries(questions).map(([name, question]) =>
+      decisionQuestion(name, question)
+    ),
+  };
+};

package/src/jev/decisions-response.ts

@@ -0,0 +1,198 @@
+import { isNumber, isRecord, isString } from "../content-utils.ts";
+import type { JsonValue, RecordValue } from "../content-utils.ts";
+import { OPENAI_DECISIONS_MODEL } from "./decisions-client.ts";
+import type {
+  DecisionsQuestion,
+  DecisionsScoreQuestion,
+} from "./decisions-client.ts";
+import { JevFailureError } from "./failure.ts";
+
+export interface DecisionsUsage {
+  inputTokens: number;
+  outputTokens: number;
+}
+
+export interface NormalizedDecisionsResponse {
+  answers: RecordValue;
+  model: string;
+  usage: DecisionsUsage;
+}
+
+interface DecisionsApiResponse {
+  answers: RecordValue[];
+  model?: string;
+  usage: RecordValue;
+}
+
+const malformedResponse = (detail: string): JevFailureError =>
+  new JevFailureError("malformed", `OpenAI Decisions response ${detail}.`);
+
+const boundedProbability = (
+  value: JsonValue | undefined
+): number | undefined =>
+  isNumber(value) && Number.isFinite(value) && value >= 0 && value <= 1
+    ? value
+    : undefined;
+
+const normalizePredicateAnswer = (answer: RecordValue): RecordValue => {
+  const probability = boundedProbability(answer.probability);
+  if (probability === undefined) {
+    throw malformedResponse("has an invalid predicate probability");
+  }
+  return { noul: probability, type: "noul" };
+};
+
+const normalizeScoreAnswer = (
+  answer: RecordValue,
+  question: DecisionsScoreQuestion
+): RecordValue => {
+  if (!Array.isArray(answer.probabilities)) {
+    throw malformedResponse("has no score probability array");
+  }
+  if (answer.probabilities.length !== question.levels.length) {
+    throw malformedResponse("has an incomplete score probability array");
+  }
+  const probabilities: Record<string, number> = {};
+  const legend: Record<string, string> = {};
+  const seenLabels = new Set<string>();
+  const seenValues = new Set<number>();
+  let probabilityTotal = 0;
+  for (const entry of answer.probabilities) {
+    if (!isRecord(entry)) {
+      throw malformedResponse("has an invalid score probability entry");
+    }
+    const { label, value } = entry;
+    const probability = boundedProbability(entry.probability);
+    if (
+      !isString(label) ||
+      !isNumber(value) ||
+      !Number.isSafeInteger(value) ||
+      value < 0 ||
+      value >= question.levels.length ||
+      probability === undefined ||
+      seenLabels.has(label) ||
+      seenValues.has(value)
+    ) {
+      throw malformedResponse("has an invalid or duplicate score level");
+    }
+    const level = question.levels[value];
+    if (label !== level.label) {
+      throw malformedResponse("has an ambiguous score label/value pair");
+    }
+    seenLabels.add(label);
+    seenValues.add(value);
+    probabilities[String(value)] = probability;
+    legend[String(value)] = level.description;
+    probabilityTotal += probability;
+  }
+  if (
+    Math.abs(probabilityTotal - 1) > 0.02 ||
+    question.levels.some(
+      (level, index) => !seenValues.has(index) || !seenLabels.has(level.label)
+    )
+  ) {
+    throw malformedResponse(
+      "has an incomplete or ambiguous score distribution"
+    );
+  }
+  return { legend, probabilities, type: "score" };
+};
+
+const usageTokenCount = (value: JsonValue | undefined): number | undefined =>
+  isNumber(value) && Number.isSafeInteger(value) && value >= 0
+    ? value
+    : undefined;
+
+export const parseDecisionsApiResponse = async (
+  response: Response
+): Promise<DecisionsApiResponse> => {
+  let value: unknown;
+  try {
+    value = await response.json();
+  } catch {
+    throw malformedResponse("was not valid JSON");
+  }
+  if (!isRecord(value)) {
+    throw malformedResponse("is not an object");
+  }
+  const { answers: rawAnswers, model, usage } = value;
+  if (!Array.isArray(rawAnswers)) {
+    throw malformedResponse("did not include an answers array");
+  }
+  if (!isRecord(usage)) {
+    throw malformedResponse("has malformed usage");
+  }
+  if (model !== undefined && !isString(model)) {
+    throw malformedResponse("has an invalid model name");
+  }
+  const answers: RecordValue[] = [];
+  for (const answer of rawAnswers) {
+    if (!isRecord(answer)) {
+      throw malformedResponse("contains an invalid answer");
+    }
+    answers.push(answer);
+  }
+  return { answers, model: isString(model) ? model : undefined, usage };
+};
+
+const normalizeAnswers = (
+  responseAnswers: RecordValue[],
+  questions: DecisionsQuestion[]
+): RecordValue => {
+  const expected = new Map(
+    questions.map((question) => [question.name, question])
+  );
+  if (expected.size !== questions.length || expected.size === 0) {
+    throw malformedResponse(
+      "has duplicate or missing requested question names"
+    );
+  }
+  const received = new Map<string, RecordValue>();
+  for (const answer of responseAnswers) {
+    const { name } = answer;
+    if (!isString(name) || !name) {
+      throw malformedResponse("contains an unnamed answer");
+    }
+    if (!expected.has(name)) {
+      throw malformedResponse("contains an unexpected answer");
+    }
+    if (received.has(name)) {
+      throw malformedResponse("contains duplicate answer names");
+    }
+    if (answer.type === "refusal") {
+      throw malformedResponse("contains a refusal");
+    }
+    received.set(name, answer);
+  }
+  if (received.size !== expected.size) {
+    throw malformedResponse("is missing one or more named answers");
+  }
+  const answers: RecordValue = {};
+  for (const question of questions) {
+    const answer = received.get(question.name);
+    if (!answer || answer.type !== question.type) {
+      throw malformedResponse("has an answer with the wrong type");
+    }
+    answers[question.name] =
+      question.type === "predicate"
+        ? normalizePredicateAnswer(answer)
+        : normalizeScoreAnswer(answer, question);
+  }
+  return answers;
+};
+
+export const normalizeDecisionsResponse = (
+  response: DecisionsApiResponse,
+  questions: DecisionsQuestion[]
+): NormalizedDecisionsResponse => {
+  const inputTokens = usageTokenCount(response.usage.input_tokens);
+  const outputTokens = usageTokenCount(response.usage.output_tokens);
+  if (inputTokens === undefined || outputTokens === undefined) {
+    throw malformedResponse("has malformed usage");
+  }
+  return {
+    answers: normalizeAnswers(response.answers, questions),
+    model: response.model || OPENAI_DECISIONS_MODEL,
+    usage: { inputTokens, outputTokens },
+  };
+};