@oh-my-pi/pi-coding-agent 15.7.1 → 15.7.2

package/src/config/settings-schema.ts

@@ -1,6 +1,6 @@
 import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
-import { getThinkingLevelMetadata } from "../thinking";
+import { AUTO_THINKING, getConfiguredThinkingLevelMetadata, getThinkingLevelMetadata } from "../thinking";
 import {
 	TINY_MODEL_DEVICE_DEFAULT,
 	TINY_MODEL_DEVICE_SETTING_OPTIONS,
@@ -12,6 +12,9 @@ import {
 	TINY_MODEL_DTYPE_SETTING_VALUES,
 } from "../tiny/dtype";
 import {
+	AUTO_THINKING_MODEL_OPTIONS,
+	AUTO_THINKING_MODEL_VALUES,
+	ONLINE_AUTO_THINKING_MODEL_KEY,
 	ONLINE_MEMORY_MODEL_KEY,
 	ONLINE_TINY_TITLE_MODEL_KEY,
 	TINY_MEMORY_MODEL_OPTIONS,
@@ -671,13 +674,16 @@ export const SETTINGS_SCHEMA = {
 	// Reasoning and prompts
 	defaultThinkingLevel: {
 		type: "enum",
-		values: THINKING_EFFORTS,
+		values: [...THINKING_EFFORTS, AUTO_THINKING],
 		default: "high",
 		ui: {
 			tab: "model",
 			label: "Thinking Level",
 			description: "Reasoning depth for thinking-capable models",
-			options: [...THINKING_EFFORTS.map(getThinkingLevelMetadata)],
+			options: [
+				getConfiguredThinkingLevelMetadata(AUTO_THINKING),
+				...THINKING_EFFORTS.map(getThinkingLevelMetadata),
+			],
 		},
 	},
 
@@ -2954,7 +2960,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "providers",
 			label: "Tiny Model Device",
 			description:
-				"ONNX execution provider for local tiny models (titles + memory). Default picks DirectML on Windows, CUDA on Linux x64, CPU elsewhere. The PI_TINY_DEVICE env var overrides this.",
+				"ONNX execution provider for local tiny models (titles + memory). Default uses CPU-only inference. The PI_TINY_DEVICE env var overrides this.",
 			options: TINY_MODEL_DEVICE_SETTING_OPTIONS,
 		},
 	},
@@ -2984,6 +2990,20 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"providers.autoThinkingModel": {
+		type: "enum",
+		values: AUTO_THINKING_MODEL_VALUES,
+		default: ONLINE_AUTO_THINKING_MODEL_KEY,
+		ui: {
+			tab: "model",
+			label: "Auto Thinking Model",
+			description:
+				"Difficulty classifier for the `auto` thinking level: online smol by default, or a local on-device model",
+			condition: "autoThinkingActive",
+			options: AUTO_THINKING_MODEL_OPTIONS,
+		},
+	},
+
 	"providers.kimiApiFormat": {
 		type: "enum",
 		values: ["openai", "anthropic"] as const,

package/src/edit/hashline/diff.ts

@@ -31,6 +31,12 @@ export interface HashlineDiffOptions {
 	 * preview path only.
 	 */
 	streaming?: boolean;
+	/**
+	 * Skip snapshot-tag validation. Streaming previews use this so transient
+	 * stale/missing tags do not flash re-read errors while the model is still
+	 * authoring input; the final apply path still validates through Patcher.
+	 */
+	skipHashValidation?: boolean;
 }
 
 async function readSectionText(absolutePath: string, sectionPath: string): Promise<string> {
@@ -73,8 +79,10 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readSectionText(absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		const hashError = validateSectionHash(section, absolutePath, normalized, snapshots);
-		if (hashError) return { error: hashError };
+		if (!options.skipHashValidation) {
+			const hashError = validateSectionHash(section, absolutePath, normalized, snapshots);
+			if (hashError) return { error: hashError };
+		}
 		const result = options.streaming
 			? section.applyPartialTo(normalized, nativeBlockResolver)
 			: section.applyTo(normalized, nativeBlockResolver);

package/src/edit/streaming.ts

@@ -314,8 +314,14 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	},
 	async computeDiffPreview(args, ctx) {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
-		const input = trimTrailingPartialLine(args.input, ctx.isStreaming);
-		if (input.length === 0) return null;
+		// Unlike apply_patch, hashline previews flow through `applyPartialTo`,
+		// whose streaming-tolerant parser (`parsePatchStreaming` → `endStreaming`)
+		// drops a payload-less trailing op and projects a partially-typed payload
+		// line onto the file as it grows. Trimming the trailing partial line here
+		// would instead strip the sole payload of a single-op `replace`/`insert`
+		// for almost the entire stream, collapsing the preview to "No changes" and
+		// rendering a blank box. Feed the raw in-flight text straight through.
+		const input = args.input;
 		ctx.signal.throwIfAborted();
 
 		let sections: readonly HashlineInputSection[];
@@ -347,12 +353,17 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 			const section = sectionsToProcess[i];
 			const result = await computeHashlineSectionDiff(section, ctx.cwd, ctx.snapshots, {
 				streaming: ctx.isStreaming,
+				skipHashValidation: ctx.isStreaming === true,
 			});
 			ctx.signal.throwIfAborted();
-			// In a multi-section preview, ignore parse/apply errors from the
-			// last section: it's still streaming and the partial op may not
-			// parse yet. Earlier sections are stable and stay rendered.
-			if (sectionsToProcess.length > 1 && i === trailingProcessedIndex && "error" in result) {
+			// Ignore parse/apply errors from the trailing (actively-typed)
+			// section while streaming: a mid-typed op may transiently resolve to
+			// "No changes" or an out-of-bounds anchor, and surfacing that would
+			// wipe the already-stable previews (or, for a lone section, the prior
+			// good frame). Returning no entry preserves the last preview. Earlier
+			// sections, and every section once args are complete, stay rendered so
+			// real errors still reach the model.
+			if ((ctx.isStreaming || sectionsToProcess.length > 1) && i === trailingProcessedIndex && "error" in result) {
 				continue;
 			}
 			previews.push(toPerFilePreview(section.path, result));

package/src/eval/__tests__/shared-executors.test.ts

@@ -492,6 +492,38 @@ display({"label": "A"})`,
 		expect(reloaded.output.trim()).toBe("2");
 	});
 
+	it("links a cyclic local module graph without crashing", async () => {
+		// Regression: the loader used to link()+evaluate() each local module individually
+		// inside the recursive linker callback. On any import cycle that re-entered Bun's
+		// node:vm linker mid-instantiation and segfaulted the process (SIGTRAP,
+		// getImportedModule on a null record) — e.g. `await import("…/edit/streaming.ts")`,
+		// whose relative-import subtree is cyclic. The graph must now link in a single pass.
+		using tempDir = TempDir.createSync("@omp-eval-js-cycle-");
+		const sessionFile = path.join(tempDir.path(), "session.jsonl");
+		const sessionId = `js-cycle:${crypto.randomUUID()}`;
+		const session = createToolSession(tempDir.path(), sessionFile);
+		const alphaPath = path.join(tempDir.path(), "alpha.ts");
+		const betaPath = path.join(tempDir.path(), "beta.ts");
+		const alphaSpec = JSON.stringify(alphaPath);
+		const betaSpec = JSON.stringify(betaPath);
+		await Bun.write(
+			alphaPath,
+			'import { betaName } from "./beta.ts";\nexport const alphaName = "alpha";\nexport function combined() { return alphaName + ":" + betaName; }\n',
+		);
+		await Bun.write(
+			betaPath,
+			'import { alphaName } from "./alpha.ts";\nexport const betaName = "beta";\nexport function viaAlpha() { return alphaName; }\n',
+		);
+
+		const result = await executeJs(
+			`const a = await import(${alphaSpec});\nconst b = await import(${betaSpec});\nreturn [a.combined(), b.viaAlpha()].join("|");`,
+			{ sessionId, session, sessionFile },
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(result.output.trim()).toBe("alpha:beta|alpha");
+	});
+
 	it("loads TypeScript type-only imports in cells and local modules", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-js-type-imports-");
 		const sessionFile = path.join(tempDir.path(), "session.jsonl");

package/src/eval/js/shared/local-module-loader.ts

@@ -9,6 +9,8 @@ interface LocalModuleEntry {
 	version: number;
 	identifier: string;
 	module: vm.SourceTextModule;
+	/** Memoized link+evaluate of this module as a graph root; set lazily by `#loadLocalModule`. */
+	loaded?: Promise<void>;
 }
 
 export type LocalImportResolution = { mode: "local"; value: unknown } | { mode: "external"; target: string };
@@ -26,6 +28,7 @@ export class LocalModuleLoader {
 	#moduleBuilds = new Map<string, Promise<LocalModuleEntry>>();
 	#externalModules = new Map<string, Promise<vm.Module>>();
 	#requireCache = new Map<string, NodeJS.Require>();
+	#modulePaths = new WeakMap<vm.Module, string>();
 
 	constructor(sessionId: string) {
 		this.#context = vm.createContext(globalThis);
@@ -68,8 +71,8 @@ export class LocalModuleLoader {
 	async #resolveFromBase(baseDir: string, source: string): Promise<LocalImportResolution> {
 		const resolved = resolveImportSpecifier(baseDir, source);
 		if (isLocalPathSpecifier(source) && isManagedLocalModulePath(resolved)) {
-			const entry = await this.#ensureLocalModule(resolved);
-			return { mode: "local", value: entry.module.namespace };
+			const module = await this.#loadLocalModule(resolved);
+			return { mode: "local", value: module.namespace };
 		}
 		return { mode: "external", target: normalizeImportTarget(resolved) };
 	}
@@ -86,6 +89,11 @@ export class LocalModuleLoader {
 		return await buildPromise;
 	}
 
+	// Construct (parse + register) a local module WITHOUT linking or evaluating it.
+	// Linking and evaluation are driven once from the graph root in `#linkAndEvaluate`;
+	// doing them per-module inside the recursive linker re-enters Bun's node:vm linker
+	// mid-instantiation, which segfaults JSC (getImportedModule on a null record) whenever
+	// the local graph contains an import cycle.
 	async #buildLocalModule(modulePath: string): Promise<LocalModuleEntry> {
 		const rawSource = fs.readFileSync(modulePath, "utf8");
 		const stripped = stripTypeScriptSyntax(rawSource, {
@@ -116,28 +124,85 @@ export class LocalModuleLoader {
 				(meta as { url?: string; path?: string; dir?: string }).dir = moduleDir;
 			},
 			importModuleDynamically: async specifier => {
-				return await this.#resolveLinkedModule(modulePath, String(specifier));
+				return await this.#resolveDynamicImport(modulePath, String(specifier));
 			},
 		});
+		this.#modulePaths.set(module, modulePath);
 		const entry: LocalModuleEntry = { version, identifier, module };
 		this.#moduleEntries.set(modulePath, entry);
+		return entry;
+	}
+
+	// Construct (if needed) then link+evaluate a local module as a graph root, returning
+	// the evaluated module. Link and evaluate run exactly once over the whole reachable
+	// graph; the static linker only constructs dependencies, letting node:vm instantiate
+	// cyclic graphs in a single pass.
+	async #loadLocalModule(modulePath: string): Promise<vm.SourceTextModule> {
+		const entry = await this.#ensureLocalModule(modulePath);
+		entry.loaded ??= this.#linkAndEvaluate(entry, modulePath);
+		await entry.loaded;
+		return entry.module;
+	}
+
+	async #linkAndEvaluate(entry: LocalModuleEntry, modulePath: string): Promise<void> {
+		const { module } = entry;
 		try {
-			await module.link(async specifier => await this.#resolveLinkedModule(modulePath, specifier));
-			await module.evaluate();
-			return entry;
+			if (module.status === "unlinked") await module.link(this.#linkResolve);
+			if (module.status === "linked") await module.evaluate();
 		} catch (error) {
-			this.#moduleEntries.delete(modulePath);
+			this.#invalidateFailedLoad(modulePath);
 			throw error;
 		}
+		if (module.status === "errored") {
+			this.#invalidateFailedLoad(modulePath);
+			throw module.error;
+		}
 	}
 
-	async #resolveLinkedModule(referrerPath: string, specifier: string): Promise<vm.Module> {
-		const baseDir = path.dirname(referrerPath);
-		const resolved = resolveImportSpecifier(baseDir, specifier);
+	// Shared static-link resolver for `module.link()`. node:vm passes the referencing
+	// module and reuses this one resolver for the entire graph, so the referrer path is
+	// recovered from `#modulePaths`. Local dependencies are constructed but NOT linked or
+	// evaluated here (the root drives that); externals are loaded eagerly — they carry no
+	// imports and cannot participate in a cycle.
+	#linkResolve = async (specifier: string, referencingModule: vm.Module): Promise<vm.Module> => {
+		const referrerPath = this.#modulePaths.get(referencingModule);
+		if (referrerPath === undefined) {
+			throw new Error(`local module loader: unknown referrer while linking "${specifier}"`);
+		}
+		const resolved = resolveImportSpecifier(path.dirname(referrerPath), specifier);
 		if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
 			return (await this.#ensureLocalModule(resolved)).module;
 		}
 		return await this.#ensureExternalModule(normalizeImportTarget(resolved));
+	};
+
+	// Resolver for runtime `import()` inside evaluated module code: the result must be a
+	// fully linked+evaluated module, so local targets are loaded as graph roots.
+	async #resolveDynamicImport(referrerPath: string, specifier: string): Promise<vm.Module> {
+		const resolved = resolveImportSpecifier(path.dirname(referrerPath), specifier);
+		if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
+			return await this.#loadLocalModule(resolved);
+		}
+		return await this.#ensureExternalModule(normalizeImportTarget(resolved));
+	}
+
+	// A failed link/evaluate can leave a partial graph cached. Drop every reachable module
+	// that is not fully evaluated so the next attempt reconstructs it; fully evaluated
+	// modules keep valid namespaces and stay cached.
+	#invalidateFailedLoad(rootPath: string): void {
+		const stack = [rootPath];
+		const seen = new Set<string>();
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (current === undefined || seen.has(current)) continue;
+			seen.add(current);
+			const entry = this.#moduleEntries.get(current);
+			if (entry && entry.module.status === "evaluated") continue;
+			this.#moduleEntries.delete(current);
+			this.#moduleBuilds.delete(current);
+			const deps = this.#moduleDeps.get(current);
+			if (deps) for (const dep of deps) stack.push(dep);
+		}
 	}
 
 	async #ensureExternalModule(target: string): Promise<vm.Module> {