acpx 0.3.1 → 0.4.1

package/dist/{queue-ipc-EQLpBMKv.js → queue-ipc-CE8_QGX3.js}

@@ -1,9 +1,8 @@
-import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
-import { t as isAcpJsonRpcMessage } from "./acp-jsonrpc-BNHXq7qK.js";
+import { n as isAcpJsonRpcMessage } from "./acp-jsonrpc-BbBgC5gO.js";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
+import { createHash, randomUUID } from "node:crypto";
 import net from "node:net";
 //#region src/acp-error-shapes.ts
 const RESOURCE_NOT_FOUND_ACP_CODES = new Set([-32001, -32002]);
@@ -52,10 +51,11 @@ function formatUnknownErrorMessage(error) {
 	}
 	return String(error);
 }
+const SESSION_NOT_FOUND_PATTERN = /session\s+["'\w-]+\s+not found/i;
 function isSessionNotFoundText(value) {
 	if (typeof value !== "string") return false;
 	const normalized = value.toLowerCase();
-	return normalized.includes("resource_not_found") || normalized.includes("resource not found") || normalized.includes("session not found") || normalized.includes("unknown session") || normalized.includes("invalid session identifier");
+	return normalized.includes("resource_not_found") || normalized.includes("resource not found") || normalized.includes("session not found") || normalized.includes("unknown session") || normalized.includes("invalid session identifier") || SESSION_NOT_FOUND_PATTERN.test(value);
 }
 function hasSessionNotFoundHint(value, depth = 0) {
 	if (depth > 4) return false;
@@ -112,6 +112,33 @@ var AgentSpawnError = class extends AcpxOperationalError {
 		this.agentCommand = agentCommand;
 	}
 };
+var AgentDisconnectedError = class extends AcpxOperationalError {
+	reason;
+	exitCode;
+	signal;
+	constructor(reason, exitCode, signal, options) {
+		super(`ACP agent disconnected during request (${reason}, exit=${exitCode ?? "null"}, signal=${signal ?? "null"})`, {
+			outputCode: "RUNTIME",
+			detailCode: "AGENT_DISCONNECTED",
+			origin: "acp",
+			...options
+		});
+		this.reason = reason;
+		this.exitCode = exitCode;
+		this.signal = signal;
+	}
+};
+var SessionResumeRequiredError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "RUNTIME",
+			detailCode: "SESSION_RESUME_REQUIRED",
+			origin: "acp",
+			retryable: true,
+			...options
+		});
+	}
+};
 var GeminiAcpStartupTimeoutError = class extends AcpxOperationalError {
 	constructor(message, options) {
 		super(message, {
@@ -132,6 +159,16 @@ var SessionModeReplayError = class extends AcpxOperationalError {
 		});
 	}
 };
+var SessionModelReplayError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "RUNTIME",
+			detailCode: "SESSION_MODEL_REPLAY_FAILED",
+			origin: "acp",
+			...options
+		});
+	}
+};
 var ClaudeAcpSessionCreateTimeoutError = class extends AcpxOperationalError {
 	constructor(message, options) {
 		super(message, {
@@ -286,6 +323,34 @@ function promptToDisplayText(prompt) {
 	}).filter((entry) => entry.trim().length > 0).join("\n\n").trim();
 }
 //#endregion
+//#region src/agent-session-id.ts
+const AGENT_SESSION_ID_META_KEYS = ["agentSessionId", "sessionId"];
+function normalizeAgentSessionId(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function asMetaRecord(meta) {
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
+	return meta;
+}
+function extractAgentSessionId(meta) {
+	const record = asMetaRecord(meta);
+	if (!record) return;
+	for (const key of AGENT_SESSION_ID_META_KEYS) {
+		const normalized = normalizeAgentSessionId(record[key]);
+		if (normalized) return normalized;
+	}
+}
+//#endregion
+//#region src/runtime-session-id.ts
+function normalizeRuntimeSessionId(value) {
+	return normalizeAgentSessionId(value);
+}
+function extractRuntimeSessionId(meta) {
+	return extractAgentSessionId(meta);
+}
+//#endregion
 //#region src/types.ts
 const EXIT_CODES = {
 	SUCCESS: 0,
@@ -404,6 +469,24 @@ function normalizeOutputError(error, options = {}) {
 		acp
 	};
 }
+/**
+* Returns true when an error from `client.prompt()` looks transient and
+* can reasonably be retried (e.g. model-API 400/500, network hiccups that
+* surface as ACP internal errors).
+*
+* Errors that are definitively non-recoverable (auth, missing session,
+* invalid params, timeout, permission) return false.
+*/
+function isRetryablePromptError(error) {
+	if (error instanceof PermissionDeniedError || error instanceof PermissionPromptUnavailableError) return false;
+	if (isTimeoutLike(error) || isNoSessionLike(error) || isUsageLike(error)) return false;
+	const acp = extractAcpError(error);
+	if (!acp) return false;
+	if (acp.code === -32001 || acp.code === -32002) return false;
+	if (isAcpAuthRequiredPayload(acp)) return false;
+	if (acp.code === -32601 || acp.code === -32602) return false;
+	return acp.code === -32603 || acp.code === -32700;
+}
 function exitCodeForOutputErrorCode(code) {
 	switch (code) {
 		case "USAGE": return EXIT_CODES.USAGE;
@@ -690,6 +773,96 @@ async function waitMs(ms) {
 	});
 }
 //#endregion
+//#region src/queue-ipc-transport.ts
+const QUEUE_CONNECT_ATTEMPTS = 40;
+const SOCKET_CONNECTION_TIMEOUT_MS = 5e3;
+function shouldRetryQueueConnect(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "ECONNREFUSED";
+}
+async function connectToSocket(socketPath, timeoutMs = SOCKET_CONNECTION_TIMEOUT_MS) {
+	return await new Promise((resolve, reject) => {
+		const socket = net.createConnection(socketPath);
+		let settled = false;
+		const timeout = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			reject(/* @__PURE__ */ new Error(`Connection to ${socketPath} timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		const onConnect = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			socket.off("error", onError);
+			resolve(socket);
+		};
+		const onError = (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			socket.off("connect", onConnect);
+			reject(error);
+		};
+		socket.once("connect", onConnect);
+		socket.once("error", onError);
+	});
+}
+async function connectToQueueOwner(owner, maxAttempts = QUEUE_CONNECT_ATTEMPTS) {
+	let lastError;
+	const attempts = Math.max(1, Math.trunc(maxAttempts));
+	for (let attempt = 0; attempt < attempts; attempt += 1) try {
+		return await measurePerf("queue.connect", async () => await connectToSocket(owner.socketPath));
+	} catch (error) {
+		lastError = error;
+		if (!shouldRetryQueueConnect(error)) throw error;
+		await waitMs(50);
+	}
+	if (lastError && !shouldRetryQueueConnect(lastError)) throw lastError;
+}
+//#endregion
+//#region src/queue-ipc-health.ts
+async function probeQueueOwnerHealth(sessionId) {
+	const ownerRecord = await readQueueOwnerRecord(sessionId);
+	if (!ownerRecord) return {
+		sessionId,
+		hasLease: false,
+		healthy: false,
+		socketReachable: false,
+		pidAlive: false
+	};
+	const owner = await readQueueOwnerStatus(sessionId);
+	if (!owner) return {
+		sessionId,
+		hasLease: false,
+		healthy: false,
+		socketReachable: false,
+		pidAlive: false
+	};
+	const pidAlive = owner.alive;
+	let socketReachable = false;
+	try {
+		const socket = await connectToQueueOwner(ownerRecord, 2);
+		if (socket) {
+			socketReachable = true;
+			if (!socket.destroyed) socket.end();
+		}
+	} catch {
+		socketReachable = false;
+	}
+	return {
+		sessionId,
+		hasLease: true,
+		healthy: socketReachable,
+		socketReachable,
+		pidAlive,
+		pid: owner.pid,
+		socketPath: owner.socketPath,
+		ownerGeneration: owner.ownerGeneration,
+		queueDepth: owner.queueDepth
+	};
+}
+//#endregion
 //#region src/queue-messages.ts
 function asRecord(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
@@ -698,6 +871,9 @@ function asRecord(value) {
 function isPermissionMode(value) {
 	return value === "approve-all" || value === "approve-reads" || value === "deny-all";
 }
+function isSessionResumePolicy(value) {
+	return value === "allow-new" || value === "same-session-only";
+}
 function isNonInteractivePermissionPolicy(value) {
 	return value === "deny" || value === "fail";
 }
@@ -732,10 +908,11 @@ function parseQueueRequest(raw) {
 	const timeoutRaw = request.timeoutMs;
 	const timeoutMs = typeof timeoutRaw === "number" && Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? Math.round(timeoutRaw) : void 0;
 	if (request.type === "submit_prompt") {
+		const resumePolicy = request.resumePolicy == null ? void 0 : isSessionResumePolicy(request.resumePolicy) ? request.resumePolicy : null;
 		const nonInteractivePermissions = request.nonInteractivePermissions == null ? void 0 : isNonInteractivePermissionPolicy(request.nonInteractivePermissions) ? request.nonInteractivePermissions : null;
 		const suppressSdkConsoleErrors = request.suppressSdkConsoleErrors == null ? void 0 : typeof request.suppressSdkConsoleErrors === "boolean" ? request.suppressSdkConsoleErrors : null;
 		const prompt = request.prompt == null ? void 0 : isPromptInput(request.prompt) ? request.prompt : null;
-		if (typeof request.message !== "string" || !isPermissionMode(request.permissionMode) || prompt === null || nonInteractivePermissions === null || suppressSdkConsoleErrors === null || typeof request.waitForCompletion !== "boolean") return null;
+		if (typeof request.message !== "string" || !isPermissionMode(request.permissionMode) || resumePolicy === null || prompt === null || nonInteractivePermissions === null || suppressSdkConsoleErrors === null || typeof request.waitForCompletion !== "boolean") return null;
 		return {
 			type: "submit_prompt",
 			requestId: request.requestId,
@@ -743,6 +920,7 @@ function parseQueueRequest(raw) {
 			message: request.message,
 			prompt: prompt ?? textPrompt(request.message),
 			permissionMode: request.permissionMode,
+			...resumePolicy !== void 0 ? { resumePolicy } : {},
 			nonInteractivePermissions,
 			timeoutMs,
 			...suppressSdkConsoleErrors !== void 0 ? { suppressSdkConsoleErrors } : {},
@@ -764,6 +942,16 @@ function parseQueueRequest(raw) {
 			timeoutMs
 		};
 	}
+	if (request.type === "set_model") {
+		if (typeof request.modelId !== "string" || request.modelId.trim().length === 0) return null;
+		return {
+			type: "set_model",
+			requestId: request.requestId,
+			ownerGeneration,
+			modelId: request.modelId,
+			timeoutMs
+		};
+	}
 	if (request.type === "set_config_option") {
 		if (typeof request.configId !== "string" || request.configId.trim().length === 0 || typeof request.value !== "string" || request.value.trim().length === 0) return null;
 		return {
@@ -836,6 +1024,15 @@ function parseQueueOwnerMessage(raw) {
 			modeId: message.modeId
 		};
 	}
+	if (message.type === "set_model_result") {
+		if (typeof message.modelId !== "string") return null;
+		return {
+			type: "set_model_result",
+			requestId: message.requestId,
+			ownerGeneration,
+			modelId: message.modelId
+		};
+	}
 	if (message.type === "set_config_option_result") {
 		const response = asRecord(message.response);
 		if (!response || !Array.isArray(response.configOptions)) return null;
@@ -1084,6 +1281,21 @@ var SessionQueueOwner = class SessionQueueOwner {
 				});
 				return;
 			}
+			if (request.type === "set_model") {
+				this.handleControlRequest({
+					socket,
+					requestId: request.requestId,
+					run: async () => {
+						await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
+						return {
+							type: "set_model_result",
+							requestId: request.requestId,
+							modelId: request.modelId
+						};
+					}
+				});
+				return;
+			}
 			if (request.type === "set_config_option") {
 				this.handleControlRequest({
 					socket,
@@ -1101,6 +1313,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 				message: request.message,
 				prompt: request.prompt ?? textPrompt(request.message),
 				permissionMode: request.permissionMode,
+				resumePolicy: request.resumePolicy,
 				nonInteractivePermissions: request.nonInteractivePermissions,
 				timeoutMs: request.timeoutMs,
 				suppressSdkConsoleErrors: request.suppressSdkConsoleErrors,
@@ -1139,23 +1352,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 };
 //#endregion
 //#region src/queue-ipc.ts
-var queue_ipc_exports = /* @__PURE__ */ __exportAll({
-	QUEUE_CONNECT_RETRY_MS: () => 50,
-	SessionQueueOwner: () => SessionQueueOwner,
-	isProcessAlive: () => isProcessAlive,
-	probeQueueOwnerHealth: () => probeQueueOwnerHealth,
-	releaseQueueOwnerLease: () => releaseQueueOwnerLease,
-	terminateProcess: () => terminateProcess,
-	terminateQueueOwnerForSession: () => terminateQueueOwnerForSession,
-	tryAcquireQueueOwnerLease: () => tryAcquireQueueOwnerLease,
-	tryCancelOnRunningOwner: () => tryCancelOnRunningOwner,
-	trySetConfigOptionOnRunningOwner: () => trySetConfigOptionOnRunningOwner,
-	trySetModeOnRunningOwner: () => trySetModeOnRunningOwner,
-	trySubmitToRunningOwner: () => trySubmitToRunningOwner,
-	waitMs: () => waitMs
-});
-const QUEUE_CONNECT_ATTEMPTS = 40;
-const QUEUE_CONNECT_RETRY_MS = 50;
+const MAX_MESSAGE_BUFFER_SIZE = 10 * 1024 * 1024;
 const STALE_OWNER_PROTOCOL_DETAIL_CODES = new Set(["QUEUE_PROTOCOL_MALFORMED_MESSAGE", "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE"]);
 async function maybeRecoverStaleOwnerAfterProtocolMismatch(params) {
 	if (!(params.error instanceof QueueProtocolError)) return false;
@@ -1166,77 +1363,6 @@ async function maybeRecoverStaleOwnerAfterProtocolMismatch(params) {
 	if (params.verbose) process.stderr.write(`[acpx] dropped stale queue owner metadata after protocol mismatch for session ${params.sessionId} (${detailCode})\n`);
 	return true;
 }
-function shouldRetryQueueConnect(error) {
-	const code = error.code;
-	return code === "ENOENT" || code === "ECONNREFUSED";
-}
-async function connectToSocket(socketPath) {
-	return await new Promise((resolve, reject) => {
-		const socket = net.createConnection(socketPath);
-		const onConnect = () => {
-			socket.off("error", onError);
-			resolve(socket);
-		};
-		const onError = (error) => {
-			socket.off("connect", onConnect);
-			reject(error);
-		};
-		socket.once("connect", onConnect);
-		socket.once("error", onError);
-	});
-}
-async function connectToQueueOwner(owner, maxAttempts = QUEUE_CONNECT_ATTEMPTS) {
-	let lastError;
-	const attempts = Math.max(1, Math.trunc(maxAttempts));
-	for (let attempt = 0; attempt < attempts; attempt += 1) try {
-		return await measurePerf("queue.connect", async () => await connectToSocket(owner.socketPath));
-	} catch (error) {
-		lastError = error;
-		if (!shouldRetryQueueConnect(error)) throw error;
-		await waitMs(50);
-	}
-	if (lastError && !shouldRetryQueueConnect(lastError)) throw lastError;
-}
-async function probeQueueOwnerHealth(sessionId) {
-	const ownerRecord = await readQueueOwnerRecord(sessionId);
-	if (!ownerRecord) return {
-		sessionId,
-		hasLease: false,
-		healthy: false,
-		socketReachable: false,
-		pidAlive: false
-	};
-	const owner = await readQueueOwnerStatus(sessionId);
-	if (!owner) return {
-		sessionId,
-		hasLease: false,
-		healthy: false,
-		socketReachable: false,
-		pidAlive: false
-	};
-	const pidAlive = owner.alive;
-	let socketReachable = false;
-	try {
-		const socket = await connectToQueueOwner(ownerRecord, 2);
-		if (socket) {
-			socketReachable = true;
-			if (!socket.destroyed) socket.end();
-		}
-	} catch {
-		socketReachable = false;
-	}
-	return {
-		sessionId,
-		hasLease: true,
-		healthy: socketReachable,
-		socketReachable,
-		pidAlive,
-		pid: owner.pid,
-		socketPath: owner.socketPath,
-		ownerGeneration: owner.ownerGeneration,
-		queueDepth: owner.queueDepth
-	};
-}
 function assertOwnerGeneration(owner, message) {
 	if (owner.ownerGeneration !== void 0 && message.ownerGeneration !== void 0 && message.ownerGeneration !== owner.ownerGeneration) throw new QueueProtocolError("Queue owner returned mismatched generation", {
 		detailCode: "QUEUE_OWNER_GENERATION_MISMATCH",
@@ -1313,6 +1439,11 @@ async function runQueueOwnerRequest(options) {
 		};
 		socket.on("data", (chunk) => {
 			buffer += chunk;
+			if (buffer.length > 10485760) {
+				socket.destroy();
+				finishReject(/* @__PURE__ */ new Error(`Message buffer exceeded ${MAX_MESSAGE_BUFFER_SIZE} bytes`));
+				return;
+			}
 			let index = buffer.indexOf("\n");
 			while (index >= 0) {
 				const line = buffer.slice(0, index).trim();
@@ -1340,6 +1471,7 @@ async function submitToQueueOwner(owner, options) {
 		message: options.message,
 		prompt: options.prompt,
 		permissionMode: options.permissionMode,
+		resumePolicy: options.resumePolicy,
 		nonInteractivePermissions: options.nonInteractivePermissions,
 		timeoutMs: options.timeoutMs,
 		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
@@ -1512,6 +1644,23 @@ async function submitSetModeToQueueOwner(owner, modeId, timeoutMs) {
 	});
 	return true;
 }
+async function submitSetModelToQueueOwner(owner, modelId, timeoutMs) {
+	const request = {
+		type: "set_model",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		modelId,
+		timeoutMs
+	};
+	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "set_model_result");
+	if (!response) return;
+	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched set_model response", {
+		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+		origin: "queue",
+		retryable: true
+	});
+	return true;
+}
 async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
 	const request = {
 		type: "set_config_option",
@@ -1585,6 +1734,20 @@ async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
 		retryable: true
 	});
 }
+async function trySetModelOnRunningOwner(sessionId, modelId, timeoutMs, verbose) {
+	const owner = await readQueueOwnerRecord(sessionId);
+	if (!owner) return;
+	if (await submitSetModelToQueueOwner(owner, modelId, timeoutMs)) {
+		if (verbose) process.stderr.write(`[acpx] requested session/set_model on owner pid ${owner.pid} for session ${sessionId}\n`);
+		return true;
+	}
+	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
+	throw new QueueConnectionError("Session queue owner is running but not accepting set_model requests", {
+		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+		origin: "queue",
+		retryable: true
+	});
+}
 async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose) {
 	const owner = await readQueueOwnerRecord(sessionId);
 	if (!owner) return;
@@ -1601,6 +1764,6 @@ async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, time
 	});
 }
 //#endregion
-export { OUTPUT_FORMATS as A, CopilotAcpUnsupportedError as B, exitCodeForOutputErrorCode as C, AUTH_POLICIES as D, normalizeOutputError as E, promptToDisplayText as F, SessionModeReplayError as G, PermissionDeniedError as H, textPrompt as I, extractAcpError as J, SessionNotFoundError as K, AgentSpawnError as L, PromptInputValidationError as M, mergePromptSourceWithText as N, EXIT_CODES as O, parsePromptSource as P, AuthPolicyError as R, startPerfTimer as S, isAcpQueryClosedBeforeResponseError as T, PermissionPromptUnavailableError as U, GeminiAcpStartupTimeoutError as V, QueueConnectionError as W, isAcpResourceNotFoundError as Y, getPerfMetricsSnapshot as _, trySetConfigOptionOnRunningOwner as a, resetPerfMetrics as b, SessionQueueOwner as c, releaseQueueOwnerLease as d, terminateProcess as f, formatPerfMetric as g, waitMs as h, tryCancelOnRunningOwner as i, SESSION_RECORD_SCHEMA as j, NON_INTERACTIVE_PERMISSION_POLICIES as k, isProcessAlive as l, tryAcquireQueueOwnerLease as m, probeQueueOwnerHealth as n, trySetModeOnRunningOwner as o, terminateQueueOwnerForSession as p, SessionResolutionError as q, queue_ipc_exports as r, trySubmitToRunningOwner as s, QUEUE_CONNECT_RETRY_MS as t, refreshQueueOwnerLease as u, incrementPerfCounter as v, formatErrorMessage as w, setPerfGauge as x, measurePerf as y, ClaudeAcpSessionCreateTimeoutError as z };
+export { extractAcpError as $, OUTPUT_FORMATS as A, AgentSpawnError as B, formatErrorMessage as C, AUTH_POLICIES as D, normalizeOutputError as E, mergePromptSourceWithText as F, PermissionDeniedError as G, ClaudeAcpSessionCreateTimeoutError as H, parsePromptSource as I, SessionModeReplayError as J, PermissionPromptUnavailableError as K, promptToDisplayText as L, extractRuntimeSessionId as M, normalizeRuntimeSessionId as N, EXIT_CODES as O, PromptInputValidationError as P, SessionResumeRequiredError as Q, textPrompt as R, exitCodeForOutputErrorCode as S, isRetryablePromptError as T, CopilotAcpUnsupportedError as U, AuthPolicyError as V, GeminiAcpStartupTimeoutError as W, SessionNotFoundError as X, SessionModelReplayError as Y, SessionResolutionError as Z, incrementPerfCounter as _, trySubmitToRunningOwner as a, setPerfGauge as b, isProcessAlive as c, terminateProcess as d, isAcpResourceNotFoundError as et, terminateQueueOwnerForSession as f, getPerfMetricsSnapshot as g, formatPerfMetric as h, trySetModelOnRunningOwner as i, SESSION_RECORD_SCHEMA as j, NON_INTERACTIVE_PERMISSION_POLICIES as k, refreshQueueOwnerLease as l, waitMs as m, trySetConfigOptionOnRunningOwner as n, SessionQueueOwner as o, tryAcquireQueueOwnerLease as p, QueueConnectionError as q, trySetModeOnRunningOwner as r, probeQueueOwnerHealth as s, tryCancelOnRunningOwner as t, releaseQueueOwnerLease as u, measurePerf as v, isAcpQueryClosedBeforeResponseError as w, startPerfTimer as x, resetPerfMetrics as y, AgentDisconnectedError as z };
 
-//# sourceMappingURL=queue-ipc-EQLpBMKv.js.map
+//# sourceMappingURL=queue-ipc-CE8_QGX3.js.map