pi-advisor-flow 0.4.0 → 0.5.1

package/src/config.ts

@@ -13,8 +13,6 @@ import {
   isValidGitContextLevel,
 } from "./git.js";
 
-export const FALLBACK_EXECUTOR = "openai-codex/gpt-5.6-luna";
-export const FALLBACK_ADVISOR = "openai-codex/gpt-5.6-sol";
 export const DEFAULT_CONTEXT_MAX_CHARS = 15_000;
 export const MAX_CONTEXT_MAX_CHARS = Number.MAX_SAFE_INTEGER;
 export const DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES = DEFAULT_MAX_LINES;
@@ -37,8 +35,11 @@ export const GATE_FAILURE_MODES: GateFailureMode[] = [
   "warn-and-continue",
 ];
 
-export let executorRef = FALLBACK_EXECUTOR;
-export let advisorRef = FALLBACK_ADVISOR;
+// An empty ref means no model has been selected yet.
+export let executorRef = "";
+export let advisorRef = "";
+let persistedExecutorRef: string | undefined;
+let persistedAdvisorRef: string | undefined;
 export let executorEffortRef: string | undefined;
 export let advisorEffortRef: string | undefined;
 export let contextMaxCharsRef = DEFAULT_CONTEXT_MAX_CHARS;
@@ -66,6 +67,8 @@ export let advisorOutcomeLoggingRef = false;
 export let advisorUntrackedContentRef = false;
 export let advisorTrackedFileContentRef = false;
 export let advisorScoutEnabledRef = false;
