@oh-my-pi/pi-coding-agent 16.1.13 → 16.1.14

package/src/tiny/title-client.ts

@@ -1,7 +1,18 @@
-import * as path from "node:path";
-import { $env, isBunTestRuntime, isCompiledBinary, logger, workerHostEntry } from "@oh-my-pi/pi-utils";
-import type { Subprocess } from "bun";
+import { $env, logger } from "@oh-my-pi/pi-utils";
 import { settings } from "../config/settings";
+import {
+	createUnavailableWorker,
+	createWorkerHandle,
+	createWorkerSubprocess,
+	logWorkerMessage,
+	resolveWorkerSpawnCmd,
+	SMOKE_TEST_TIMEOUT_MS,
+	type SpawnedSubprocess,
+	smokeTestWorker,
+	spawnWorkerOrUnavailable,
+	type WorkerHandle,
+	workerEnvFromParent,
+} from "../subprocess/worker-client";
 import { safeSend } from "../utils/ipc";
 import { tinyModelDeviceSettingToEnv } from "./device";
 import { tinyModelDtypeSettingToEnv } from "./dtype";
@@ -15,21 +26,6 @@ import {
 } from "./models";
 import type { TinyTitleProgressEvent, TinyTitleWorkerInbound, TinyTitleWorkerOutbound } from "./title-protocol";
 
-/**
- * Abstraction over the tiny-model subprocess. Modelled as a worker interface
- * so existing callers (titles, memory completions, downloads) compose the
- * same way; the runtime implementation is a Bun child process so
- * `onnxruntime-node`'s NAPI finalizer never runs inside the main agent
- * address space — that destructor segfaults Bun on Windows during shutdown
- * (issue #1606).
- */
-interface WorkerHandle {
-	send(message: TinyTitleWorkerInbound): void;
-	onMessage(handler: (message: TinyTitleWorkerOutbound) => void): () => void;
-	onError(handler: (error: Error) => void): () => void;
-	terminate(): Promise<void>;
-}
-
 type PendingRequest =
 	| { kind: "generate"; modelKey: TinyTitleLocalModelKey; resolve: (title: string | null) => void }
 	| { kind: "complete"; modelKey: TinyMemoryLocalModelKey; resolve: (text: string | null) => void }
@@ -51,13 +47,6 @@ export interface TinyTitleGenerateOptions {
 	systemPrompt?: string;
 }
 
