@xopcai/xopc 0.0.241 → 0.0.243

package/dist/src/gateway/service/run-gateway-agent.js

@@ -131,7 +131,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 				const eventStream = agentService.turnDispatcher.processDirectStreaming(stampedMessage, sessionKey, origin, prepared, thinking, {
 					signal: mergedSignal,
 					runId,
-					sourceContexts: runOptions?.sourceContexts
+					sourceContexts: runOptions?.sourceContexts,
+					presentation: runOptions?.presentation
 				});
 				const mappedEvents = (async function* () {
 					for await (const event of eventStream) yield* mapper.map(event);
@@ -150,6 +151,18 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 					summary: mergedSignal.aborted ? "Interrupted" : "Message processed successfully"
 				};
 			} catch (error) {
+				if (mergedSignal.aborted) {
+					terminalStatus = "cancelled";
+					taskRunStatus = "cancelled";
+					taskRunSummary = "Interrupted";
+					yield* emitAndYield(mapper.end("cancelled", "Interrupted"));
+					completeRealtimeTopic(`run:${runId}`);
+					runTopicCompleted = true;
+					return {
+						status: "aborted",
+						summary: "Interrupted"
+					};
+				}
 				const em = error instanceof Error ? error.message : String(error);
 				log.error({
 					err: error,
@@ -173,6 +186,11 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 					summary: streamError
 				};
 			} finally {
+				if (mergedSignal.aborted) {
+					terminalStatus = "cancelled";
+					taskRunStatus = "cancelled";
+					taskRunSummary = "Interrupted";
+				}
 				if (registeredActiveWebchatRun && activeWebchatRunBySession.get(sessionKey) === runId) {
 					activeWebchatRunBySession.delete(sessionKey);
 					publishRealtime("sessions", "run.completed", {

package/dist/src/gateway/service.d.ts

@@ -19,6 +19,7 @@ import { GatewaySessionsApi } from './service/sessions-api.js';
 import { GatewayMarketplaceService } from './service/marketplace-service.js';
 import { GatewayAgentRunner } from './service/agent-runner.js';
 import { RealtimeRuntime } from '../realtime/runtime.js';
+import { VoiceRealtimeRuntime } from '../voice/realtime/runtime.js';
 import type { GatewayServiceConfig } from './service/types.js';
 import { type GatewayReadinessSnapshot } from './startup-readiness.js';
 import { type ConnectorLearningCoordinator } from '../connectors/learning-coordinator.js';
@@ -51,6 +52,7 @@ export declare class GatewayService {
     private auth;
     readonly endpointTools: EndpointToolRuntime;
     readonly realtime: RealtimeRuntime;
+    readonly voiceRealtime: VoiceRealtimeRuntime;
     getConfig(): Config;
     getModelCatalogSync(): ModelCatalogSyncService;
     get browserRecipes(): BrowserRecipeService;

package/dist/src/gateway/service.js

@@ -6,6 +6,8 @@ import { getRuntimeLogStats } from "../utils/logger/stats.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { closeXopcDatabase, openXopcDatabase } from "../storage/sqlite/connection.js";
+import { notifyUserContextChange } from "../user-context/changes.js";
+import { getSessionConfig } from "../storage/sqlite/config-repository.js";
 import "../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveDefaultAgentId } from "../agent/agent-scope.js";
@@ -18,6 +20,7 @@ import { loadConfig, saveConfig } from "../config/loader.js";
 import { buildSessionKey, init_session_key, sanitizeSegment } from "../routing/session-key.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { init_providers, providers_exports } from "../providers/index.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { TaskRepository } from "../tasks/task-repository.js";
 import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
 import { disposeAllSessionMcpRuntimes } from "../agent/mcp/bundle-mcp-runtime.js";
@@ -68,6 +71,8 @@ import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validate
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
 import { reconcileDreamingAutomations } from "./dreaming-automation-reconciler.js";
+import { buildVoiceMemoryContext } from "../voice/realtime/memory-context.js";
+import { voiceMemoryBudget } from "../voice/realtime/conversation-context.js";
 import { NotesStore } from "../notes/store.js";
 import { buildNoteAgentContext } from "../notes/agent-context.js";
 import { NotesService } from "../notes/service.js";
@@ -114,6 +119,7 @@ import { GatewayMarketplaceService } from "./service/marketplace-service.js";
 import { GatewayConfigCoordinator } from "./service/config-coordinator.js";
 import { GatewayAgentRunner } from "./service/agent-runner.js";
 import { RealtimeRuntime } from "../realtime/runtime.js";
+import { VoiceRealtimeRuntime } from "../voice/realtime/runtime.js";
 import { GatewayReadiness } from "./startup-readiness.js";
 import { createGatewayStartupTrace } from "./startup-trace.js";
 import { applyAutomaticVoiceLanguage, inferProductLanguageFromEnvironment, initializeVoiceDefaults } from "../voice/language-profile.js";
@@ -158,6 +164,71 @@ var GatewayService = class {
 	auth;
 	endpointTools = new EndpointToolRuntime();
 	realtime = new RealtimeRuntime(this.endpointTools);
+	voiceRealtime = new VoiceRealtimeRuntime({
+		getConversationContext: async (sessionKey, expectedSessionId) => {
+			if ((await this.sessionIndex.getSessionMetadata(sessionKey))?.sessionId !== expectedSessionId) throw new Error("Conversation changed before voice connection");
+			const messages = await this.sessionIndex.loadMessages(sessionKey);
+			const after = await this.sessionIndex.getSessionMetadata(sessionKey);
+			if (after?.sessionId !== expectedSessionId) throw new Error("Conversation changed while loading voice context");
+			const profile = resolveEffectiveAgentProfileForSession(this.config, sessionKey);
+			const context = {
+				identity: [`Your name is ${profile.config.profile?.name ?? profile.agentId}.`, profile.customInstructions ?? ""].join("\n"),
+				history: messages
+			};
+			const memory = buildVoiceMemoryContext({
+				getConfig: () => this.config,
+				sessionKey,
+				workspaceId: getSessionConfig(sessionKey)?.workingDirectoryOverride ?? profile.resolvedWorkspacePath,
+				projectId: after?.projectId,
+				history: messages,
+				maxChars: voiceMemoryBudget(this.config.voice.realtime.omni.instructions, context)
+			});
+			return {
+				...context,
+				...memory ? { memory } : {}
+			};
+		},
+		getSessionIdentity: async (sessionKey) => (await this.sessionIndex.getSessionMetadata(sessionKey))?.sessionId,
+		recordOmniTranscript: async (sessionKey, callId, entry, expectedSessionId) => {
+			await this.sessionIndex.appendTranscriptCustomMessageEntry(sessionKey, {
+				expectedSessionId,
+				customType: "voice_omni_transcript",
+				content: entry.text,
+				display: true,
+				details: {
+					callId,
+					itemId: entry.itemId,
+					role: entry.role,
+					interrupted: entry.interrupted,
+					engine: "omni"
+				}
+			});
+			this.emit("session.transcript_updated", { key: sessionKey });
+		},
+		getConfig: () => this.config,
+		sessionExists: async (sessionKey) => Boolean(await this.sessionIndex.getSessionMetadata(sessionKey)),
+		sessionBusy: (sessionKey) => Boolean(this.agentRunner.getActiveRunId(sessionKey)) || this.agentRunner.inputs.snapshot(sessionKey).inputs.some((input) => input.status === "queued"),
+		recordInterruption: (entry) => this.sessionIndex.appendTranscriptContextEntry(entry.sessionKey, {
+			text: "Voice response was interrupted before playback completed.",
+			data: {
+				type: "voice_response_interrupted",
+				responseId: entry.responseId,
+				reason: entry.reason,
+				generatedCharacters: entry.generatedCharacters,
+				interruptedDuring: entry.interruptedDuring
+			}
+		}),
+		runAgent: (text, sessionKey, signal) => {
+			if (this.agentRunner.hasActiveRun(sessionKey)) throw new Error("Conversation session already has an active response");
+			return this.agentRunner.runAgent(text, "webchat", sessionKey, {
+				type: "channel",
+				channel: "webchat"
+			}, void 0, void 0, {
+				signal,
+				presentation: "voice"
+			});
+		}
+	});
 	getConfig() {
 		return this.config;
 	}
@@ -1097,6 +1168,7 @@ var GatewayService = class {
 		this.endpointTools.close();
 		await this.sideChats.disposeAll();
 		this.realtime.close();
+		this.voiceRealtime.close();
 		await this.proactiveWorker.stop();
 		await this.discussionWorker.stop();
 		await this.discussionSealer.stop();
@@ -1543,6 +1615,7 @@ var GatewayService = class {
 		});
 	}
 	emit(type, payload) {
+		if (type === "config.reload") notifyUserContextChange({ kind: "policy" });
 		this.realtime.broker.publish("gateway", type, payload);
 		this.createNotificationService().handleGatewayEvent(type, payload);
 	}

package/dist/src/media-understanding/types.d.ts

@@ -112,6 +112,65 @@ export interface AudioTranscriptionResult {
     /** Audio duration in seconds, when reported. */
     durationSeconds?: number;
 }
+export interface PcmAudioFormat {
+    encoding: 'pcm_s16le';
+    sampleRate: 16_000 | 24_000;
+    channels: 1;
+}
+export interface StreamingSttCapabilities {
+    inputSampleRates: readonly number[];
+    turnDetection: readonly 'server_vad'[];
+    defaultModel: string;
+    models: readonly string[];
+}
+export type StreamingSttEvent = {
+    type: 'ready';
+} | {
+    type: 'speech_started';
+    utteranceId: string;
+} | {
+    type: 'speech_stopped';
+    utteranceId: string;
+} | {
+    type: 'transcript_delta';
+    utteranceId: string;
+    revision: number;
+    text: string;
+} | {
+    type: 'transcript_final';
+    utteranceId: string;
+    revision: number;
+    text: string;
+    language?: string;
+} | {
+    type: 'usage';
+    inputAudioMs: number;
+} | {
+    type: 'error';
+    error: Error;
+};
+export interface StreamingSttOpenRequest {
+    model: string;
+    inputFormat: PcmAudioFormat;
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    language?: string;
+    prompt?: string;
+    turnDetection: {
+        mode: 'server_vad';
+        silenceDurationMs: number;
+    };
+    timeoutMs: number;
+    signal: AbortSignal;
+    onEvent: (event: StreamingSttEvent) => void;
+}
+export interface StreamingSttSession {
+    appendAudio(chunk: Uint8Array): void;
+    commit(): Promise<void>;
+    close(): Promise<void>;
+    abort(reason: string): void;
+}
 export interface ImageDescriptionRequest {
     buffer: Buffer;
     fileName: string;
@@ -170,6 +229,8 @@ export interface MediaUnderstandingProvider {
     /** True when the provider can natively ingest PDF (no OCR pre-step needed). */
     nativeDocumentInputs?: ReadonlyArray<'pdf'>;
     transcribeAudio?: (req: AudioTranscriptionRequest) => Promise<AudioTranscriptionResult>;
+    streamingAudio?: StreamingSttCapabilities;
+    openAudioStream?: (req: StreamingSttOpenRequest) => Promise<StreamingSttSession>;
     describeImage?: (req: ImageDescriptionRequest) => Promise<ImageDescriptionResult>;
     describeVideo?: (req: VideoDescriptionRequest) => Promise<VideoDescriptionResult>;
 }

package/dist/src/runtime-tools/archive.js

@@ -5,12 +5,15 @@ import { lstat, mkdir, readdir, readlink, rename, rm, stat } from "node:fs/promi
 import AdmZip from "adm-zip";
 //#region src/runtime-tools/archive.ts
 const MAX_ARCHIVE_ENTRIES = 5e4;
+const MAX_TAR_OUTPUT_BYTES = 16 * 1024 * 1024;
+const MAX_EXTRACTED_BYTES = 2 * 1024 * 1024 * 1024;
 function validateMemberPath(memberPath) {
 	const portablePath = memberPath.replaceAll("\\", "/");
 	const normalized = posix.normalize(portablePath);
 	if (!memberPath || isAbsolute(memberPath) || portablePath.startsWith("/") || normalized === ".." || normalized.startsWith("../")) throw new Error(`Unsafe archive member: ${memberPath}`);
 }
 async function validateExtractedTree(root, current = root) {
+	let totalBytes = 0;
 	for (const entry of await readdir(current)) {
 		const entryPath = join(current, entry);
 		const details = await lstat(entryPath);
@@ -19,8 +22,10 @@ async function validateExtractedTree(root, current = root) {
 			if (relativeTarget.split(/[\\/]/)[0] === ".." || isAbsolute(relativeTarget)) throw new Error(`Archive symlink escapes extraction root: ${entryPath}`);
 			continue;
 		}
-		if (details.isDirectory()) await validateExtractedTree(root, entryPath);
+		totalBytes += details.isDirectory() ? await validateExtractedTree(root, entryPath) : details.size;
+		if (totalBytes > MAX_EXTRACTED_BYTES) throw new Error("Extracted archive exceeds size limit");
 	}
+	return totalBytes;
 }
 async function runTar(args) {
 	return await new Promise((resolvePromise, reject) => {
@@ -30,11 +35,19 @@ async function runTar(args) {
 			shell: false,
 			windowsHide: true
 		});
+		const append = (current, chunk) => {
+			if (Buffer.byteLength(current) + chunk.byteLength > MAX_TAR_OUTPUT_BYTES) {
+				child.kill("SIGKILL");
+				reject(/* @__PURE__ */ new Error("tar output exceeds size limit"));
+				return current;
+			}
+			return current + chunk.toString();
+		};
 		child.stdout?.on("data", (chunk) => {
-			stdout += chunk.toString();
+			stdout = append(stdout, chunk);
 		});
 		child.stderr?.on("data", (chunk) => {
-			stderr += chunk.toString();
+			stderr = append(stderr, chunk);
 		});
 		child.once("error", reject);
 		child.once("close", (code) => {
@@ -47,6 +60,7 @@ async function extractZip(archivePath, destination) {
 	const zip = new AdmZip(archivePath);
 	const entries = zip.getEntries();
 	if (entries.length > MAX_ARCHIVE_ENTRIES) throw new Error("Archive contains too many entries");
+	if (entries.reduce((total, entry) => total + entry.header.size, 0) > MAX_EXTRACTED_BYTES) throw new Error("Extracted archive exceeds size limit");
 	for (const entry of entries) validateMemberPath(entry.entryName);
 	zip.extractAllTo(destination, true, false);
 }

package/dist/src/runtime-tools/command.d.ts

@@ -5,6 +5,7 @@ export interface RuntimeCommandResult {
     exitCode: number | null;
     timedOut: boolean;
     aborted: boolean;
+    outputTruncated: boolean;
 }
 export declare function runRuntimeCommand(params: {
     command: string;

package/dist/src/runtime-tools/command.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 //#region src/runtime-tools/command.ts
 const DEFAULT_COMMAND_TIMEOUT_MS = 5e3;
+const MAX_COMMAND_OUTPUT_BYTES = 1024 * 1024;
 async function runRuntimeCommand(params) {
 	return await new Promise((resolve) => {
 		let stdout = "";
@@ -8,7 +9,10 @@ async function runRuntimeCommand(params) {
 		let settled = false;
 		let timedOut = false;
 		let aborted = false;
+		let outputTruncated = false;
+		let timeout;
 		const child = spawn(params.command, params.args, {
+			detached: process.platform !== "win32",
 			env: params.env,
 			shell: false,
 			windowsHide: process.platform === "win32",
@@ -18,36 +22,53 @@ async function runRuntimeCommand(params) {
 				"pipe"
 			]
 		});
+		const killChild = () => {
+			if (process.platform !== "win32" && child.pid) try {
+				process.kill(-child.pid, "SIGKILL");
+				return;
+			} catch {}
+			child.kill("SIGKILL");
+		};
 		const finish = (exitCode) => {
 			if (settled) return;
 			settled = true;
-			clearTimeout(timeout);
+			if (timeout) clearTimeout(timeout);
 			params.signal?.removeEventListener("abort", abort);
 			resolve({
-				ok: exitCode === 0 && !timedOut && !aborted,
+				ok: exitCode === 0 && !timedOut && !aborted && !outputTruncated,
 				stdout: stdout.trim(),
 				stderr: stderr.trim(),
 				exitCode,
 				timedOut,
-				aborted
+				aborted,
+				outputTruncated
 			});
 		};
 		const abort = () => {
 			aborted = true;
-			child.kill("SIGKILL");
+			killChild();
 			finish(null);
 		};
+		const appendOutput = (current, chunk) => {
+			const remaining = MAX_COMMAND_OUTPUT_BYTES - Buffer.byteLength(current);
+			if (remaining <= 0 || chunk.byteLength > remaining) {
+				outputTruncated = true;
+				killChild();
+				return remaining > 0 ? current + chunk.subarray(0, remaining).toString() : current;
+			}
+			return current + chunk.toString();
+		};
 		child.stdout?.on("data", (chunk) => {
-			stdout += chunk.toString();
+			stdout = appendOutput(stdout, chunk);
 		});
 		child.stderr?.on("data", (chunk) => {
-			stderr += chunk.toString();
+			stderr = appendOutput(stderr, chunk);
 		});
 		child.once("error", () => finish(null));
 		child.once("close", finish);
-		const timeout = setTimeout(() => {
+		timeout = setTimeout(() => {
 			timedOut = true;
-			child.kill("SIGKILL");
+			killChild();
 			finish(null);
 		}, params.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS);
 		timeout.unref();

package/dist/src/runtime-tools/environment.d.ts

@@ -6,6 +6,7 @@ export interface RuntimeEnvironmentOptions {
     baseEnv: Record<string, string>;
     runtimes?: RuntimeKind[];
     extraBinDirs?: string[];
+    skillEnvironmentIds?: string[];
 }
 export interface RuntimeEnvironmentResult {
     env: Record<string, string>;

package/dist/src/runtime-tools/environment.js

@@ -1,7 +1,7 @@
-import { applyPathPrepend } from "../infra/path-prepend.js";
+import { applyPathPrepend, findPathKey, normalizePathPrepend } from "../infra/path-prepend.js";
 import { ManagedRuntimeManager } from "./manager.js";
-import { dirname, join } from "node:path";
-import { access, readdir } from "node:fs/promises";
+import { delimiter, dirname, join } from "node:path";
+import { access } from "node:fs/promises";
 //#region src/runtime-tools/environment.ts
 const POLLUTING_ENV_KEYS = [
 	"NODE_OPTIONS",
@@ -19,14 +19,8 @@ const POLLUTING_ENV_KEYS = [
 	"UV_CACHE_DIR",
 	"UV_PYTHON_INSTALL_MIRROR"
 ];
-async function skillEnvironmentBinDirs(stateDir) {
+async function skillEnvironmentBinDirs(stateDir, environmentIds) {
 	const root = join(stateDir, "tools", "environments", "skills");
-	let environmentIds;
-	try {
-		environmentIds = await readdir(root);
-	} catch {
-		return [];
-	}
 	const candidates = environmentIds.flatMap((id) => [join(root, id, "bin"), join(root, id, "node_modules", ".bin")]);
 	return (await Promise.all(candidates.map(async (candidate) => {
 		try {
@@ -37,6 +31,10 @@ async function skillEnvironmentBinDirs(stateDir) {
 		}
 	}))).filter((candidate) => candidate !== null);
 }
+function appendPathEntries(env, entries) {
+	const pathKey = findPathKey(env);
+	env[pathKey] = normalizePathPrepend([...(env[pathKey] ?? "").split(delimiter).filter(Boolean), ...entries]).join(delimiter);
+}
 async function buildRuntimeEnvironment(options) {
 	const env = { ...options.baseEnv };
 	for (const key of POLLUTING_ENV_KEYS) delete env[key];
@@ -60,12 +58,9 @@ async function buildRuntimeEnvironment(options) {
 		}
 	}))).filter((item) => item !== null);
 	const managedBinDirs = resolved.filter((item) => item.source === "managed").map((item) => dirname(item.executable));
-	const skillBinDirs = await skillEnvironmentBinDirs(options.stateDir);
-	applyPathPrepend(env, [
-		...managedBinDirs,
-		...skillBinDirs,
-		...options.extraBinDirs ?? []
-	]);
+	const skillBinDirs = await skillEnvironmentBinDirs(options.stateDir, options.skillEnvironmentIds ?? []);
+	applyPathPrepend(env, [...managedBinDirs, ...options.extraBinDirs ?? []]);
+	appendPathEntries(env, skillBinDirs);
 	if (resolved.some((item) => item.runtime === "python")) {
 		env.PYTHONNOUSERSITE = "1";
 		env.PIP_REQUIRE_VIRTUALENV = "1";

package/dist/src/runtime-tools/install-lock.d.ts

@@ -1 +1 @@
-export declare function withInstallLock<T>(path: string, metadata: Record<string, unknown>, fn: () => Promise<T>): Promise<T>;
+export declare function withInstallLock<T>(path: string, metadata: Record<string, unknown>, fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;

package/dist/src/runtime-tools/install-lock.js

@@ -7,38 +7,51 @@ function isProcessAlive(pid) {
 	try {
 		process.kill(pid, 0);
 		return true;
-	} catch {
-		return false;
+	} catch (error) {
+		return error.code === "EPERM";
 	}
 }
 async function staleLock(path) {
 	try {
 		const value = JSON.parse(await readFile(path, "utf8"));
-		const pid = typeof value.pid === "number" ? value.pid : 0;
-		const createdAt = typeof value.createdAt === "number" ? value.createdAt : 0;
-		return !isProcessAlive(pid) && Date.now() - createdAt > LOCK_STALE_MS;
+		return !isProcessAlive(typeof value.pid === "number" ? value.pid : 0);
 	} catch {
 		return true;
 	}
 }
-async function withInstallLock(path, metadata, fn) {
+async function withInstallLock(path, metadata, fn, signal) {
 	await mkdir(dirname(path), { recursive: true });
-	while (true) try {
-		const handle = await open(path, "wx", 384);
-		await handle.writeFile(JSON.stringify({
-			pid: process.pid,
-			createdAt: Date.now(),
-			...metadata
-		}));
-		await handle.close();
-		break;
-	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-		if (await staleLock(path)) {
-			await unlink(path).catch(() => void 0);
-			continue;
+	const waitStartedAt = Date.now();
+	while (true) {
+		if (signal?.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("Runtime installation was aborted");
+		try {
+			const handle = await open(path, "wx", 384);
+			await handle.writeFile(JSON.stringify({
+				pid: process.pid,
+				createdAt: Date.now(),
+				...metadata
+			}));
+			await handle.close();
+			break;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			if (await staleLock(path)) {
+				await unlink(path).catch(() => void 0);
+				continue;
+			}
+			if (Date.now() - waitStartedAt > LOCK_STALE_MS) throw new Error(`Timed out waiting for runtime installation lock: ${path}`);
+			await new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					signal?.removeEventListener("abort", abort);
+					resolve();
+				}, LOCK_WAIT_MS);
+				const abort = () => {
+					clearTimeout(timeout);
+					reject(signal?.reason ?? /* @__PURE__ */ new Error("Runtime installation was aborted"));
+				};
+				signal?.addEventListener("abort", abort, { once: true });
+			});
 		}
-		await new Promise((resolve) => setTimeout(resolve, LOCK_WAIT_MS));
 	}
 	try {
 		return await fn();

package/dist/src/runtime-tools/manager.d.ts

@@ -15,6 +15,6 @@ export declare class ManagedRuntimeManager extends EventEmitter {
     private uvEnvironment;
     status(runtime: RuntimeKind): Promise<RuntimeStatus>;
     statusAll(): Promise<RuntimeStatus[]>;
-    repair(runtime: RuntimeKind): Promise<ResolvedRuntime>;
+    repair(runtime: RuntimeKind, requestedVersion?: string): Promise<ResolvedRuntime>;
     private progress;
 }