pi-cohort 2.0.0

package/src/runs/shared/long-running-guard.ts

@@ -0,0 +1,175 @@
+import type { ResolvedControlConfig } from "../../shared/types.ts";
+
+interface LongRunningNoticeMetrics {
+	startedAt: number;
+	now: number;
+	turns: number;
+	tokens: number;
+}
+
+type LongRunningTriggerReason = "time_threshold" | "turn_threshold" | "token_threshold";
+
+interface FailedMutatingAttempt {
+	tool: string;
+	path?: string;
+	error: string;
+	ts: number;
+}
+
+interface MutatingFailureState {
+	consecutiveFailures: number;
+	lastFailureAt?: number;
+	recentFailures: FailedMutatingAttempt[];
+	lastMutatingPath?: string;
+	repeatedPathFailures: number;
+}
+
+const MUTATING_BASH_PATTERNS = [
+	/(^|[;&|()\s])rm\s+/,
+	/(^|[;&|()\s])mv\s+/,
+	/(^|[;&|()\s])cp\s+/,
+	/(^|[;&|()\s])mkdir\s+/,
+	/(^|[;&|()\s])touch\s+/,
+	/(^|[;&|()\s])git\s+apply\b/,
+	/(^|[;&|()\s])patch\s+/,
+	/(^|[;&|()\s])sed\s+[^\n;&|]*\s-i\b/,
+	/(^|[;&|()\s])perl\s+[^\n;&|]*\s-pi\b/,
+	/(^|[;&|()]|\n)\s*tee\s+[^|&;]+/,
+	/\b(writeFile|writeFileSync|appendFile|appendFileSync)\b/,
+	/\bwrite_text\s*\(/,
+	/\bopen\s*\([^)]*,\s*["'][wa]/,
+];
+
+const MUTATING_FAILURE_HINTS = [
+	"failed",
+	"error",
+	"no exact match",
+	"did not match",
+	"malformed",
+	"rejected",
+	"unable",
+	"cannot",
+	"could not",
+];
+
+export function resolveCurrentPath(toolName: string | undefined, args: Record<string, unknown> | undefined): string | undefined {
+	if (!toolName || !args) return undefined;
+	const direct = ["path", "file", "filename", "target", "cwd"];
+	for (const key of direct) {
+		const value = args[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+	}
+	if (toolName === "bash") {
+		const command = typeof args.command === "string" ? args.command : undefined;
+		if (!command) return undefined;
+		const redirect = command.match(/(?:>|>>|tee\s+)(\S+)/);
+		if (redirect?.[1]) return redirect[1];
+	}
+	return undefined;
+}
+
+function hasUnquotedFileRedirection(command: string): boolean {
+	let inSingle = false;
+	let inDouble = false;
+	for (let i = 0; i < command.length; i++) {
+		const char = command[i]!;
+		if (char === "'" && !inDouble) {
+			inSingle = !inSingle;
+			continue;
+		}
+		if (char === '"' && !inSingle) {
+			inDouble = !inDouble;
+			continue;
+		}
+		if (inSingle || inDouble) continue;
+		if (char !== ">") continue;
+		if (command[i - 1] === "-") continue;
+		const isDouble = command[i + 1] === ">";
+		let cursor = i + (isDouble ? 2 : 1);
+		while (cursor < command.length && /\s/.test(command[cursor]!)) cursor++;
+		if (cursor >= command.length) continue;
+		const targetStart = command[cursor]!;
+		if (targetStart === "&" || targetStart === "|" || targetStart === ";") continue;
+		if (targetStart === "(" || targetStart === ")") continue;
+		return true;
+	}
+	return false;
+}
+
+export function isMutatingBashCommand(command: string): boolean {
+	return hasUnquotedFileRedirection(command) || MUTATING_BASH_PATTERNS.some((pattern) => pattern.test(command));
+}
+
+export function isMutatingTool(toolName: string | undefined, args: Record<string, unknown> | undefined): boolean {
+	if (!toolName) return false;
+	if (toolName === "edit" || toolName === "write") return true;
+	if (toolName !== "bash") return false;
+	const command = typeof args?.command === "string" ? args.command : "";
+	if (!command.trim()) return false;
+	return isMutatingBashCommand(command);
+}
+
+export function didMutatingToolFail(text: string): boolean {
+	const lowered = text.toLowerCase();
+	return MUTATING_FAILURE_HINTS.some((hint) => lowered.includes(hint));
+}
+
+export function nextLongRunningTrigger(
+	config: ResolvedControlConfig,
+	metrics: LongRunningNoticeMetrics,
+): LongRunningTriggerReason | undefined {
+	if (metrics.now - metrics.startedAt >= config.activeNoticeAfterMs) return "time_threshold";
+	if (config.activeNoticeAfterTurns !== undefined && metrics.turns >= config.activeNoticeAfterTurns) return "turn_threshold";
+	if (config.activeNoticeAfterTokens !== undefined && metrics.tokens >= config.activeNoticeAfterTokens) return "token_threshold";
+	return undefined;
+}
+
+export function resetMutatingFailureState(state: MutatingFailureState): void {
+	state.consecutiveFailures = 0;
+	state.lastFailureAt = undefined;
+	state.recentFailures = [];
+	state.lastMutatingPath = undefined;
+	state.repeatedPathFailures = 0;
+}
+
+export function createMutatingFailureState(): MutatingFailureState {
+	return {
+		consecutiveFailures: 0,
+		recentFailures: [],
+		repeatedPathFailures: 0,
+	};
+}
+
+export function recordMutatingFailure(
+	state: MutatingFailureState,
+	input: FailedMutatingAttempt,
+	windowMs: number,
+): void {
+	if (state.lastFailureAt === undefined || input.ts - state.lastFailureAt > windowMs) {
+		state.consecutiveFailures = 0;
+		state.recentFailures = [];
+		state.repeatedPathFailures = 0;
+		state.lastMutatingPath = undefined;
+	}
+	state.lastFailureAt = input.ts;
+	state.consecutiveFailures += 1;
+	if (input.path && state.lastMutatingPath === input.path) {
+		state.repeatedPathFailures += 1;
+	} else if (input.path) {
+		state.lastMutatingPath = input.path;
+		state.repeatedPathFailures = 1;
+	}
+	state.recentFailures.push(input);
+	if (state.recentFailures.length > 3) state.recentFailures.shift();
+}
+
+export function shouldEscalateMutatingFailures(state: MutatingFailureState, threshold: number): boolean {
+	return state.consecutiveFailures >= threshold || state.repeatedPathFailures >= threshold;
+}
+
+export function summarizeRecentMutatingFailures(state: MutatingFailureState): string | undefined {
+	if (state.recentFailures.length === 0) return undefined;
+	return state.recentFailures
+		.map((entry) => `${entry.tool}${entry.path ? `(${entry.path})` : ""}: ${entry.error}`)
+		.join(" | ");
+}

package/src/runs/shared/model-fallback.ts

@@ -0,0 +1,103 @@
+import type { ModelInfo as AvailableModelInfo } from "../../shared/model-info.ts";
+import type { Usage } from "../../shared/types.ts";
+
+export type { AvailableModelInfo };
+
+interface ModelAttemptSummary {
+	model: string;
+	success: boolean;
+	exitCode?: number | null;
+	error?: string;
+	usage?: Usage;
+}
+
+export function splitThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
+	const colonIdx = model.lastIndexOf(":");
+	if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
+	return {
+		baseModel: model.substring(0, colonIdx),
+		thinkingSuffix: model.substring(colonIdx),
+	};
+}
+
+export function resolveModelCandidate(
+	model: string | undefined,
+	availableModels: AvailableModelInfo[] | undefined,
+	preferredProvider?: string,
+): string | undefined {
+	if (!model) return undefined;
+	if (model.includes("/")) return model;
+	if (!availableModels || availableModels.length === 0) return model;
+
+	const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
+	const matches = availableModels.filter((entry) => entry.id === baseModel);
+	if (preferredProvider) {
+		const preferredMatch = matches.find((entry) => entry.provider === preferredProvider);
+		if (preferredMatch) return `${preferredMatch.fullId}${thinkingSuffix}`;
+	}
+	if (matches.length !== 1) return model;
+	return `${matches[0]!.fullId}${thinkingSuffix}`;
+}
+
+export function buildModelCandidates(
+	primaryModel: string | undefined,
+	fallbackModels: string[] | undefined,
+	availableModels: AvailableModelInfo[] | undefined,
+	preferredProvider?: string,
+): string[] {
+	const seen = new Set<string>();
+	const candidates: string[] = [];
+	for (const raw of [primaryModel, ...(fallbackModels ?? [])]) {
+		if (!raw) continue;
+		const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
+		if (!normalized || seen.has(normalized)) continue;
+		seen.add(normalized);
+		candidates.push(normalized);
+	}
+	return candidates;
+}
+
+const RETRYABLE_MODEL_FAILURE_PATTERNS = [
+	/rate\s*limit/i,
+	/too many requests/i,
+	/\b429\b/,
+	/quota/i,
+	/billing/i,
+	/credit/i,
+	/auth(?:entication)?/i,
+	/unauthori[sz]ed/i,
+	/forbidden/i,
+	/api key/i,
+	/token expired/i,
+	/invalid key/i,
+	/provider.*unavailable/i,
+	/model.*unavailable/i,
+	/model.*disabled/i,
+	/model.*not found/i,
+	/unknown model/i,
+	/overloaded/i,
+	/service unavailable/i,
+	/temporar(?:ily)? unavailable/i,
+	/connection refused/i,
+	/fetch failed/i,
+	/network error/i,
+	/socket hang up/i,
+	/upstream/i,
+	/timed? out/i,
+	/timeout/i,
+	/\b502\b/,
+	/\b503\b/,
+	/\b504\b/,
+];
+
+export function isRetryableModelFailure(error: string | undefined): boolean {
+	if (!error) return false;
+	return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
+}
+
+export function formatModelAttemptNote(attempt: ModelAttemptSummary, nextModel?: string): string {
+	const failure = attempt.error?.trim() || `exit ${attempt.exitCode ?? 1}`;
+	return nextModel
+		? `[fallback] ${attempt.model} failed: ${failure}. Retrying with ${nextModel}.`
+		: `[fallback] ${attempt.model} failed: ${failure}.`;
+}