@pixelzx/genesis 2026.5.3-2 → 2026.5.3-3

package/dist/run-main-Bk3B1Ycl.js

@@ -1,516 +0,0 @@
-import { a as formatUncaughtError } from "./errors-Jbvi20TW.js";
-import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
-import { A as getPositiveIntFlagValue, B as isValueToken, M as getVerboseFlag, N as hasFlag, O as getCommandPositionalsWithRootOptions, k as getFlagValue } from "./logger-QwLssHIf.js";
-import { t as resolveCliArgvInvocation } from "./argv-invocation-BIP3nEco.js";
-import { a as parseCliContainerArgs, i as maybeRunCliInContainer, n as applyCliProfileEnv, r as parseCliProfileArgs, t as normalizeWindowsArgv } from "./windows-argv-BjGyLQLP.js";
-import { n as defaultRuntime } from "./runtime-CQ7eH0le.js";
-import { a as enableConsoleCapture } from "./subsystem-DTMy5YmO.js";
-import { i as normalizeEnv, t as isTruthyEnvValue } from "./env-CLDDxlAx.js";
-import { _ as resolveStateDir } from "./paths-DmR9mjUX.js";
-import { t as assertSupportedRuntime } from "./runtime-guard-BFpbWnbi.js";
-import { t as resolveManifestCommandAliasOwner } from "./manifest-command-aliases.runtime-Bn3BECKD.js";
-import { s as hasMemoryRuntime } from "./memory-state-I5DhT9-V.js";
-import "./logging-CK8BHMuV.js";
-import { i as initializeDebugProxyCapture, r as finalizeDebugProxyCapture } from "./runtime-BvG8l5o6.js";
-import { r as ensureGlobalUndiciEnvProxyDispatcher } from "./undici-global-dispatcher-Xd3UzxKn.js";
-import { t as ensureGenesisCliOnPath } from "./path-env-BdTD13zq.js";
-import { i as shouldSkipPluginCommandRegistration, n as shouldRegisterPrimaryCommandOnly } from "./command-registration-policy-B8ZdpbiI.js";
-import { a as shouldEnsureCliPathForCommandPath, c as cliCommandCatalog, n as ensureCliExecutionBootstrap, o as resolveCliCommandPathPolicy, r as resolveCliExecutionStartupContext, s as matchesCommandPath, t as applyCliExecutionStartupPresentation } from "./command-execution-startup-Dzs0UAoU.js";
-import { n as maybeWarnAboutDebugProxyCoverage } from "./coverage-DnUzcfFR.js";
-import process$1 from "node:process";
-import "node:url";
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { CommanderError } from "commander";
-//#region src/cli/program/route-args.ts
-function parseOptionalFlagValue(argv, name) {
-	const value = getFlagValue(argv, name);
-	if (value === null) return { ok: false };
-	return {
-		ok: true,
-		value
-	};
-}
-function parseRepeatedFlagValues(argv, name) {
-	const values = [];
-	const args = argv.slice(2);
-	for (let i = 0; i < args.length; i += 1) {
-		const arg = args[i];
-		if (!arg || arg === "--") break;
-		if (arg === name) {
-			const next = args[i + 1];
-			if (!isValueToken(next)) return null;
-			values.push(next);
-			i += 1;
-			continue;
-		}
-		if (arg.startsWith(`${name}=`)) {
-			const value = arg.slice(name.length + 1).trim();
-			if (!value) return null;
-			values.push(value);
-		}
-	}
-	return values;
-}
-function parseSinglePositional(argv, params) {
-	const positionals = getCommandPositionalsWithRootOptions(argv, params);
-	if (!positionals || positionals.length !== 1) return null;
-	return positionals[0] ?? null;
-}
-function parseHealthRouteArgs(argv) {
-	const timeoutMs = getPositiveIntFlagValue(argv, "--timeout");
-	if (timeoutMs === null) return null;
-	return {
-		json: hasFlag(argv, "--json"),
-		verbose: getVerboseFlag(argv, { includeDebug: true }),
-		timeoutMs
-	};
-}
-function parseStatusRouteArgs(argv) {
-	const timeoutMs = getPositiveIntFlagValue(argv, "--timeout");
-	if (timeoutMs === null) return null;
-	return {
-		json: hasFlag(argv, "--json"),
-		deep: hasFlag(argv, "--deep"),
-		all: hasFlag(argv, "--all"),
-		usage: hasFlag(argv, "--usage"),
-		verbose: getVerboseFlag(argv, { includeDebug: true }),
-		timeoutMs
-	};
-}
-function parseGatewayStatusRouteArgs(argv) {
-	const url = parseOptionalFlagValue(argv, "--url");
-	if (!url.ok) return null;
-	const token = parseOptionalFlagValue(argv, "--token");
-	if (!token.ok) return null;
-	const password = parseOptionalFlagValue(argv, "--password");
-	if (!password.ok) return null;
-	const timeout = parseOptionalFlagValue(argv, "--timeout");
-	if (!timeout.ok) return null;
-	const ssh = parseOptionalFlagValue(argv, "--ssh");
-	if (!ssh.ok || ssh.value !== void 0) return null;
-	const sshIdentity = parseOptionalFlagValue(argv, "--ssh-identity");
-	if (!sshIdentity.ok || sshIdentity.value !== void 0) return null;
-	if (hasFlag(argv, "--ssh-auto")) return null;
-	return {
-		rpc: {
-			url: url.value,
-			token: token.value,
-			password: password.value,
-			timeout: timeout.value
-		},
-		deep: hasFlag(argv, "--deep"),
-		json: hasFlag(argv, "--json"),
-		requireRpc: hasFlag(argv, "--require-rpc"),
-		probe: !hasFlag(argv, "--no-probe")
-	};
-}
-function parseSessionsRouteArgs(argv) {
-	const agent = parseOptionalFlagValue(argv, "--agent");
-	if (!agent.ok) return null;
-	const store = parseOptionalFlagValue(argv, "--store");
-	if (!store.ok) return null;
-	const active = parseOptionalFlagValue(argv, "--active");
-	if (!active.ok) return null;
-	return {
-		json: hasFlag(argv, "--json"),
-		allAgents: hasFlag(argv, "--all-agents"),
-		agent: agent.value,
-		store: store.value,
-		active: active.value
-	};
-}
-function parseAgentsListRouteArgs(argv) {
-	return {
-		json: hasFlag(argv, "--json"),
-		bindings: hasFlag(argv, "--bindings")
-	};
-}
-function parseConfigGetRouteArgs(argv) {
-	const path = parseSinglePositional(argv, {
-		commandPath: ["config", "get"],
-		booleanFlags: ["--json"]
-	});
-	if (!path) return null;
-	return {
-		path,
-		json: hasFlag(argv, "--json")
-	};
-}
-function parseConfigUnsetRouteArgs(argv) {
-	const path = parseSinglePositional(argv, { commandPath: ["config", "unset"] });
-	if (!path) return null;
-	return { path };
-}
-function parseModelsListRouteArgs(argv) {
-	const provider = parseOptionalFlagValue(argv, "--provider");
-	if (!provider.ok) return null;
-	return {
-		provider: provider.value,
-		all: hasFlag(argv, "--all"),
-		local: hasFlag(argv, "--local"),
-		json: hasFlag(argv, "--json"),
-		plain: hasFlag(argv, "--plain")
-	};
-}
-function parseModelsStatusRouteArgs(argv) {
-	const probeProvider = parseOptionalFlagValue(argv, "--probe-provider");
-	if (!probeProvider.ok) return null;
-	const probeTimeout = parseOptionalFlagValue(argv, "--probe-timeout");
-	if (!probeTimeout.ok) return null;
-	const probeConcurrency = parseOptionalFlagValue(argv, "--probe-concurrency");
-	if (!probeConcurrency.ok) return null;
-	const probeMaxTokens = parseOptionalFlagValue(argv, "--probe-max-tokens");
-	if (!probeMaxTokens.ok) return null;
-	const agent = parseOptionalFlagValue(argv, "--agent");
-	if (!agent.ok) return null;
-	const probeProfileValues = parseRepeatedFlagValues(argv, "--probe-profile");
-	if (probeProfileValues === null) return null;
-	const probeProfile = probeProfileValues.length === 0 ? void 0 : probeProfileValues.length === 1 ? probeProfileValues[0] : probeProfileValues;
-	return {
-		probeProvider: probeProvider.value,
-		probeTimeout: probeTimeout.value,
-		probeConcurrency: probeConcurrency.value,
-		probeMaxTokens: probeMaxTokens.value,
-		agent: agent.value,
-		probeProfile,
-		json: hasFlag(argv, "--json"),
-		plain: hasFlag(argv, "--plain"),
-		check: hasFlag(argv, "--check"),
-		probe: hasFlag(argv, "--probe")
-	};
-}
-function parseChannelsListRouteArgs(argv) {
-	return {
-		json: hasFlag(argv, "--json"),
-		usage: !hasFlag(argv, "--no-usage")
-	};
-}
-function parseChannelsStatusRouteArgs(argv) {
-	const timeout = parseOptionalFlagValue(argv, "--timeout");
-	if (!timeout.ok) return null;
-	return {
-		json: hasFlag(argv, "--json"),
-		probe: hasFlag(argv, "--probe"),
-		timeout: timeout.value
-	};
-}
-//#endregion
-//#region src/cli/program/routed-command-definitions.ts
-function defineRoutedCommand(definition) {
-	return definition;
-}
-let configCliPromise;
-let modelsListPromise;
-function loadConfigCli() {
-	configCliPromise ??= import("./config-cli-CdYXdQ9l.js");
-	return configCliPromise;
-}
-function loadModelsList() {
-	modelsListPromise ??= import("./list-B99x_eEq.js");
-	return modelsListPromise;
-}
-const routedCommandDefinitions = {
-	health: defineRoutedCommand({
-		parseArgs: parseHealthRouteArgs,
-		runParsedArgs: async (args) => {
-			const { healthCommand } = await import("./health-CVQcF_SU.js");
-			await healthCommand(args, defaultRuntime);
-		}
-	}),
-	status: defineRoutedCommand({
-		parseArgs: parseStatusRouteArgs,
-		runParsedArgs: async (args) => {
-			if (args.json) {
-				const { statusJsonCommand } = await import("./status-json-DTxIuLgj.js");
-				await statusJsonCommand({
-					deep: args.deep,
-					all: args.all,
-					usage: args.usage,
-					timeoutMs: args.timeoutMs
-				}, defaultRuntime);
-				return;
-			}
-			const { statusCommand } = await import("./status-tDmBvO9G.js");
-			await statusCommand(args, defaultRuntime);
-		}
-	}),
-	"gateway-status": defineRoutedCommand({
-		parseArgs: parseGatewayStatusRouteArgs,
-		runParsedArgs: async (args) => {
-			const { runDaemonStatus } = await import("./status-DYJ_8ZJ7.js");
-			await runDaemonStatus(args);
-		}
-	}),
-	sessions: defineRoutedCommand({
-		parseArgs: parseSessionsRouteArgs,
-		runParsedArgs: async (args) => {
-			const { sessionsCommand } = await import("./sessions-uBVh9dx9.js");
-			await sessionsCommand(args, defaultRuntime);
-		}
-	}),
-	"agents-list": defineRoutedCommand({
-		parseArgs: parseAgentsListRouteArgs,
-		runParsedArgs: async (args) => {
-			const { agentsListCommand } = await import("./agents-BKMfctCm.js");
-			await agentsListCommand(args, defaultRuntime);
-		}
-	}),
-	"config-get": defineRoutedCommand({
-		parseArgs: parseConfigGetRouteArgs,
-		runParsedArgs: async (args) => {
-			const { runConfigGet } = await loadConfigCli();
-			await runConfigGet(args);
-		}
-	}),
-	"config-unset": defineRoutedCommand({
-		parseArgs: parseConfigUnsetRouteArgs,
-		runParsedArgs: async (args) => {
-			const { runConfigUnset } = await loadConfigCli();
-			await runConfigUnset(args);
-		}
-	}),
-	"models-list": defineRoutedCommand({
-		parseArgs: parseModelsListRouteArgs,
-		runParsedArgs: async (args) => {
-			const { modelsListCommand } = await loadModelsList();
-			await modelsListCommand(args, defaultRuntime);
-		}
-	}),
-	"models-status": defineRoutedCommand({
-		parseArgs: parseModelsStatusRouteArgs,
-		runParsedArgs: async (args) => {
-			const { modelsStatusCommand } = await loadModelsList();
-			await modelsStatusCommand(args, defaultRuntime);
-		}
-	}),
-	"channels-list": defineRoutedCommand({
-		parseArgs: parseChannelsListRouteArgs,
-		runParsedArgs: async (args) => {
-			const { channelsListCommand } = await import("./list-CXO2Pv7s.js");
-			await channelsListCommand(args, defaultRuntime);
-		}
-	}),
-	"channels-status": defineRoutedCommand({
-		parseArgs: parseChannelsStatusRouteArgs,
-		runParsedArgs: async (args) => {
-			const { channelsStatusCommand } = await import("./status-BFeYb9-f.js");
-			await channelsStatusCommand(args, defaultRuntime);
-		}
-	})
-};
-//#endregion
-//#region src/cli/program/route-specs.ts
-function createCommandLoadPlugins(commandPath) {
-	return (argv) => {
-		const loadPlugins = resolveCliCommandPathPolicy([...commandPath]).loadPlugins;
-		return loadPlugins === "always" || loadPlugins === "text-only" && !hasFlag(argv, "--json");
-	};
-}
-function createParsedRoute(params) {
-	return {
-		matches: (path) => matchesCommandPath(path, params.entry.commandPath, { exact: params.entry.exact }),
-		loadPlugins: params.entry.route?.preloadPlugins ? createCommandLoadPlugins(params.entry.commandPath) : void 0,
-		run: async (argv) => {
-			const args = params.definition.parseArgs(argv);
-			if (!args) return false;
-			await params.definition.runParsedArgs(args);
-			return true;
-		}
-	};
-}
-const routedCommands = cliCommandCatalog.filter((entry) => Boolean(entry.route)).map((entry) => createParsedRoute({
-	entry,
-	definition: routedCommandDefinitions[entry.route.id]
-}));
-//#endregion
-//#region src/cli/program/routes.ts
-function findRoutedCommand(path) {
-	for (const route of routedCommands) if (route.matches(path)) return route;
-	return null;
-}
-//#endregion
-//#region src/cli/route.ts
-async function prepareRoutedCommand(params) {
-	const { startupPolicy } = resolveCliExecutionStartupContext({
-		argv: params.argv,
-		jsonOutputMode: hasFlag(params.argv, "--json"),
-		env: process.env,
-		routeMode: true
-	});
-	const { VERSION } = await import("./version-FRL0kdp-.js");
-	await applyCliExecutionStartupPresentation({
-		argv: params.argv,
-		routeLogsToStderrOnSuppress: false,
-		startupPolicy,
-		showBanner: process.stdout.isTTY && !startupPolicy.suppressDoctorStdout,
-		version: VERSION
-	});
-	const shouldLoadPlugins = typeof params.loadPlugins === "function" ? params.loadPlugins(params.argv) : params.loadPlugins;
-	await ensureCliExecutionBootstrap({
-		runtime: defaultRuntime,
-		commandPath: params.commandPath,
-		startupPolicy,
-		loadPlugins: shouldLoadPlugins ?? startupPolicy.loadPlugins
-	});
-}
-async function tryRouteCli(argv) {
-	if (isTruthyEnvValue(process.env.GENESIS_DISABLE_ROUTE_FIRST)) return false;
-	const invocation = resolveCliArgvInvocation(argv);
-	if (invocation.hasHelpOrVersion) return false;
-	if (!invocation.commandPath[0]) return false;
-	const route = findRoutedCommand(invocation.commandPath);
-	if (!route) return false;
-	await prepareRoutedCommand({
-		argv,
-		commandPath: invocation.commandPath,
-		loadPlugins: route.loadPlugins
-	});
-	return route.run(argv);
-}
-//#endregion
-//#region src/cli/run-main.ts
-async function closeCliMemoryManagers() {
-	if (!hasMemoryRuntime()) return;
-	try {
-		const { closeActiveMemorySearchManagers } = await import("./memory-runtime-B5t8GLq-.js");
-		await closeActiveMemorySearchManagers();
-	} catch {}
-}
-function rewriteUpdateFlagArgv(argv) {
-	const index = argv.indexOf("--update");
-	if (index === -1) return argv;
-	const next = [...argv];
-	next.splice(index, 1, "update");
-	return next;
-}
-function shouldEnsureCliPath(argv) {
-	const invocation = resolveCliArgvInvocation(argv);
-	if (invocation.hasHelpOrVersion) return false;
-	return shouldEnsureCliPathForCommandPath(invocation.commandPath);
-}
-function shouldUseRootHelpFastPath(argv) {
-	return resolveCliArgvInvocation(argv).isRootHelpInvocation;
-}
-function resolveMissingPluginCommandMessage(pluginId, config, options) {
-	const normalizedPluginId = normalizeLowercaseStringOrEmpty(pluginId);
-	if (!normalizedPluginId) return null;
-	const allow = Array.isArray(config?.plugins?.allow) && config.plugins.allow.length > 0 ? config.plugins.allow.filter((entry) => typeof entry === "string").map((entry) => normalizeOptionalLowercaseString(entry)).filter(Boolean) : [];
-	const commandAlias = resolveManifestCommandAliasOwner({
-		command: normalizedPluginId,
-		config,
-		registry: options?.registry
-	});
-	const parentPluginId = commandAlias?.pluginId;
-	if (parentPluginId) {
-		if (allow.length > 0 && !allow.includes(parentPluginId)) return `"${normalizedPluginId}" is not a plugin; it is a command provided by the "${parentPluginId}" plugin. Add "${parentPluginId}" to \`plugins.allow\` instead of "${normalizedPluginId}".`;
-		if (config?.plugins?.entries?.[parentPluginId]?.enabled === false) return `The \`genesis ${normalizedPluginId}\` command is unavailable because \`plugins.entries.${parentPluginId}.enabled=false\`. Re-enable that entry if you want the bundled plugin command surface.`;
-		if (commandAlias.kind === "runtime-slash") return `"${normalizedPluginId}" is a runtime slash command (/${normalizedPluginId}), not a CLI command. It is provided by the "${parentPluginId}" plugin. ${commandAlias.cliCommand ? `Use \`genesis ${commandAlias.cliCommand}\` for related CLI operations, or ` : "Use "}\`/${normalizedPluginId}\` in a chat session.`;
-	}
-	if (allow.length > 0 && !allow.includes(normalizedPluginId)) {
-		if (parentPluginId && allow.includes(parentPluginId)) return null;
-		return `The \`genesis ${normalizedPluginId}\` command is unavailable because \`plugins.allow\` excludes "${normalizedPluginId}". Add "${normalizedPluginId}" to \`plugins.allow\` if you want that bundled plugin CLI surface.`;
-	}
-	if (config?.plugins?.entries?.[normalizedPluginId]?.enabled === false) return `The \`genesis ${normalizedPluginId}\` command is unavailable because \`plugins.entries.${normalizedPluginId}.enabled=false\`. Re-enable that entry if you want the bundled plugin CLI surface.`;
-	return null;
-}
-function shouldLoadCliDotEnv(env = process$1.env) {
-	if (existsSync(path.join(process$1.cwd(), ".env"))) return true;
-	return existsSync(path.join(resolveStateDir(env), ".env"));
-}
-async function runCli(argv = process$1.argv) {
-	const originalArgv = normalizeWindowsArgv(argv);
-	const parsedContainer = parseCliContainerArgs(originalArgv);
-	if (!parsedContainer.ok) throw new Error(parsedContainer.error);
-	const parsedProfile = parseCliProfileArgs(parsedContainer.argv);
-	if (!parsedProfile.ok) throw new Error(parsedProfile.error);
-	if (parsedProfile.profile) applyCliProfileEnv({ profile: parsedProfile.profile });
-	if ((parsedContainer.container ?? normalizeOptionalString(process$1.env.GENESIS_CONTAINER) ?? null) && parsedProfile.profile) throw new Error("--container cannot be combined with --profile/--dev");
-	const containerTarget = maybeRunCliInContainer(originalArgv);
-	if (containerTarget.handled) {
-		if (containerTarget.exitCode !== 0) process$1.exitCode = containerTarget.exitCode;
-		return;
-	}
-	let normalizedArgv = parsedProfile.argv;
-	if (shouldLoadCliDotEnv()) {
-		const { loadCliDotEnv } = await import("./dotenv-BK-J20F9.js");
-		loadCliDotEnv({ quiet: true });
-	}
-	normalizeEnv();
-	initializeDebugProxyCapture("cli");
-	process$1.once("exit", () => {
-		finalizeDebugProxyCapture();
-	});
-	ensureGlobalUndiciEnvProxyDispatcher();
-	maybeWarnAboutDebugProxyCoverage();
-	if (shouldEnsureCliPath(normalizedArgv)) ensureGenesisCliOnPath();
-	assertSupportedRuntime();
-	try {
-		if (shouldUseRootHelpFastPath(normalizedArgv)) {
-			const { outputPrecomputedRootHelpText } = await import("./root-help-metadata-BUUHf8a6.js");
-			if (!outputPrecomputedRootHelpText()) {
-				const { outputRootHelp } = await import("./root-help-CtpK6G48.js");
-				await outputRootHelp();
-			}
-			return;
-		}
-		if (await tryRouteCli(normalizedArgv)) return;
-		enableConsoleCapture();
-		const [{ buildProgram }, { runFatalErrorHooks }, { installUnhandledRejectionHandler }, { restoreTerminalState }] = await Promise.all([
-			import("./program-Dfu5UhC1.js"),
-			import("./fatal-error-hooks-C54p3nG2.js"),
-			import("./unhandled-rejections-Cr4SP4Pl.js"),
-			import("./restore-Bq3mpjIz.js")
-		]);
-		const program = buildProgram();
-		installUnhandledRejectionHandler();
-		process$1.on("uncaughtException", (error) => {
-			console.error("[genesis] Uncaught exception:", formatUncaughtError(error));
-			for (const message of runFatalErrorHooks({
-				reason: "uncaught_exception",
-				error
-			})) console.error("[genesis]", message);
-			restoreTerminalState("uncaught exception", { resumeStdinIfPaused: false });
-			process$1.exit(1);
-		});
-		const parseArgv = rewriteUpdateFlagArgv(normalizedArgv);
-		const { primary } = resolveCliArgvInvocation(parseArgv);
-		if (primary && shouldRegisterPrimaryCommandOnly(parseArgv)) {
-			const { getProgramContext } = await import("./program-context-BqBOeoCP.js");
-			const ctx = getProgramContext(program);
-			if (ctx) {
-				const { registerCoreCliByName } = await import("./command-registry-BVFXhcOs.js");
-				await registerCoreCliByName(program, ctx, primary, parseArgv);
-			}
-			const { registerSubCliByName } = await import("./register.subclis-CQQMGIv7.js");
-			await registerSubCliByName(program, primary);
-		}
-		if (!shouldSkipPluginCommandRegistration({
-			argv: parseArgv,
-			primary,
-			hasBuiltinPrimary: primary !== null && program.commands.some((command) => command.name() === primary || command.aliases().includes(primary))
-		})) {
-			const { registerPluginCliCommandsFromValidatedConfig } = await import("./cli-DOiNFMc7.js");
-			const config = await registerPluginCliCommandsFromValidatedConfig(program, void 0, void 0, {
-				mode: "lazy",
-				primary
-			});
-			if (config) {
-				if (primary && !program.commands.some((command) => command.name() === primary || command.aliases().includes(primary))) {
-					const missingPluginCommandMessage = resolveMissingPluginCommandMessage(primary, config);
-					if (missingPluginCommandMessage) throw new Error(missingPluginCommandMessage);
-				}
-			}
-		}
-		try {
-			await program.parseAsync(parseArgv);
-		} catch (error) {
-			if (!(error instanceof CommanderError)) throw error;
-			process$1.exitCode = error.exitCode;
-		}
-	} finally {
-		await closeCliMemoryManagers();
-	}
-}
-//#endregion
-export { runCli };