+export let showUsageDetailsRef = true;
+export let showUsageFooterRef = false;
 
 export const setExecutorRef = (ref: string) => {
   executorRef = ref;
@@ -73,6 +76,11 @@ export const setExecutorRef = (ref: string) => {
 export const setAdvisorRef = (ref: string) => {
   advisorRef = ref;
 };
+/** Returns model refs explicitly persisted in the global Advisor config. */
+export const getPersistedModelRefs = () => ({
+  advisor: persistedAdvisorRef,
+  executor: persistedExecutorRef,
+});
 export const setExecutorEffortRef = (effort: string | undefined) => {
   executorEffortRef = effort;
 };
@@ -174,6 +182,12 @@ export const setAdvisorTrackedFileContentRef = (enabled: boolean) => {
 export const setAdvisorScoutEnabledRef = (enabled: boolean) => {
   advisorScoutEnabledRef = enabled;
 };
+export const setShowUsageDetailsRef = (enabled: boolean) => {
+  showUsageDetailsRef = enabled;
+};
+export const setShowUsageFooterRef = (enabled: boolean) => {
+  showUsageFooterRef = enabled;
+};
 
 /**
  * Returns the current live settings state. Use this at UI boundaries instead of
@@ -200,6 +214,8 @@ export const getAdvisorSettings = () => ({
   redactSecrets: advisorRedactSecretsRef,
   scoutEnabled: advisorScoutEnabledRef,
   sessionSummary: advisorSessionSummaryRef,
+  showUsageDetails: showUsageDetailsRef,
+  showUsageFooter: showUsageFooterRef,
   simpleMode: simpleModeRef,
   toolPolicies: { ...advisorToolPoliciesRef },
   toolResultMaxBytes: advisorToolResultMaxBytesRef,
@@ -253,6 +269,8 @@ export interface AdvisorConfig {
   executor?: string;
   executorEffort?: string;
   gateFailureMode?: GateFailureMode;
+  showUsageDetails?: boolean;
+  showUsageFooter?: boolean;
   simpleMode?: boolean;
 }
 
@@ -273,6 +291,7 @@ const CONFIG_KEYS = new Set<keyof AdvisorConfig>([
   "advisorPlanGate",
   "advisorSessionSummary",
   "advisorScoutEnabled",
+  "showUsageDetails",
   "simpleMode",
   "alwaysOn",
   "advisorToolResultMaxBytes",
@@ -286,6 +305,7 @@ const CONFIG_KEYS = new Set<keyof AdvisorConfig>([
   "executor",
   "executorEffort",
   "gateFailureMode",
+  "showUsageFooter",
 ]);
 const BOOLEAN_CONFIG_KEYS = [
   "advisorPlanGate",
@@ -296,6 +316,8 @@ const BOOLEAN_CONFIG_KEYS = [
   "advisorAutoLoopGate",
   "advisorSessionSummary",
   "advisorScoutEnabled",
+  "showUsageDetails",
+  "showUsageFooter",
   "simpleMode",
   "alwaysOn",
   "advisorHerdrIntegration",
@@ -453,8 +475,10 @@ export const validateConfig = (
 };
 
 const resetDefaults = () => {
-  executorRef = FALLBACK_EXECUTOR;
-  advisorRef = FALLBACK_ADVISOR;
+  executorRef = "";
+  advisorRef = "";
+  persistedExecutorRef = undefined;
+  persistedAdvisorRef = undefined;
   executorEffortRef = undefined;
   advisorEffortRef = undefined;
   contextMaxCharsRef = DEFAULT_CONTEXT_MAX_CHARS;
@@ -482,6 +506,8 @@ const resetDefaults = () => {
   advisorUntrackedContentRef = false;
   advisorTrackedFileContentRef = false;
   advisorScoutEnabledRef = false;
+  showUsageDetailsRef = true;
+  showUsageFooterRef = false;
 };
 
 const applyOptionalConfig = <Key extends keyof AdvisorConfig>(
@@ -504,6 +530,9 @@ const applyNonEmptyStringConfig = (
   }
 };
 
+const configuredModelRef = (value: string | undefined): string | undefined =>
+  value?.trim() || undefined;
+
 const applyConfig = (config: AdvisorConfig) => {
   applyNonEmptyStringConfig(config.executor, setExecutorRef);
   applyNonEmptyStringConfig(config.advisor, setAdvisorRef);
@@ -549,6 +578,8 @@ const applyConfig = (config: AdvisorConfig) => {
     setAdvisorSessionSummaryRef
   );
   applyOptionalConfig(config, "advisorScoutEnabled", setAdvisorScoutEnabledRef);
+  applyOptionalConfig(config, "showUsageDetails", setShowUsageDetailsRef);
+  applyOptionalConfig(config, "showUsageFooter", setShowUsageFooterRef);
   applyOptionalConfig(config, "simpleMode", setSimpleModeRef);
   applyOptionalConfig(config, "alwaysOn", setAlwaysOnRef);
   applyOptionalConfig(config, "gateFailureMode", setAdvisorFailureModeRef);
@@ -647,6 +678,8 @@ export const loadConfig = (_ctx: ExtensionContext) => {
   const globalConfig = existsSync(global)
     ? readConfigCached(global)
     : undefined;
+  persistedExecutorRef = configuredModelRef(globalConfig?.executor);
+  persistedAdvisorRef = configuredModelRef(globalConfig?.advisor);
   if (globalConfig) {
     applyConfig(globalConfig);
     const unknownKeys = unknownConfigKeys(globalConfig as ConfigRecord);
@@ -671,8 +704,18 @@ export const loadConfig = (_ctx: ExtensionContext) => {
 };
 
 /** Saves user-controlled configuration globally without outcome consent. */
-export const saveConfig = (_ctx: ExtensionContext) => {
+export interface SaveConfigOptions {
+  persistAdvisor?: boolean;
+  persistExecutor?: boolean;
+}
+
+export const saveConfig = (
+  _ctx: ExtensionContext,
+  options: SaveConfigOptions = {}
+) => {
   const path = join(getAgentDir(), "advisor.json");
+  const persistAdvisor = options.persistAdvisor ?? true;
+  const persistExecutor = options.persistExecutor ?? true;
   let existing: Record<string, unknown> = {};
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8"));
@@ -687,7 +730,7 @@ export const saveConfig = (_ctx: ExtensionContext) => {
   }
   const data = {
     ...existing,
-    advisor: advisorRef,
+    ...(persistAdvisor && advisorRef ? { advisor: advisorRef } : {}),
     advisorAutoLoopGate: advisorAutoLoopGateRef,
     advisorBlockOnBlocked: advisorBlockOnBlockedRef,
     advisorCollapseResponses: advisorCollapseResponsesRef,
@@ -698,7 +741,7 @@ export const saveConfig = (_ctx: ExtensionContext) => {
     advisorLoopThreshold: advisorLoopThresholdRef,
     advisorPlanGate: advisorPlanGateRef,
     contextMaxChars: contextMaxCharsRef,
-    executor: executorRef,
+    ...(persistExecutor && executorRef ? { executor: executorRef } : {}),
     executorEffort: executorEffortRef,
     ...(advisorMaxCallsPerSessionRef === undefined
       ? {}
@@ -716,6 +759,8 @@ export const saveConfig = (_ctx: ExtensionContext) => {
     advisorUntrackedContent: advisorUntrackedContentRef,
     alwaysOn: alwaysOnRef,
     gateFailureMode: advisorFailureModeRef,
+    showUsageDetails: showUsageDetailsRef,
+    showUsageFooter: showUsageFooterRef,
     simpleMode: simpleModeRef,
   };
   writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);

package/src/model-stream.ts

@@ -18,9 +18,12 @@ export interface ResolvedConfiguredModel {
 
 export const resolveConfiguredModel = async (
   ctx: ExtensionContext,
-  ref: string,
+  ref: string | undefined,
   label: string
 ): Promise<ResolvedConfiguredModel> => {
+  if (!ref) {
+    throw new Error(`${label} model not configured`);
+  }
   const [provider, modelId] = splitRef(ref);
   const model = ctx.modelRegistry.find(provider, modelId);
   if (!model) {
@@ -56,6 +59,129 @@ export interface CollectedTextStream {
   usage?: unknown;
 }
 
+export const ADVISOR_STREAM_UPDATE_INTERVAL_MS = 90;
+
+export interface CoalescedUpdateResult {
+  error?: unknown;
+  failed: boolean;
+}
+
+export interface CoalescedUpdate<T> {
+  cancel: () => void;
+  flush: () => CoalescedUpdateResult;
+  update: (value: T) => void;
+}
+
+export interface CoalescedUpdateScheduler {
+  clearTimeout: (timer: ReturnType<typeof setTimeout>) => void;
+  now: () => number;
+  setTimeout: (
+    callback: () => void,
+    delay: number
+  ) => ReturnType<typeof setTimeout>;
+}
+
+/**
+ * Keep stream updates responsive without forwarding every provider delta to
+ * the UI. The first update in a burst is immediate; later updates are kept as
+ * the latest value and published at most once per interval. `flush()` closes
+ * the publisher and is intended for terminal success/error paths.
+ */
+export const createCoalescedUpdate = <T>(
+  publish: (value: T) => void,
+  intervalMs = ADVISOR_STREAM_UPDATE_INTERVAL_MS,
+  scheduler: CoalescedUpdateScheduler = {
+    clearTimeout,
+    now: Date.now,
+    setTimeout: (callback, delay) => setTimeout(callback, delay),
+  }
+): CoalescedUpdate<T> => {
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+    throw new Error("Coalesced update interval must be positive and finite.");
+  }
+
+  let closed = false;
+  let hasPending = false;
+  let pending: T | undefined;
+  let lastPublishedAt: number | undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let publishError: unknown;
+  let publishFailed = false;
+
+  const clearTimer = () => {
+    if (timer !== undefined) {
+      scheduler.clearTimeout(timer);
+      timer = undefined;
+    }
+  };
+
+  const publishPending = () => {
+    timer = undefined;
+    if (!hasPending) {
+      return;
+    }
+    const value = pending as T;
+    pending = undefined;
+    hasPending = false;
+    lastPublishedAt = scheduler.now();
+    try {
+      publish(value);
+    } catch (error) {
+      publishFailed = true;
+      publishError = error;
+      closed = true;
+      clearTimer();
+    }
+  };
+
+  const schedule = () => {
+    const elapsed =
+      lastPublishedAt === undefined
+        ? intervalMs
+        : scheduler.now() - lastPublishedAt;
+    const delay = Math.max(0, intervalMs - elapsed);
+    if (delay === 0) {
+      publishPending();
+      return;
+    }
+    timer = scheduler.setTimeout(publishPending, delay);
+    timer.unref?.();
+  };
+
+  return {
+    cancel: () => {
+      closed = true;
+      clearTimer();
+      pending = undefined;
+      hasPending = false;
+    },
+    flush: () => {
+      if (!closed) {
+        closed = true;
+        clearTimer();
+        publishPending();
+      }
+      return { error: publishError, failed: publishFailed };
+    },
+    update: (value) => {
+      if (closed) {
+        return;
+      }
+      if (publishFailed) {
+        throw publishError;
+      }
+      pending = value;
+      hasPending = true;
+      if (timer === undefined) {
+        schedule();
+      }
+      if (publishFailed) {
+        throw publishError;
+      }
+    },
+  };
+};
+
 export const collectTextStream = async (
   resolved: ResolvedConfiguredModel,
   options: CollectTextStreamOptions,
@@ -70,7 +196,13 @@ export const collectTextStream = async (
       apiKey: resolved.apiKey,
       env: resolved.env,
       headers: resolved.headers,
+      // `stream()` uses the provider-facing name while the extension's public
+      // option keeps the Pi-facing `reasoning` name. Preserve both so the
+      // configured effort reaches providers that serialize reasoning_effort.
       reasoning: options.reasoning as never,
+      ...(options.reasoning === undefined
+        ? {}
+        : { reasoningEffort: options.reasoning as never }),
       signal: options.signal,
     }
   );

package/src/session-state.ts

@@ -124,6 +124,7 @@ export class AdvisorSessionState {
     string,
     { advice: string; trigger: ConsultationTrigger }
   >();
+  readonly #pendingAdvice = new Set<string>();
   readonly #reportedAdvice = new Set<string>();
   #draftConsultations = 0;
   #outcomes = 0;
@@ -138,6 +139,7 @@ export class AdvisorSessionState {
     this.#loopInterventions = 0;
     this.#consumedCalls = 0;
     this.#issuedAdvice.clear();
+    this.#pendingAdvice.clear();
     this.#reportedAdvice.clear();
     this.#draftConsultations = 0;
     this.#outcomes = 0;
@@ -237,16 +239,38 @@ export class AdvisorSessionState {
     return true;
   }
 
-  claimAdvice(id: string) {
-    if (this.#reportedAdvice.has(id)) {
+  reserveAdvice(id: string) {
+    if (this.#reportedAdvice.has(id) || this.#pendingAdvice.has(id)) {
       return;
     }
     const advice = this.#issuedAdvice.get(id);
     if (!advice) {
       return;
     }
+    this.#pendingAdvice.add(id);
+    return advice;
+  }
+
+  commitAdvice(id: string) {
+    if (!this.#pendingAdvice.delete(id)) {
+      return false;
+    }
     this.#reportedAdvice.add(id);
     this.#outcomes += 1;
+    return true;
+  }
+
+  releaseAdvice(id: string) {
+    this.#pendingAdvice.delete(id);
+  }
+
+  /** Compatibility helper for synchronous callers that can commit immediately. */
+  claimAdvice(id: string) {
+    const advice = this.reserveAdvice(id);
+    if (!advice) {
+      return;
+    }
+    this.commitAdvice(id);
     return advice;
   }