pi-openai-toolkit 0.9.0 → 0.10.0

package/src/config.ts

@@ -11,10 +11,21 @@ import {
 	DEFAULT_NATIVE_FALLBACK_CONFIG,
 	DEFAULT_WEB_SEARCH_CONFIG,
 	RESPONSES_COMPACT_CAPABLE_APIS,
+	BREAKER_LIMIT_MAX,
+	BREAKER_LIMIT_MIN,
+	BREAKER_WINDOW_MAX,
+	BREAKER_WINDOW_MIN,
+	CLASSIFIER_MAX_LAG_MAX,
+	CLASSIFIER_MAX_LAG_MIN,
+	DEFAULT_CLASSIFIER_TIMEOUT_MS,
+	EVIDENCE_ROUNDS_MAX,
+	EVIDENCE_ROUNDS_MIN,
 	REVIEWER_TIMEOUT_MAX_MS,
 	REVIEWER_TIMEOUT_MIN_MS,
 	THINKING_LEVELS,
 	TOOLKIT_ID,
+	type AutoModeCircuitBreakerConfig,
+	type AutoModeClassifierConfig,
 	type AutoModeConfig,
 	type AutoModeGate,
 	type CompactionConfig,
@@ -47,7 +58,21 @@ const NATIVE_FALLBACK_FIELDS = new Set(["enabled", "model", "thinkingLevel"]);
 const AUTO_COMPACTION_FIELDS = new Set(["enabled", "continuation", "unsupportedFallback", "reserveTokens"]);
 const WEB_SEARCH_FIELDS = new Set(["enabled", "models"]);
 const IMAGE_GENERATION_FIELDS = new Set(["enabled"]);
-const AUTO_MODE_FIELDS = new Set(["enabled", "models", "reviewerModel", "gate", "extraTools", "timeoutMs"]);
+const AUTO_MODE_FIELDS = new Set([
+	"enabled",
+	"models",
+	"reviewerModel",
+	"gate",
+	"extraTools",
+	"timeoutMs",
+	"transcript",
+	"evidenceTools",
+	"maxEvidenceRounds",
+	"classifier",
+	"circuitBreaker",
+]);
+const AUTO_MODE_CLASSIFIER_FIELDS = new Set(["enabled", "model", "timeoutMs", "maxLag"]);
+const AUTO_MODE_BREAKER_FIELDS = new Set(["consecutiveDenials", "recentDenials", "windowSize"]);
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
@@ -156,6 +181,21 @@ function toNonNegativeInteger(value: unknown, fieldPath: string, warnings: strin
 	return undefined;
 }
 
+function toBoundedInteger(
+	value: unknown,
+	fieldPath: string,
+	warnings: string[],
+	min: number,
+	max: number,
+): number | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value >= min && value <= max) {
+		return value;
+	}
+	warnings.push(`Ignoring ${fieldPath}: expected an integer between ${min} and ${max}.`);
+	return undefined;
+}
+
 function toSupportedApis(
 	value: unknown,
 	fieldPath: string,
@@ -233,6 +273,8 @@ function cloneDefaults(): ToolkitConfig {
 			...DEFAULT_AUTO_MODE_CONFIG,
 			models: [...DEFAULT_AUTO_MODE_CONFIG.models],
 			extraTools: [...DEFAULT_AUTO_MODE_CONFIG.extraTools],
+			classifier: { ...DEFAULT_AUTO_MODE_CONFIG.classifier },
+			circuitBreaker: { ...DEFAULT_AUTO_MODE_CONFIG.circuitBreaker },
 		},
 	};
 }
