pi-advisor-flow 0.6.0 → 0.7.0

package/src/tools/types.ts

@@ -8,6 +8,8 @@ import type {
   GateTrigger,
 } from "../session-state.ts";
 import type { consultAdvisor, runAdvisorGate } from "./consultation.ts";
+import type { JevSkipKind, screenConsultation } from "./jev-filter.ts";
+import type { JevTurnGateDeps } from "./jev-turn-gate.ts";
 import type { ScoutStatusManager } from "./scout-status.ts";
 
 export type {
@@ -79,6 +81,11 @@ export interface AdvisorToolDetails {
   adviceId?: string;
   advisor?: string;
   draftBytes?: number;
+  jev?: {
+    kind: JevSkipKind;
+    reason: string;
+    skipped: boolean;
+  };
   preferenceBytes?: number;
   question?: string;
   scout?: ScoutToolDetails;
@@ -108,6 +115,7 @@ export interface ToolRegistrationContext {
   reservedCalls: Set<string>;
   runGate: typeof runAdvisorGate;
   scoutStatus: ScoutStatusManager;
+  screen: typeof screenConsultation;
   session: AdvisorSessionState;
 }
 
@@ -115,5 +123,7 @@ export interface ToolRegistrationDependencies {
   appendOutcome?: typeof appendOutcome;
   consult?: typeof consultAdvisor;
   runGate?: typeof runAdvisorGate;
+  screen?: typeof screenConsultation;
   statusManager?: ScoutStatusManager;
+  turnGateDeps?: JevTurnGateDeps;
 }

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

@@ -0,0 +1,344 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  type Component,
+  type Focusable,
+  Key,
+  matchesKey,
+  truncateToWidth,
+} from "@earendil-works/pi-tui";
+import { noul } from "@typesafe-ai/sdk";
+import { jevClientFromCredentials } from "../jev/client.ts";
+import {
+  clearKeyTypeSafeKey,
+  consumePlaintextKeyWarning,
+  type JevKeyStoreResult,
+  removeTypeSafeKeyFromAdvisorJson,
+  writeKeyTypeSafeKey,
+} from "../jev/key-store.ts";
+import { type JevCredentials, resolveJevTransport } from "../jev/transport.ts";
+import { MaskedInput } from "./masked-input.ts";
+import type { RenderRequester } from "./types.ts";
+
+export interface JevSetupSubmenuOptions {
+  currentValue: string;
+  done: (selectedValue?: string) => void;
+  theme: Theme;
+  tui: RenderRequester;
+}
+
+export interface JevSetupDeps {
+  clearStoredKey?: () => Promise<JevKeyStoreResult>;
+  removePlaintextKey?: () => JevKeyStoreResult;
+  resolveTransport?: () => Promise<JevCredentials | undefined>;
+  verify?: (credentials: JevCredentials) => Promise<JevFailureLike>;
+  writeKey?: (key: string) => Promise<JevKeyStoreResult>;
+}
+
+interface JevFailureLike {
+  message?: string;
+  ok: boolean;
+}
+
+type SetupMode = "menu" | "key-entry" | "verifying";
+type SetupAction =
+  | "verify-enable"
+  | "verify-again"
+  | "disable"
+  | "disable-clear"
+  | "enter-key"
+  | "done";
+
+const transportLabel = (credentials: JevCredentials): string => {
+  if (credentials.transport === "openrouter") {
+    return "OpenRouter (reusing pi login)";
+  }
+  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)";
+  }
+};
+
+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,
+    };
+  }
+};
+
+/** Guided Jev credentials setup: detects a reusable login, verifies live
+ * before enabling, and never echoes an entered key back. */
+export class JevSetupSubmenu implements Component, Focusable {
+  private readonly options: JevSetupSubmenuOptions;
+  private readonly deps: JevSetupDeps;
+  private readonly maskedInput: MaskedInput;
+  private credentials: JevCredentials | undefined;
+  private mode: SetupMode = "menu";
+  private notice: string | undefined;
+  private selectedIndex = 0;
+  private _focused = true;
+
+  constructor(options: JevSetupSubmenuOptions, deps: JevSetupDeps = {}) {
+    this.options = options;
+    this.deps = {
+      clearStoredKey: deps.clearStoredKey ?? clearKeyTypeSafeKey,
+      removePlaintextKey:
+        deps.removePlaintextKey ?? removeTypeSafeKeyFromAdvisorJson,
+      resolveTransport: deps.resolveTransport ?? (() => resolveJevTransport()),
+      verify: deps.verify ?? defaultVerify,
+      writeKey: deps.writeKey ?? writeKeyTypeSafeKey,
+    };
+    this.maskedInput = new MaskedInput({
+      onEscape: () => this.options.done(),
+      onSubmit: (value) => this.submitEnteredKey(value),
+      placeholder: "Paste a TypeSafe API key",
+    });
+    this.refresh().catch(() => undefined);
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.maskedInput.focused = value;
+  }
+
+  invalidate(): void {
+    this.maskedInput.invalidate();
+  }
+
+  handleInput(keyData: string): void {
+    if (this.mode === "key-entry") {
+      this.maskedInput.handleInput(keyData);
+      this.options.tui.requestRender();
+      return;
+    }
+    if (this.mode !== "menu") {
+      return;
+    }
+    const actions = this.actions();
+    if (
+      matchesKey(keyData, Key.down) ||
+      keyData === "\u001b[B" ||
+      keyData === "\u001bOB"
+    ) {
+      this.selectedIndex = (this.selectedIndex + 1) % actions.length;
+    } else if (
+      matchesKey(keyData, Key.up) ||
+      keyData === "\u001b[A" ||
+      keyData === "\u001bOA"
+    ) {
+      this.selectedIndex =
+        (this.selectedIndex - 1 + actions.length) % actions.length;
+    } else if (matchesKey(keyData, Key.enter) || keyData === "\r") {
+      this.activate(actions[this.selectedIndex]);
+    } else {
+      return;
+    }
+    this.options.tui.requestRender();
+  }
+
+  render(width: number): string[] {
+    const { theme } = this.options;
+    const enabled = this.options.currentValue === "On";
+    const lines = [
+      theme.fg("accent", theme.bold("  Jev consultation filter")),
+      "",
+    ];
+    if (this.credentials) {
+      lines.push(`  Transport: ${transportLabel(this.credentials)}`);
+      lines.push(`  Filter: ${enabled ? "On" : "Off"}`);
+    } else if (this.mode === "verifying") {
+      lines.push("  Checking available Jev credentials…");
+    } else {
+      lines.push(
+        "  No Jev credentials found. Enter a TypeSafe API key below, or add"
+      );
+      lines.push("  an OpenRouter login in pi; it is reused automatically.");
+    }
+    if (this.notice) {
+      lines.push("");
+      lines.push(theme.fg("warning", `  ${this.notice}`));
+    }
+    lines.push("");
+    if (this.mode === "verifying") {
+      lines.push("  Verifying with a live Jev call…");
+    } else if (this.mode === "key-entry") {
+      lines.push(
+        `  ${this.maskedInput.render(Math.max(10, width - 4))[0] ?? ""}`
+      );
+      lines.push(theme.fg("dim", "  Enter: verify · Esc: cancel"));
+    } else {
+      for (const [index, label] of this.labels().entries()) {
+        const prefix = index === this.selectedIndex ? "→ " : "  ";
+        lines.push(`${prefix}${label}`);
+      }
+    }
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+
+  private actions(): SetupAction[] {
+    if (!this.credentials) {
+      return ["enter-key", "done"];
+    }
+    const enabled = this.options.currentValue === "On";
+    const actions: SetupAction[] = [enabled ? "verify-again" : "verify-enable"];
+    actions.push("disable");
+    if (
+      this.credentials.source === "bun-secrets" ||
+      this.credentials.source === "file"
+    ) {
+      actions.push("disable-clear");
+    }
+    actions.push("done");
+    return actions;
+  }
+
+  private actionLabels(): Record<SetupAction, string> {
+    return {
+      disable: "Disable",
+      "disable-clear": "Disable and clear stored key",
+      done: "Done",
+      "enter-key": "Enter a TypeSafe API key",
+      "verify-again": "Verify again",
+      "verify-enable": "Verify and enable",
+    };
+  }
+
+  private labels(): string[] {
+    const labels = this.actionLabels();
+    return this.actions().map((action) => labels[action]);
+  }
+
+  private async refresh(): Promise<void> {
+    const wasVerifying = this.mode === "verifying";
+    this.mode = "verifying";
+    if (!wasVerifying) {
+      this.options.tui.requestRender();
+    }
+    this.credentials = await this.deps.resolveTransport?.();
+    this.mode = "menu";
+    this.selectedIndex = 0;
+    if (this.credentials?.source === "advisor-json") {
+      this.notice ??= consumePlaintextKeyWarning();
+    }
+    this.options.tui.requestRender();
+  }
+
+  private activate(action: SetupAction): void {
+    switch (action) {
+      case "done":
+        this.options.done();
+        return;
+      case "enter-key":
+        this.mode = "key-entry";
+        return;
+      case "disable":
+        this.notice = undefined;
+        this.options.done("Off");
+        return;
+      case "disable-clear":
+        this.disableAndClear().catch(() => undefined);
+        return;
+      case "verify-again":
+      case "verify-enable":
+        this.verifyAndEnable().catch(() => undefined);
+        return;
+      default:
+        return;
+    }
+  }
+
+  private async disableAndClear(): Promise<void> {
+    const clear = this.deps.clearStoredKey;
+    if (!clear) {
+      return;
+    }
+    const result = await clear();
+    this.credentials = undefined;
+    this.notice = result.message;
+    this.options.done("Off");
+  }
+
+  private async verifyAndEnable(): Promise<void> {
+    const { credentials } = this;
+    if (!(credentials && this.deps.verify)) {
+      return;
+    }
+    this.mode = "verifying";
+    this.notice = undefined;
+    this.options.tui.requestRender();
+    const outcome = await this.deps.verify(credentials);
+    this.mode = "menu";
+    if (!outcome.ok) {
+      this.notice = `Verification failed: ${outcome.message ?? "unknown error"}`;
+      this.options.tui.requestRender();
+      return;
+    }
+    if (
+      credentials.transport === "typesafe" &&
+      credentials.source === "advisor-json"
+    ) {
+      const stored = await this.deps.writeKey?.(credentials.apiKey);
+      if (!stored?.ok) {
+        this.notice =
+          stored?.message ??
+          "Storing the key failed; the plaintext advisor.json key keeps working.";
+        this.options.tui.requestRender();
+        return;
+      }
+      const removed = this.deps.removePlaintextKey?.();
+      this.notice = removed?.ok
+        ? "Key moved from advisor.json into the secure store."
+        : `Stored securely, but ${removed?.message ?? "removing the plaintext copy failed; remove it yourself."}`;
+    }
+    this.options.done("On");
+  }
+
+  private async submitEnteredKey(value: string): Promise<void> {
+    const key = value.trim();
+    if (!key) {
+      return;
+    }
+    if (!this.deps.verify) {
+      return;
+    }
+    this.mode = "verifying";
+    this.options.tui.requestRender();
+    const outcome = await this.deps.verify({
+      apiKey: key,
+      transport: "typesafe",
+    });
+    this.mode = "menu";
+    if (!outcome.ok) {
+      this.notice = `Verification failed: ${outcome.message ?? "unknown error"}`;
+      this.options.tui.requestRender();
+      return;
+    }
+    const stored = await this.deps.writeKey?.(key);
+    if (!stored?.ok) {
+      this.notice = stored?.message ?? "Storing the key failed.";
+      this.options.tui.requestRender();
+      return;
+    }
+    this.notice = `${stored.message} Verification succeeded.`;
+    await this.refresh();
+    this.options.done("On");
+  }
+}

package/src/ui/masked-input.ts

@@ -0,0 +1,68 @@
+import {
+  type Component,
+  type Focusable,
+  Input,
+  truncateToWidth,
+} from "@earendil-works/pi-tui";
+
+export interface MaskedInputOptions {
+  onEscape?: () => void;
+  onSubmit?: (value: string) => void;
+  placeholder?: string;
+}
+
+interface InputPrivateFields {
+  cursor: number;
+}
+
+/** Single-line secret input rendering bullets; the value never reaches the screen. */
+export class MaskedInput implements Component, Focusable {
+  private readonly input: Input;
+  private readonly options: MaskedInputOptions;
+  private _focused = true;
+
+  constructor(options: MaskedInputOptions = {}) {
+    this.options = options;
+    this.input = new Input({ placeholder: options.placeholder });
+    this.input.focused = true;
+    this.input.onSubmit = (value) => options.onSubmit?.(value);
+    this.input.onEscape = () => options.onEscape?.();
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.input.focused = value;
+  }
+
+  getValue(): string {
+    return this.input.getValue();
+  }
+
+  setValue(value: string): void {
+    this.input.setValue(value);
+  }
+
+  handleInput(keyData: string): void {
+    this.input.handleInput(keyData);
+  }
+
+  invalidate(): void {
+    this.input.invalidate();
+  }
+
+  render(width: number): string[] {
+    const value = this.input.getValue();
+    // Compatibility-only read for the caret position; Input does not expose it.
+    const { cursor } = this.input as unknown as InputPrivateFields;
+    const masked = `${"•".repeat(Math.min(cursor, value.length))}█${"•".repeat(Math.max(0, value.length - cursor))}`;
+    const placeholder =
+      value.length === 0 && this.options.placeholder
+        ? this.options.placeholder
+        : masked;
+    return [truncateToWidth(placeholder, Math.max(1, width))];
+  }
+}

package/src/ui/settings-items.ts

@@ -1,6 +1,18 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { SettingItem } from "@earendil-works/pi-tui";
+import {
+  DEFAULT_JEV_DIGEST_MAX_CHARS,
+  DEFAULT_JEV_FILTER_NOUL_MARGIN,
+  DEFAULT_JEV_FILTER_OVERRIDE_WINDOW,
+  DEFAULT_JEV_FILTER_SKIP_CONFIDENCE,
+  DEFAULT_JEV_MODEL,
+  DEFAULT_JEV_PRICE_PER_MTOK,
+  DEFAULT_JEV_TIMEOUT_MS,
+  DEFAULT_JEV_TRANSPORT,
+  DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD,
+} from "../config/types.ts";
 import { isValidAdvisorToolPolicies } from "../config/validation.ts";
+import { JevSetupSubmenu } from "./jev-setup-submenu.ts";
 import {
   contextDescription,
   currentContextLabel,
@@ -40,6 +52,154 @@ const toggle = (
   values: TOGGLE_VALUES,
 });
 
+const jevItems = (
+  settings: AdvisorSettings,
+  theme: Theme,
+  tui: RenderRequester
+): SettingItem[] => [
+  {
+    currentValue: settingValue(settings.jevFilterEnabled, false),
+    description:
+      "Screen low-stakes ask_advisor consultations with Jev; guided setup verifies credentials.",
+    id: "jevFilter",
+    label: "Jev consultation filter",
+    submenu: (currentValue, done) =>
+      new JevSetupSubmenu({ currentValue, done, theme, tui }),
+  },
+  {
+    currentValue: String(
+      settings.jevFilterSkipConfidence ?? DEFAULT_JEV_FILTER_SKIP_CONFIDENCE
+    ),
+    description:
+      "Required probability on negligible stakes before a consultation is skipped.",
+    id: "jevFilterSkipConfidence",
+    label: "Jev skip confidence",
+    values: numericValues(
+      settings.jevFilterSkipConfidence ?? DEFAULT_JEV_FILTER_SKIP_CONFIDENCE,
+      [0.6, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]
+    ),
+  },
+  {
+    currentValue: String(
+      settings.jevFilterNoulMargin ?? DEFAULT_JEV_FILTER_NOUL_MARGIN
+    ),
+    description:
+      "Extra margin over a coin flip required on self-answerability before skipping.",
+    id: "jevFilterNoulMargin",
+    label: "Jev Noul margin",
+    values: numericValues(
+      settings.jevFilterNoulMargin ?? DEFAULT_JEV_FILTER_NOUL_MARGIN,
+      [0.1, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45]
+    ),
+  },
+  {
+    currentValue: `${settings.jevFilterOverrideWindow ?? DEFAULT_JEV_FILTER_OVERRIDE_WINDOW} turns`,
+    description:
+      "Turns after a skip during which the same question passes automatically.",
+    id: "jevFilterOverrideWindow",
+    label: "Jev override window",
+    values: numericValues(
+      settings.jevFilterOverrideWindow ?? DEFAULT_JEV_FILTER_OVERRIDE_WINDOW,
+      [0, 3, 5, 10, 20, 50]
+    ).map((value) => `${value} turns`),
+  },
+  {
+    currentValue: settings.jevModel ?? DEFAULT_JEV_MODEL,
+    description: "TypeSafe Jev model used for screening and turn-gate checks.",
+    id: "jevModel",
+    label: "Jev model",
+    submenu: (_currentValue, done) =>
+      new TextSettingSubmenu({
+        description:
+          "Enter a TypeSafe model name (for example jev-latest or jev-1.13.0).",
+        initial: settings.jevModel ?? DEFAULT_JEV_MODEL,
+        onCancel: done,
+        onSubmit: (value) => ({ value: value.trim() || DEFAULT_JEV_MODEL }),
+        theme,
+        title: "Jev model",
+        tui,
+      }),
+  },
+  {
+    currentValue: String(settings.jevTimeoutMs ?? DEFAULT_JEV_TIMEOUT_MS),
+    description: "Total wall-time budget for one Jev call, including retries.",
+    id: "jevTimeoutMs",
+    label: "Jev timeout ms",
+    values: numericValues(
+      settings.jevTimeoutMs ?? DEFAULT_JEV_TIMEOUT_MS,
+      [1000, 2000, 5000, 8000, 15_000, 30_000]
+    ),
+  },
+  {
+    currentValue: String(
+      settings.jevDigestMaxChars ?? DEFAULT_JEV_DIGEST_MAX_CHARS
+    ),
+    description: "Conversation characters sent to Jev as screening evidence.",
+    id: "jevDigestMaxChars",
+    label: "Jev digest chars",
+    values: numericValues(
+      settings.jevDigestMaxChars ?? DEFAULT_JEV_DIGEST_MAX_CHARS,
+      [0, 1000, 2000, 4000, 8000, 15_000]
+    ),
+  },
+  {
+    currentValue: String(
+      settings.jevPricePerMtok ?? DEFAULT_JEV_PRICE_PER_MTOK
+    ),
+    description:
+      "Assumed TypeSafe price per million input tokens for cost lines.",
+    id: "jevPricePerMtok",
+    label: "Jev price/Mtok",
+    values: numericValues(
+      settings.jevPricePerMtok ?? DEFAULT_JEV_PRICE_PER_MTOK,
+      [0.01, 0.02, 0.042, 0.05, 0.1]
+    ),
+  },
+  {
+    currentValue:
+      settings.jevTurnGateEveryTurns === 0 ||
+      settings.jevTurnGateEveryTurns === undefined
+        ? "Off"
+        : `every ${settings.jevTurnGateEveryTurns} turns`,
+    description:
+      "Proactively consult the Advisor every N turns without a consultation (0 = off).",
+    id: "jevTurnGateEveryTurns",
+    label: "Jev turn gate",
+    values: [
+      "Off",
+      "every 3 turns",
+      "every 5 turns",
+      "every 10 turns",
+      "every 20 turns",
+    ],
+  },
+  {
+    currentValue: String(
+      settings.jevTurnGateNoulThreshold ?? DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD
+    ),
+    description:
+      "Jev confidence required before the turn gate interrupts with advice.",
+    id: "jevTurnGateNoulThreshold",
+    label: "Jev 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 createSettingsItems = ({
   effortLevels,
   presets,
@@ -317,7 +477,8 @@ export const createSettingsItems = ({
       "Allow anonymized Advisor outcomes to be logged globally.",
       settings.outcomeLogging,
       false
-    )
+    ),
+    ...jevItems(settings, theme, tui)
   );
   return items;
 };

package/src/ui/settings-mutations.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_JEV_MODEL } from "../config/types.ts";
 import type { AdvisorSettings, ContextPreset, SettingValue } from "./types.ts";
 
 const BOOLEAN_SETTING_IDS = new Set([
@@ -70,6 +71,40 @@ export const mutateAdvisorSettings = (
     case "gitContextMaxChars":
       settings.gitContextMaxChars = Number(value);
       break;
+    case "jevFilter":
+      settings.jevFilterEnabled = value === "On";
+      break;
+    case "jevFilterSkipConfidence":
+      settings.jevFilterSkipConfidence = Number(value);
+      break;
+    case "jevFilterNoulMargin":
+      settings.jevFilterNoulMargin = Number(value);
+      break;
+    case "jevFilterOverrideWindow":
+      settings.jevFilterOverrideWindow = Number(value.replace(" turns", ""));
+      break;
+    case "jevTurnGateEveryTurns":
+      settings.jevTurnGateEveryTurns =
+        value === "Off" ? 0 : Number(value.replace(/[^0-9]/g, ""));
+      break;
+    case "jevTurnGateNoulThreshold":
+      settings.jevTurnGateNoulThreshold = Number(value);
+      break;
+    case "jevModel":
+      settings.jevModel = value.trim() || DEFAULT_JEV_MODEL;
+      break;
+    case "jevTimeoutMs":
+      settings.jevTimeoutMs = Number(value);
+      break;
+    case "jevDigestMaxChars":
+      settings.jevDigestMaxChars = Number(value);
+      break;
+    case "jevPricePerMtok":
+      settings.jevPricePerMtok = Number(value);
+      break;
+    case "jevTransport":
+      settings.jevTransport = value as AdvisorSettings["jevTransport"];
+      break;
     default:
       if (BOOLEAN_SETTING_IDS.has(id)) {
         (settings as unknown as Record<string, SettingValue | boolean>)[id] =

package/src/ui/types.ts

@@ -69,6 +69,17 @@ export interface AdvisorSettings {
   gitContext?: GitContextLevel;
   gitContextMaxChars?: number;
   herdrIntegration?: boolean;
+  jevDigestMaxChars?: number;
+  jevFilterEnabled?: boolean;
+  jevFilterNoulMargin?: number;
+  jevFilterOverrideWindow?: number;
+  jevFilterSkipConfidence?: number;
+  jevModel?: string;
+  jevPricePerMtok?: number;
+  jevTimeoutMs?: number;
+  jevTransport?: "auto" | "typesafe" | "openrouter";
+  jevTurnGateEveryTurns?: number;
+  jevTurnGateNoulThreshold?: number;
   loopThreshold?: number;
   maxCallsPerSession?: number;
   outcomeLogging?: boolean;