package/dist/run-subagent-registry.runtime-DYsO0_RA.js

@@ -1,2 +0,0 @@
-import { l as listDescendantRunsForRequester, n as countActiveDescendantRuns } from "./subagent-registry-B1giKhqf.js";
-export { countActiveDescendantRuns, listDescendantRunsForRequester };

package/dist/run-wait-BMbf92lX.js

@@ -1,135 +0,0 @@
-import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
-import { r as callGateway } from "./call-DMoCOQgN.js";
-import { r as stripToolMessages, t as extractAssistantText } from "./chat-history-text-D0DcXXTa.js";
-let runWaitDeps = { callGateway };
-function normalizeAgentWaitResult(status, wait) {
-	return {
-		status,
-		error: typeof wait?.error === "string" ? wait.error : void 0,
-		startedAt: typeof wait?.startedAt === "number" ? wait.startedAt : void 0,
-		endedAt: typeof wait?.endedAt === "number" ? wait.endedAt : void 0
-	};
-}
-const RECOVERABLE_AGENT_WAIT_ERROR_PATTERNS = [
-	/gateway closed \(1006/i,
-	/transport close/i,
-	/connection loss/i,
-	/connection closed/i,
-	/gateway not connected/i,
-	/no active .* listener/i,
-	/socket hang up/i,
-	/\b(ECONNRESET|ECONNREFUSED|ETIMEDOUT|EPIPE|EHOSTUNREACH|ENETUNREACH)\b/i
-];
-function isRecoverableAgentWaitError(error) {
-	const message = error?.trim();
-	if (!message) return false;
-	if (message.includes("gateway timeout")) return false;
-	return RECOVERABLE_AGENT_WAIT_ERROR_PATTERNS.some((pattern) => pattern.test(message));
-}
-function normalizePendingRunIds(runIds) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const runId of runIds) {
-		const normalized = runId.trim();
-		if (!normalized || seen.has(normalized)) continue;
-		seen.add(normalized);
-	}
-	return [...seen];
-}
-function resolveLatestAssistantReplySnapshot(messages) {
-	for (let i = messages.length - 1; i >= 0; i -= 1) {
-		const candidate = messages[i];
-		if (!candidate || typeof candidate !== "object") continue;
-		if (candidate.role !== "assistant") continue;
-		const text = extractAssistantText(candidate);
-		if (!text?.trim()) continue;
-		let fingerprint;
-		try {
-			fingerprint = JSON.stringify(candidate);
-		} catch {
-			fingerprint = text;
-		}
-		return {
-			text,
-			fingerprint
-		};
-	}
-	return {};
-}
-async function readLatestAssistantReplySnapshot(params) {
-	const history = await (params.callGateway ?? runWaitDeps.callGateway)({
-		method: "chat.history",
-		params: {
-			sessionKey: params.sessionKey,
-			limit: params.limit ?? 50
-		}
-	});
-	return resolveLatestAssistantReplySnapshot(stripToolMessages(Array.isArray(history?.messages) ? history.messages : []));
-}
-async function readLatestAssistantReply(params) {
-	return (await readLatestAssistantReplySnapshot({
-		sessionKey: params.sessionKey,
-		limit: params.limit,
-		callGateway: params.callGateway
-	})).text;
-}
-async function waitForAgentRun(params) {
-	const timeoutMs = Math.max(1, Math.floor(params.timeoutMs));
-	try {
-		const wait = await (params.callGateway ?? runWaitDeps.callGateway)({
-			method: "agent.wait",
-			params: {
-				runId: params.runId,
-				timeoutMs
-			},
-			timeoutMs: timeoutMs + 2e3
-		});
-		if (wait?.status === "timeout") return normalizeAgentWaitResult("timeout", wait);
-		if (wait?.status === "pending") return normalizeAgentWaitResult("pending", wait);
-		if (wait?.status === "error") return normalizeAgentWaitResult("error", wait);
-		return normalizeAgentWaitResult("ok", wait);
-	} catch (err) {
-		const error = formatErrorMessage(err);
-		return {
-			status: error.includes("gateway timeout") ? "timeout" : "error",
-			error
-		};
-	}
-}
-async function waitForAgentRunAndReadUpdatedAssistantReply(params) {
-	const wait = await waitForAgentRun({
-		runId: params.runId,
-		timeoutMs: params.timeoutMs,
-		callGateway: params.callGateway
-	});
-	if (wait.status !== "ok") return wait;
-	const latestReply = await readLatestAssistantReplySnapshot({
-		sessionKey: params.sessionKey,
-		limit: params.limit,
-		callGateway: params.callGateway
-	});
-	const baselineFingerprint = params.baseline?.fingerprint;
-	return {
-		status: "ok",
-		replyText: latestReply.text && (!baselineFingerprint || latestReply.fingerprint !== baselineFingerprint) ? latestReply.text : void 0
-	};
-}
-async function waitForAgentRunsToDrain(params) {
-	const deadlineAtMs = params.deadlineAtMs ?? Date.now() + Math.max(1, Math.floor(params.timeoutMs ?? 0));
-	let pendingRunIds = new Set(normalizePendingRunIds(params.initialPendingRunIds ?? params.getPendingRunIds()));
-	while (pendingRunIds.size > 0 && Date.now() < deadlineAtMs) {
-		const remainingMs = Math.max(1, deadlineAtMs - Date.now());
-		await Promise.allSettled([...pendingRunIds].map((runId) => waitForAgentRun({
-			runId,
-			timeoutMs: remainingMs,
-			callGateway: params.callGateway
-		})));
-		pendingRunIds = new Set(normalizePendingRunIds(params.getPendingRunIds()));
-	}
-	return {
-		timedOut: pendingRunIds.size > 0,
-		pendingRunIds: [...pendingRunIds],
-		deadlineAtMs
-	};
-}
-//#endregion
-export { waitForAgentRunAndReadUpdatedAssistantReply as a, waitForAgentRun as i, readLatestAssistantReply as n, waitForAgentRunsToDrain as o, readLatestAssistantReplySnapshot as r, isRecoverableAgentWaitError as t };