@@ -404,6 +446,116 @@ function applyAutoModeConfig(
 	if (timeoutMs !== undefined) {
 		resolved.timeoutMs = timeoutMs;
 	}
+
+	resolved.transcript = toBoolean(raw.transcript, "autoMode.transcript", warnings) ?? resolved.transcript;
+	resolved.evidenceTools =
+		toBoolean(raw.evidenceTools, "autoMode.evidenceTools", warnings) ?? resolved.evidenceTools;
+
+	const maxEvidenceRounds = toBoundedInteger(
+		raw.maxEvidenceRounds,
+		"autoMode.maxEvidenceRounds",
+		warnings,
+		EVIDENCE_ROUNDS_MIN,
+		EVIDENCE_ROUNDS_MAX,
+	);
+	if (maxEvidenceRounds !== undefined) {
+		resolved.maxEvidenceRounds = maxEvidenceRounds;
+	}
+
+	if (raw.classifier !== undefined) {
+		if (isRecord(raw.classifier)) {
+			applyAutoModeClassifierConfig(raw.classifier, resolved.classifier, warnings);
+		} else {
+			warnings.push("Ignoring autoMode.classifier: expected a JSON object.");
+		}
+	}
+
+	if (raw.circuitBreaker !== undefined) {
+		if (isRecord(raw.circuitBreaker)) {
+			applyAutoModeBreakerConfig(raw.circuitBreaker, resolved.circuitBreaker, warnings);
+		} else {
+			warnings.push("Ignoring autoMode.circuitBreaker: expected a JSON object.");
+		}
+	}
+}
+
+function applyAutoModeClassifierConfig(
+	raw: Record<string, unknown>,
+	resolved: AutoModeClassifierConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, AUTO_MODE_CLASSIFIER_FIELDS, "autoMode.classifier", warnings);
+	resolved.enabled =
+		toBoolean(raw.enabled, "autoMode.classifier.enabled", warnings) ?? resolved.enabled;
+
+	const model = toModelSpec(raw.model, "autoMode.classifier.model", warnings);
+	if (model !== undefined) {
+		resolved.model = model === null ? undefined : model;
+	}
+
+	const timeoutMs =
+		toBoundedInteger(
+			raw.timeoutMs,
+			"autoMode.classifier.timeoutMs",
+			warnings,
+			REVIEWER_TIMEOUT_MIN_MS,
+			REVIEWER_TIMEOUT_MAX_MS,
+		) ?? DEFAULT_CLASSIFIER_TIMEOUT_MS;
+	if (raw.timeoutMs !== undefined) {
+		resolved.timeoutMs = timeoutMs;
+	}
+
+	const maxLag = toBoundedInteger(
+		raw.maxLag,
+		"autoMode.classifier.maxLag",
+		warnings,
+		CLASSIFIER_MAX_LAG_MIN,
+		CLASSIFIER_MAX_LAG_MAX,
+	);
+	if (maxLag !== undefined) {
+		resolved.maxLag = maxLag;
+	}
+}
+
+function applyAutoModeBreakerConfig(
+	raw: Record<string, unknown>,
+	resolved: AutoModeCircuitBreakerConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, AUTO_MODE_BREAKER_FIELDS, "autoMode.circuitBreaker", warnings);
+
+	const consecutiveDenials = toBoundedInteger(
+		raw.consecutiveDenials,
+		"autoMode.circuitBreaker.consecutiveDenials",
+		warnings,
+		BREAKER_LIMIT_MIN,
+		BREAKER_LIMIT_MAX,
+	);
+	if (consecutiveDenials !== undefined) {
+		resolved.consecutiveDenials = consecutiveDenials;
+	}
+
+	const recentDenials = toBoundedInteger(
+		raw.recentDenials,
+		"autoMode.circuitBreaker.recentDenials",
+		warnings,
+		BREAKER_LIMIT_MIN,
+		BREAKER_LIMIT_MAX,
+	);
+	if (recentDenials !== undefined) {
+		resolved.recentDenials = recentDenials;
+	}
+
+	const windowSize = toBoundedInteger(
+		raw.windowSize,
+		"autoMode.circuitBreaker.windowSize",
+		warnings,
+		BREAKER_WINDOW_MIN,
+		BREAKER_WINDOW_MAX,
+	);
+	if (windowSize !== undefined) {
+		resolved.windowSize = windowSize;
+	}
 }
 
 /**

package/src/types.ts

@@ -111,11 +111,52 @@ export type AutoModeConfig = {
 	extraTools: string[];
 	/** Reviewer deadline in ms; expiry degrades to human confirmation or fail-closed. */
 	timeoutMs: number;
+	/** Give the reviewer a bounded transcript so it can judge user authorization. */
+	transcript: boolean;
+	/** Let the reviewer spend read-only tool calls establishing facts before deciding. */
+	evidenceTools: boolean;
+	maxEvidenceRounds: number;
+	/** Non-blocking trajectory pre-scorer that can satisfy ordinary gated calls. */
+	classifier: AutoModeClassifierConfig;
+	/** End a turn that keeps getting denied instead of negotiating forever. */
+	circuitBreaker: AutoModeCircuitBreakerConfig;
+};
+
+export type AutoModeClassifierConfig = {
+	enabled: boolean;
+	/** "provider/model-id"; falls back to `autoMode.reviewerModel` when unset. */
+	model?: string;
+	timeoutMs: number;
+	/** How many tool calls may elapse between scoring and use before a score is stale. */
+	maxLag: number;
+};
+
+export type AutoModeCircuitBreakerConfig = {
+	/** Consecutive reviewer denials in one turn that end the turn. 0 disables. */
+	consecutiveDenials: number;
+	/** Denials inside `windowSize` reviewed calls that end the turn. 0 disables. */
+	recentDenials: number;
+	windowSize: number;
 };
 
 export const REVIEWER_TIMEOUT_MIN_MS = 1_000;
 export const REVIEWER_TIMEOUT_MAX_MS = 120_000;
 
+/** Read-only investigation rounds the reviewer may spend before it must answer. */
+export const EVIDENCE_ROUNDS_MIN = 0;
+export const EVIDENCE_ROUNDS_MAX = 8;
+
+export const CLASSIFIER_MAX_LAG_MIN = 0;
+export const CLASSIFIER_MAX_LAG_MAX = 20;
+
+export const DEFAULT_CLASSIFIER_TIMEOUT_MS = 15_000;
+
+/** Denial counts are small integers; 0 disables the matching trigger. */
+export const BREAKER_LIMIT_MIN = 0;
+export const BREAKER_LIMIT_MAX = 100;
+export const BREAKER_WINDOW_MIN = 1;
+export const BREAKER_WINDOW_MAX = 200;
+
 export type ToolkitConfig = {
 	compaction: CompactionConfig;
 	webSearch: WebSearchConfig;
@@ -490,6 +531,20 @@ export const DEFAULT_AUTO_MODE_CONFIG: AutoModeConfig = {
 	gate: "side-effect",
 	extraTools: [],
 	timeoutMs: 30_000,
+	transcript: true,
+	evidenceTools: true,
+	maxEvidenceRounds: 3,
+	classifier: {
+		enabled: false,
+		model: undefined,
+		timeoutMs: DEFAULT_CLASSIFIER_TIMEOUT_MS,
+		maxLag: 2,
+	},
+	circuitBreaker: {
+		consecutiveDenials: 3,
+		recentDenials: 10,
+		windowSize: 50,
+	},
 };
 
 export const DEFAULT_TOOLKIT_CONFIG: ToolkitConfig = {