-// Cold-starting the worker subprocess from a compiled binary (decompress + module
-// graph load) is slow on contended CI runners — the macos-15-intel release smoke
-// blew past 5s while arm64/linux/win passed. The probe only needs to prove the
-// worker spawns and ponges at all (a dead worker never ponges regardless), so a
-// generous bound removes the flake without weakening the check.
-const SMOKE_TEST_TIMEOUT_MS = 30_000;
-
 function normalizeTinyTitleGenerateOptions(
 	options: AbortSignal | TinyTitleGenerateOptions | undefined,
 ): TinyTitleGenerateOptions {
@@ -107,201 +96,66 @@ export function tinyWorkerEnvOverlay(
 }
 
 /**
- * Env handed to the tiny-model subprocess. The `PI_TINY_DEVICE` / `PI_TINY_DTYPE`
- * env vars win; otherwise the persisted `providers.tinyModelDevice` /
- * `providers.tinyModelDtype` settings are mapped onto those vars so the
- * subprocess's env-based resolution picks them up. Resolved once at spawn
- * (pipelines are cached for the lifetime of the subprocess).
+ * Env handed to the tiny-model subprocess — and reused verbatim by the STT and
+ * TTS workers, which share the same device/dtype resolution. The
+ * `PI_TINY_DEVICE` / `PI_TINY_DTYPE` env vars win; otherwise the persisted
+ * `providers.tinyModelDevice` / `providers.tinyModelDtype` settings are mapped
+ * onto those vars so the subprocess's env-based resolution picks them up.
+ * Resolved once at spawn (pipelines are cached for the lifetime of the
+ * subprocess).
  */
-function tinyWorkerEnv(): Record<string, string> {
-	const overlay = tinyWorkerEnvOverlay(
-		$env,
-		readTinyModelSetting("providers.tinyModelDevice"),
-		readTinyModelSetting("providers.tinyModelDtype"),
+export function tinyWorkerEnv(): Record<string, string> {
+	return workerEnvFromParent(
+		tinyWorkerEnvOverlay(
+			$env,
+			readTinyModelSetting("providers.tinyModelDevice"),
+			readTinyModelSetting("providers.tinyModelDtype"),
+		),
 	);
-	const base = $env as Record<string, string | undefined>;
-	const merged: Record<string, string> = {};
-	for (const key in base) {
-		const value = base[key];
-		if (typeof value === "string") merged[key] = value;
-	}
-	for (const key in overlay) merged[key] = overlay[key];
-	return merged;
-}
-interface TinyWorkerSpawnCommand {
-	cmd: string[];
-	cwd?: string;
-}
-
-/**
- * Resolve the command used to relaunch the agent CLI into tiny-worker mode.
- * In a compiled binary the entry point is the binary itself (no script arg).
- * Otherwise re-enter the declared worker-host entry (source cli.ts or
- * npm-bundle cli.js) with a cwd-relative script path — Bun's subprocess IPC
- * is more reliable that way than with an absolute `.ts` entry under
- * `bun test` — and fall back to this package's own `src/cli.ts` when no host
- * entry is declared (bun test, SDK embedding).
- */
-function tinyWorkerSpawnCmd(): TinyWorkerSpawnCommand {
-	if (isCompiledBinary()) return { cmd: [process.execPath, TINY_WORKER_ARG] };
-	const hostEntry = workerHostEntry();
-	if (hostEntry) {
-		return { cmd: [process.execPath, path.basename(hostEntry), TINY_WORKER_ARG], cwd: path.dirname(hostEntry) };
-	}
-	const packageRoot = path.resolve(import.meta.dir, "..", "..");
-	return { cmd: [process.execPath, "src/cli.ts", TINY_WORKER_ARG], cwd: packageRoot };
-}
-
-interface SpawnedSubprocess {
-	proc: Subprocess<"ignore", "ignore", "ignore">;
-	inbound: Set<(message: TinyTitleWorkerOutbound) => void>;
-	errors: Set<(error: Error) => void>;
-	/**
-	 * Flipped to `true` by {@link wrapSubprocess}'s `terminate()` right
-	 * before it SIGKILLs the child so `onExit` can distinguish the
-	 * expected hard-kill from a crash/OOM/external signal. Only the
-	 * latter is surfaced as a worker error.
-	 */
-	intentionalExit: { value: boolean };
 }
 
 /**
  * Spawn the tiny-model worker as a subprocess. Exported for tests and the
- * smoke probe; production callers go through {@link spawnTinyTitleWorker}
- * which wraps the result in a {@link WorkerHandle}.
+ * smoke probe; production callers go through {@link spawnTinyTitleWorker}.
  */
-export function createTinyTitleSubprocess(): SpawnedSubprocess {
-	const inbound = new Set<(message: TinyTitleWorkerOutbound) => void>();
-	const errors = new Set<(error: Error) => void>();
-	const intentionalExit = { value: false };
-	const spawnCommand = tinyWorkerSpawnCmd();
-	const proc = Bun.spawn({
-		cmd: spawnCommand.cmd,
-		cwd: spawnCommand.cwd,
+export function createTinyTitleSubprocess(): SpawnedSubprocess<TinyTitleWorkerOutbound> {
+	return createWorkerSubprocess<TinyTitleWorkerOutbound>({
+		spawnCommand: resolveWorkerSpawnCmd(TINY_WORKER_ARG),
 		env: tinyWorkerEnv(),
-		stdin: "ignore",
-		stdout: "ignore",
-		stderr: "ignore",
-		serialization: "advanced",
-		windowsHide: true,
-		// The worker is an implementation detail of the interactive TUI. Native
-		// model runtimes may print progress or decoded text directly; never let
-		// those bytes inherit the terminal and corrupt the chat scrollback.
-		ipc(message) {
-			for (const handler of inbound) handler(message as TinyTitleWorkerOutbound);
-		},
-		onExit(_proc, exitCode, signalCode) {
-			// Clean exit. The child only exits via SIGKILL in practice, but
-			// treat code 0 as a no-op for symmetry.
-			if (exitCode === 0) return;
-			// `exitCode === null` + non-null `signalCode` covers both the
-			// expected SIGKILL from `terminate()` AND external kills
-			// (SIGSEGV from a native crash, SIGKILL from the OOM killer, an
-			// operator `kill -9`, etc.). Swallow only the expected one;
-			// every other signal exit is a real worker death that must
-			// fault every in-flight request so callers don't await forever.
-			if (exitCode === null && intentionalExit.value) return;
-			const reason = exitCode !== null ? `code ${exitCode}` : `signal ${signalCode ?? "unknown"}`;
-			const err = new Error(`tiny model subprocess exited with ${reason}`);
-			for (const handler of errors) handler(err);
-		},
+		exitLabel: "tiny model subprocess",
 	});
-	// Don't keep the parent event loop alive on account of an idle worker; the
-	// agent dispose path calls `terminate()` explicitly when shutting down.
-	// Bun's test runner can starve IPC delivery for unref'd subprocesses, so
-	// keep it referenced only under tests that assert the ping/pong contract.
-	if (!isBunTestRuntime()) proc.unref();
-	return { proc, inbound, errors, intentionalExit };
 }
 
-function wrapSubprocess({ proc, inbound, errors, intentionalExit }: SpawnedSubprocess): WorkerHandle {
-	return {
-		send(message) {
-			safeSend(proc, message, "tiny-title");
-		},
-		onMessage(handler) {
-			inbound.add(handler);
-			return () => inbound.delete(handler);
-		},
-		onError(handler) {
-			errors.add(handler);
-			return () => errors.delete(handler);
-		},
-		async terminate() {
-			// SIGKILL: the whole point of the subprocess isolation is that the
-			// parent never runs `onnxruntime-node`'s NAPI finalizer. A polite
-			// SIGTERM lets the subprocess try to clean up, which is exactly the
-			// codepath that crashes Bun on Windows. Hard-kill instead — the
-			// model lives in process memory and the OS reclaims everything.
-			// Flip the intentional-exit flag *before* killing so `onExit` can
-			// tell this apart from a crash or external SIGKILL.
-			intentionalExit.value = true;
-			try {
-				proc.kill("SIGKILL");
-			} catch {
-				// Already gone.
-			}
-		},
-	};
-}
-
-function spawnInlineUnavailableWorker(error: unknown): WorkerHandle {
-	const listeners = new Set<(message: TinyTitleWorkerOutbound) => void>();
-	const errorMessage = error instanceof Error ? error.message : String(error);
-	const emit = (message: TinyTitleWorkerOutbound): void => {
-		for (const listener of listeners) listener(message);
-	};
-	return {
-		send(message) {
-			queueMicrotask(() => {
-				if (message.type === "ping") {
-					emit({ type: "pong", id: message.id });
-					return;
-				}
-				emit({ type: "error", id: message.id, error: errorMessage });
-			});
-		},
-		onMessage(handler) {
-			listeners.add(handler);
-			return () => listeners.delete(handler);
-		},
-		onError() {
-			return () => {};
-		},
-		async terminate() {
-			listeners.clear();
-		},
-	};
-}
-
-function spawnTinyTitleWorker(): WorkerHandle {
-	try {
-		return wrapSubprocess(createTinyTitleSubprocess());
-	} catch (error) {
-		logger.warn("Tiny title worker spawn failed; local titles disabled", {
-			error: error instanceof Error ? error.message : String(error),
-		});
-		return spawnInlineUnavailableWorker(error);
-	}
+function wrapSubprocess(
+	spawned: SpawnedSubprocess<TinyTitleWorkerOutbound>,
+): WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound> {
+	const { proc } = spawned;
+	return createWorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>(spawned, message =>
+		safeSend(proc, message, "tiny-title"),
+	);
 }
 
-function logWorkerMessage(message: Extract<TinyTitleWorkerOutbound, { type: "log" }>): void {
-	if (message.level === "debug") logger.debug(message.msg, message.meta);
-	else if (message.level === "warn") logger.warn(message.msg, message.meta);
-	else logger.error(message.msg, message.meta);
+function spawnTinyTitleWorker(): WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound> {
+	return spawnWorkerOrUnavailable(
+		() => wrapSubprocess(createTinyTitleSubprocess()),
+		createUnavailableWorker<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>,
+		"Tiny title worker spawn failed; local titles disabled",
+	);
 }
 
 export class TinyTitleClient {
-	#worker: WorkerHandle | null = null;
+	#worker: WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound> | null = null;
 	#unsubscribeMessage: (() => void) | null = null;
 	#unsubscribeError: (() => void) | null = null;
 	#pending = new Map<string, PendingRequest>();
 	#failedModels = new Set<TinyLocalModelKey>();
 	#progressListeners = new Set<(event: TinyTitleProgressEvent) => void>();
 	#nextRequestId = 0;
-	#spawnWorker: () => WorkerHandle;
+	#spawnWorker: () => WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>;
 
-	constructor(spawnWorker: () => WorkerHandle = spawnTinyTitleWorker) {
+	constructor(
+		spawnWorker: () => WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound> = spawnTinyTitleWorker,
+	) {
 		this.#spawnWorker = spawnWorker;
 	}
 
@@ -443,7 +297,7 @@ export class TinyTitleClient {
 		}
 	}
 
-	#ensureWorker(): WorkerHandle {
+	#ensureWorker(): WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound> {
 		if (this.#worker) return this.#worker;
 		const worker = this.#spawnWorker();
 		this.#worker = worker;
@@ -520,25 +374,5 @@ export async function smokeTestTinyTitleWorker({
 }: {
 	timeoutMs?: number;
 } = {}): Promise<void> {
-	const handle = wrapSubprocess(createTinyTitleSubprocess());
-	const { promise, resolve, reject } = Promise.withResolvers<void>();
-	const timer = setTimeout(() => reject(new Error(`tiny title worker did not pong within ${timeoutMs}ms`)), timeoutMs);
-	const unsubscribeMessage = handle.onMessage(message => {
-		if (message.type === "pong") {
-			resolve();
-			return;
-		}
-		if (message.type === "log") return;
-		reject(new Error(`tiny title worker: expected pong, got ${JSON.stringify(message)}`));
-	});
-	const unsubscribeError = handle.onError(reject);
-	try {
-		handle.send({ type: "ping", id: "smoke" } satisfies TinyTitleWorkerInbound);
-		await promise;
-	} finally {
-		clearTimeout(timer);
-		unsubscribeMessage();
-		unsubscribeError();
-		await handle.terminate();
-	}
+	await smokeTestWorker(wrapSubprocess(createTinyTitleSubprocess()), "tiny title worker", timeoutMs);
 }

package/src/tiny/worker.ts

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 import * as path from "node:path";
 import type {
 	ProgressInfo,
@@ -6,16 +5,18 @@ import type {
 	TextGenerationStringOutput,
 	StoppingCriteria as TransformersStoppingCriteria,
 } from "@huggingface/transformers";
-import {
-	ensureRuntimeInstalled,
-	getTinyModelsCacheDir,
-	installRuntimeModuleResolver,
-	isCompiledBinary,
-	prompt,
-	resolveRuntimeModule,
-} from "@oh-my-pi/pi-utils";
-import packageJson from "../../package.json" with { type: "json" };
+import { getTinyModelsCacheDir, prompt } from "@oh-my-pi/pi-utils";
 import tinyTitleSystemPrompt from "../prompts/system/tiny-title-system.md" with { type: "text" };
+import {
+	errorMessage,
+	errorText,
+	getTransformersVersionSpec,
+	loadTransformersRuntime,
+	MemoizedRuntime,
+	replayCachedReady,
+	sendLog,
+	sendProgress,
+} from "../subprocess/worker-runtime";
 import { resolveTinyModelDevicePreference, type TinyModelDevice, tinyModelDeviceLoadOrder } from "./device";
 import { resolveTinyModelDtypeOverride, type TinyModelDtype } from "./dtype";
 import {
@@ -25,7 +26,7 @@ import {
 	type TinyTitleLocalModelSpec,
 } from "./models";
 import { formatTitleUserMessage, normalizeGeneratedTitle } from "./text";
-import type { TinyTitleProgressEvent, TinyTitleTransport, TinyTitleWorkerInbound } from "./title-protocol";
+import type { TinyTitleTransport, TinyTitleWorkerInbound } from "./title-protocol";
 
 const TITLE_PREFILL = "<title>";
 const TITLE_CLOSE = "</title>";
@@ -34,9 +35,6 @@ const STOP_DECODE_WINDOW_TOKENS = 32;
 const MEMORY_COMPLETION_DEFAULT_MAX_NEW_TOKENS = 256;
 const COMPLETION_MAX_NEW_TOKENS = 1024;
 const TINY_TITLE_SYSTEM_PROMPT = prompt.render(tinyTitleSystemPrompt);
-const TRANSFORMERS_PACKAGE = "@huggingface/transformers";
-const COMPILED_TRANSFORMERS_VERSION = process.env.PI_TINY_TRANSFORMERS_VERSION;
-const sourceRequire = createRequire(import.meta.url);
 
 const tinyModelDevicePreference = resolveTinyModelDevicePreference();
 const tinyModelDtypeOverride = resolveTinyModelDtypeOverride();
@@ -64,51 +62,11 @@ interface TransformersRuntime {
 
 const pipelines = new Map<TinyLocalModelKey, Promise<TextGenerationPipeline>>();
 
-function resolveTransformersVersionSpec(): string {
-	const manifest = packageJson as {
-		optionalDependencies?: Record<string, string>;
-		dependencies?: Record<string, string>;
-	};
-	const versionSpec =
-		manifest.optionalDependencies?.[TRANSFORMERS_PACKAGE] ?? manifest.dependencies?.[TRANSFORMERS_PACKAGE];
-	if (!versionSpec) throw new Error(`${TRANSFORMERS_PACKAGE} is missing from package.json optionalDependencies`);
-	if (!versionSpec.startsWith("catalog:")) return versionSpec;
-	if (COMPILED_TRANSFORMERS_VERSION) return COMPILED_TRANSFORMERS_VERSION;
-	const installed = sourceRequire(`${TRANSFORMERS_PACKAGE}/package.json`) as { version: string };
-	return installed.version;
-}
-let cachedTransformersVersionSpec: string | undefined;
-/**
- * Lazily resolve (and memoize) the transformers version spec. In the
- * `catalog:` case {@link resolveTransformersVersionSpec} `require`s the
- * installed `@huggingface/transformers/package.json`, so touching it forces
- * the dependency to exist. Defer it to the compiled-binary runtime-install
- * path — which only runs when a local title model is actually generated or
- * downloaded — so loading this worker (smoke-test ping, online title path)
- * never triggers the transformers resolve/install dance.
- */
-function getTransformersVersionSpec(): string {
-	cachedTransformersVersionSpec ??= resolveTransformersVersionSpec();
-	return cachedTransformersVersionSpec;
-}
 function getTransformersRuntimeKey(): string {
 	return getTransformersVersionSpec().replace(/[^A-Za-z0-9._-]/g, "_");
 }
 let generateQueue = Promise.resolve();
-let transformersRuntime: Promise<TransformersRuntime> | null = null;
-
-function errorText(error: unknown): string {
-	return error instanceof Error ? (error.stack ?? error.message) : String(error);
-}
-
-function sendLog(
-	transport: TinyTitleTransport,
-	level: "debug" | "warn" | "error",
-	msg: string,
-	meta?: Record<string, unknown>,
-): void {
-	transport.send({ type: "log", level, msg, meta });
-}
+const transformersRuntime = new MemoizedRuntime<TransformersRuntime>();
 
 function getTinyTitleRuntimeDir(): string {
 	return path.join(
@@ -118,74 +76,6 @@ function getTinyTitleRuntimeDir(): string {
 	);
 }
 
-function sendRuntimeInstallProgress(
-	transport: TinyTitleTransport,
-	requestId: string,
-	modelKey: TinyLocalModelKey,
-	status: "initiate" | "download" | "done",
-): void {
-	transport.send({
-		type: "progress",
-		id: requestId,
-		event: {
-			modelKey,
-			status,
-			name: `${TRANSFORMERS_PACKAGE}@${getTransformersVersionSpec()}`,
-		},
-	});
-}
-
-/**
- * Prepare the freshly-installed compiled runtime for loading: stub `sharp`
- * (the tiny models are text-generation only, so the native image pipeline is
- * dead weight) and patch the module resolver so Transformers.js's bare requires
- * (`onnxruntime-node`, `onnxruntime-common`) resolve against the cache. Returns
- * the absolute Transformers.js entrypoint to `require`.
- */
-async function prepareCompiledRuntime(runtimeDir: string): Promise<string> {
-	const nodeModules = path.join(runtimeDir, "node_modules");
-	const sharpStub = path.join(runtimeDir, "omp-sharp-stub.cjs");
-	await Bun.write(sharpStub, "module.exports = {};\n");
-	installRuntimeModuleResolver({ runtimeNodeModules: nodeModules, stubs: { sharp: sharpStub } });
-	const entry = resolveRuntimeModule(nodeModules, TRANSFORMERS_PACKAGE);
-	if (!entry) throw new Error(`Unable to resolve ${TRANSFORMERS_PACKAGE} in compiled runtime at ${nodeModules}`);
-	return entry;
-}
-
-function configureTransformers(transformers: TransformersRuntime): TransformersRuntime {
-	transformers.env.cacheDir = getTinyModelsCacheDir();
-	transformers.env.allowLocalModels = false;
-	transformers.env.logLevel = transformers.LogLevel.ERROR;
-	return transformers;
-}
-
-async function loadTransformers(
-	transport: TinyTitleTransport,
-	requestId: string,
-	modelKey: TinyLocalModelKey,
-): Promise<TransformersRuntime> {
-	if (transformersRuntime) return transformersRuntime;
-	transformersRuntime = (async () => {
-		if (!isCompiledBinary()) return configureTransformers(sourceRequire(TRANSFORMERS_PACKAGE) as TransformersRuntime);
-		const runtimeDir = await ensureRuntimeInstalled({
-			runtimeDir: getTinyTitleRuntimeDir(),
-			install: {
-				dependencies: { [TRANSFORMERS_PACKAGE]: getTransformersVersionSpec() },
-				trustedDependencies: ["onnxruntime-node"],
-			},
-			probePackage: TRANSFORMERS_PACKAGE,
-			onPhase: phase => sendRuntimeInstallProgress(transport, requestId, modelKey, phase),
-		});
-		const entry = await prepareCompiledRuntime(runtimeDir);
-		const require_ = createRequire(entry);
-		return configureTransformers(require_(entry) as TransformersRuntime);
-	})().catch(error => {
-		transformersRuntime = null;
-		throw error;
-	});
-	return transformersRuntime;
-}
-
 function createStopOnTextCriteria(
 	transformers: TransformersRuntime,
 	tokenizer: TextGenerationPipeline["tokenizer"],
@@ -215,48 +105,6 @@ function createStopOnTextCriteria(
 	return new StopOnTextCriteria();
 }
 
-function toProgressEvent(modelKey: TinyLocalModelKey, info: ProgressInfo): TinyTitleProgressEvent {
-	if (info.status === "ready") {
-		return { modelKey, status: info.status, task: info.task, model: info.model };
-	}
-	if (info.status === "progress_total") {
-		return {
-			modelKey,
-			status: info.status,
-			name: info.name,
-			progress: info.progress,
-			loaded: info.loaded,
-			total: info.total,
-			files: info.files,
-		};
-	}
-	if (info.status === "progress") {
-		return {
-			modelKey,
-			status: info.status,
-			name: info.name,
-			file: info.file,
-			progress: info.progress,
-			loaded: info.loaded,
-			total: info.total,
-		};
-	}
-	return { modelKey, status: info.status, name: info.name, file: info.file };
-}
-
-function sendProgress(
-	transport: TinyTitleTransport,
-	id: string,
-	modelKey: TinyLocalModelKey,
-	info: ProgressInfo,
-): void {
-	transport.send({ type: "progress", id, event: toProgressEvent(modelKey, info) });
-}
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
 async function loadPipelineOnDevice(
 	transformers: TransformersRuntime,
 	spec: TinyTitleLocalModelSpec,
@@ -318,21 +166,16 @@ async function loadPipeline(
 	const spec = getTinyLocalModelSpec(modelKey);
 	if (!spec) throw new Error(`Unknown tiny local model: ${modelKey}`);
 	if (spec.unsupportedReason) throw new Error(`${modelKey} is unavailable: ${spec.unsupportedReason}`);
-	const cached = pipelines.get(modelKey);
-	if (cached) {
-		void cached
-			.then(() => {
-				transport.send({
-					type: "progress",
-					id: requestId,
-					event: { modelKey, status: "ready", task: "text-generation", model: spec.repo },
-				});
-			})
-			.catch(() => undefined);
-		return cached;
-	}
+	const cached = replayCachedReady(pipelines, modelKey, transport, requestId, "text-generation", spec.repo);
+	if (cached) return cached;
 
-	const transformers = await loadTransformers(transport, requestId, modelKey);
+	const transformers = await loadTransformersRuntime(
+		transformersRuntime,
+		transport,
+		requestId,
+		modelKey,
+		getTinyTitleRuntimeDir,
+	);
 	const startedAt = performance.now();
 	const loaded = loadPipelineWithDeviceFallback(transformers, spec, modelKey, transport, requestId).then(
 		({ generator, device }) => {
@@ -393,7 +236,13 @@ async function generateTitle(
 ): Promise<string | null> {
 	const generator = await loadPipeline(modelKey, transport, requestId);
 	const promptText = buildPrompt(generator, message, systemPrompt);
-	const transformers = await loadTransformers(transport, requestId, modelKey);
+	const transformers = await loadTransformersRuntime(
+		transformersRuntime,
+		transport,
+		requestId,
+		modelKey,
+		getTinyTitleRuntimeDir,
+	);
 	const output = (await generator(promptText, {
 		max_new_tokens: TITLE_MAX_NEW_TOKENS,
 		do_sample: false,

package/src/tools/eval-backends.ts

@@ -4,24 +4,31 @@ import type { ToolSession } from ".";
 export interface EvalBackendsAllowance {
 	python: boolean;
 	js: boolean;
+	ruby: boolean;
+	julia: boolean;
 }
 
-/** Read per-backend allowance from settings (defaults true). */
+/** Read per-backend allowance from settings (py/js default on; rb/jl opt-in, default off). */
 export function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAllowance {
 	return {
 		python: session.settings.get("eval.py") ?? true,
 		js: session.settings.get("eval.js") ?? true,
+		ruby: session.settings.get("eval.rb") ?? false,
+		julia: session.settings.get("eval.jl") ?? false,
 	};
 }
 
 /**
- * Materialize the active eval backend allowance: PI_PY / PI_JS env flags
- * override the per-key settings; otherwise settings (defaults true) win.
+ * Materialize the active eval backend allowance: PI_PY / PI_JS / PI_RB / PI_JL
+ * env flags override the per-key settings; otherwise settings win (py/js default
+ * on, rb/jl default off).
  */
 export function resolveEvalBackends(session: ToolSession): EvalBackendsAllowance {
 	const settings = readEvalBackendsAllowance(session);
 	return {
 		python: $flag("PI_PY", settings.python),
 		js: $flag("PI_JS", settings.js),
+		ruby: $flag("PI_RB", settings.ruby),
+		julia: $flag("PI_JL", settings.julia),
 	};
 }