@pixelzx/genesis 2026.6.13-beta.3 → 2026.6.13

package/dist/wizard-models-CsM6dV5g.js

@@ -0,0 +1,334 @@
+import { f as readStringValue } from "./string-coerce-DPP_aYVc.js";
+import { n as defaultRuntime } from "./runtime-DDkDH9fa.js";
+import { u as readConfigFileSnapshot } from "./io-lNN4Levs.js";
+import { r as normalizeProviderId } from "./provider-id--dmcBtHB.js";
+import { v as resolveDefaultAgentWorkspaceDir } from "./workspace-CbdFyQfr.js";
+import { b as resolveAgentWorkspaceDir, x as resolveDefaultAgentId, y as resolveAgentDir } from "./agent-scope-Duyu_T59.js";
+import { r as replaceConfigFile } from "./mutate-CEhvH2fV.js";
+import "./config-DzozJ_v4.js";
+import { n as formatConfigIssueLines } from "./issue-format-CvKVSqgv.js";
+import { n as resolvePluginProviders } from "./providers.runtime-D_gk05Qq.js";
+import "./model-selection-Le6XU3cD.js";
+import { n as resolveProviderPluginChoice } from "./provider-wizard-D2EeMRlm.js";
+import { r as runProviderModelSelectedHook } from "./provider-auth-choice.runtime-CiyJMZgk.js";
+import { i as resolveProviderMatch, r as pickAuthMethod, t as applyDefaultModel } from "./provider-auth-choice-helpers-CfV81d-w.js";
+import { r as resolveManifestProviderAuthChoices } from "./provider-auth-choices-C2Y3hUbY.js";
+import { n as runProviderPluginAuthMethod } from "./provider-auth-choice-DrxMrqgL.js";
+import { t as invalidateModelAuthStatusCache } from "./models-auth-status-BKHvtTwP.js";
+//#region src/gateway/server-methods/wizard-models.ts
+function listProvidersWithAuthMethods(providers) {
+	return providers.filter((provider) => provider.auth.length > 0);
+}
+function sortProviderOptions(providers) {
+	return [...providers].toSorted((a, b) => {
+		const label = a.label.localeCompare(b.label);
+		return label === 0 ? a.id.localeCompare(b.id) : label;
+	});
+}
+function sortAuthMethods(methods) {
+	return [...methods].toSorted((a, b) => {
+		const label = a.label.localeCompare(b.label);
+		return label === 0 ? a.id.localeCompare(b.id) : label;
+	});
+}
+function formatInvalidConfigMessage(snapshot) {
+	const issues = formatConfigIssueLines(snapshot.issues ?? [], "-").join("\n");
+	return `Invalid config; fix it before running model provider setup.${issues ? `\n${issues}` : ""}`;
+}
+function includesTextInferenceScope(choice) {
+	return choice.onboardingScopes ? choice.onboardingScopes.includes("text-inference") : true;
+}
+function isVisibleChoice(choice) {
+	return choice.assistantVisibility !== "manual-only";
+}
+function resolveChoiceGroupId(choice) {
+	return choice.groupId ?? choice.providerId;
+}
+function resolveChoiceGroupLabel(choice) {
+	return choice.groupLabel ?? choice.choiceLabel;
+}
+function sortProviderAuthChoices(choices) {
+	return [...choices].toSorted((a, b) => {
+		const group = resolveChoiceGroupLabel(a).localeCompare(resolveChoiceGroupLabel(b));
+		if (group !== 0) return group;
+		const priorityA = a.assistantPriority ?? 0;
+		const priorityB = b.assistantPriority ?? 0;
+		if (priorityA !== priorityB) return priorityA - priorityB;
+		return a.choiceLabel.localeCompare(b.choiceLabel);
+	});
+}
+function matchesRequestedProviderChoice(params) {
+	const requestedProvider = params.requestedProvider?.trim();
+	if (requestedProvider) {
+		const normalizedRequestedProvider = normalizeProviderId(requestedProvider);
+		if (!(normalizeProviderId(params.choice.providerId) === normalizedRequestedProvider || normalizeProviderId(resolveChoiceGroupId(params.choice)) === normalizedRequestedProvider || normalizeProviderId(params.choice.pluginId) === normalizedRequestedProvider)) return false;
+	}
+	const requestedMethod = params.requestedMethod?.trim();
+	if (requestedMethod) {
+		const normalizedRequestedMethod = requestedMethod.toLowerCase();
+		if (!(params.choice.methodId.toLowerCase() === normalizedRequestedMethod || params.choice.choiceId.toLowerCase() === normalizedRequestedMethod)) return false;
+	}
+	return true;
+}
+async function selectManifestAuthChoice(params) {
+	const visibleChoices = sortProviderAuthChoices(params.choices.filter(isVisibleChoice));
+	const requestedChoices = visibleChoices.filter((choice) => matchesRequestedProviderChoice({
+		choice,
+		requestedProvider: params.requestedProvider,
+		requestedMethod: params.requestedMethod
+	}));
+	if (params.requestedProvider || params.requestedMethod) {
+		if (requestedChoices.length === 1 && requestedChoices[0]) return requestedChoices[0];
+		if (requestedChoices.length === 0) return null;
+	}
+	const choices = requestedChoices.length > 0 ? requestedChoices : visibleChoices;
+	const groups = /* @__PURE__ */ new Map();
+	for (const choice of choices) {
+		const id = resolveChoiceGroupId(choice);
+		const existing = groups.get(id);
+		if (existing) {
+			existing.choices.push(choice);
+			continue;
+		}
+		groups.set(id, {
+			id,
+			label: resolveChoiceGroupLabel(choice),
+			...choice.groupHint ? { hint: choice.groupHint } : {},
+			choices: [choice]
+		});
+	}
+	const sortedGroups = [...groups.values()].toSorted((a, b) => a.label.localeCompare(b.label));
+	if (sortedGroups.length === 0) return null;
+	const selectedGroupId = sortedGroups.length === 1 && sortedGroups[0] ? sortedGroups[0].id : await params.prompter.select({
+		message: "Select a model provider",
+		options: sortedGroups.map((group) => ({
+			value: group.id,
+			label: group.label,
+			hint: group.hint
+		})),
+		searchable: true
+	});
+	const group = sortedGroups.find((candidate) => candidate.id === selectedGroupId);
+	if (!group || group.choices.length === 0) throw new Error("Unknown provider selected.");
+	if (group.choices.length === 1 && group.choices[0]) return group.choices[0];
+	const selectedChoiceId = await params.prompter.select({
+		message: `${group.label} auth method`,
+		options: group.choices.map((choice) => ({
+			value: choice.choiceId,
+			label: choice.choiceLabel,
+			hint: choice.choiceHint
+		}))
+	});
+	const choice = group.choices.find((candidate) => candidate.choiceId === selectedChoiceId);
+	if (!choice) throw new Error("Unknown auth method selected.");
+	return choice;
+}
+async function selectProvider(params) {
+	const requested = params.requestedProvider?.trim();
+	if (requested) {
+		const matched = resolveProviderMatch(params.providers, requested);
+		if (!matched) {
+			const available = params.providers.map((provider) => provider.id).toSorted().join(", ");
+			throw new Error(`Unknown provider "${requested}". Available providers: ${available}`);
+		}
+		return matched;
+	}
+	const options = sortProviderOptions(params.providers).map((provider) => ({
+		value: provider.id,
+		label: provider.label,
+		hint: provider.docsPath ? `Docs: ${provider.docsPath}` : provider.auth[0]?.hint
+	}));
+	const selected = await params.prompter.select({
+		message: "Select a model provider",
+		options,
+		searchable: true
+	});
+	const matched = resolveProviderMatch(params.providers, selected);
+	if (!matched) throw new Error("Unknown provider selected.");
+	return matched;
+}
+async function selectAuthMethod(params) {
+	const requested = params.requestedMethod?.trim();
+	if (requested) {
+		const matched = pickAuthMethod(params.provider, requested);
+		if (!matched) {
+			const available = params.provider.auth.map((method) => method.id).toSorted().join(", ");
+			throw new Error(`Unknown auth method "${requested}" for provider "${params.provider.id}". Available methods: ${available}`);
+		}
+		return matched;
+	}
+	if (params.provider.auth.length === 1 && params.provider.auth[0]) return params.provider.auth[0];
+	const methods = sortAuthMethods(params.provider.auth);
+	const selected = await params.prompter.select({
+		message: `Auth method for ${params.provider.label}`,
+		options: methods.map((method) => ({
+			value: method.id,
+			label: method.label,
+			hint: method.hint
+		}))
+	});
+	const matched = pickAuthMethod(params.provider, selected);
+	if (!matched) throw new Error("Unknown auth method selected.");
+	return matched;
+}
+async function promptClientOpenUrl(prompter, url) {
+	await prompter.note(["Open this URL in your browser:", url].join("\n"), "Browser sign-in");
+}
+async function runManifestModelProviderWizard(params) {
+	const resolved = resolveProviderPluginChoice({
+		providers: listProvidersWithAuthMethods(resolvePluginProviders({
+			config: params.config,
+			workspaceDir: params.workspaceDir,
+			mode: "setup",
+			bundledProviderAllowlistCompat: true,
+			bundledProviderVitestCompat: true,
+			providerRefs: [params.choice.providerId],
+			activate: true,
+			includeUntrustedWorkspacePlugins: false
+		})),
+		choice: params.choice.choiceId
+	});
+	if (!resolved) throw new Error(`Unable to load provider setup for ${params.choice.choiceLabel}.`);
+	const applied = await runProviderPluginAuthMethod({
+		config: params.config,
+		env: process.env,
+		runtime: defaultRuntime,
+		prompter: params.prompter,
+		method: resolved.method,
+		agentDir: params.agentDir,
+		agentId: params.agentId,
+		workspaceDir: params.workspaceDir,
+		emitNotes: true,
+		allowSecretRefPrompt: false,
+		secretInputMode: "plaintext",
+		isRemote: false,
+		openUrl: async (url) => {
+			await promptClientOpenUrl(params.prompter, url);
+		},
+		opts: {}
+	});
+	let nextConfig = applied.config;
+	if (applied.profileCount === 0 && !applied.patched && !applied.defaultModel) await params.prompter.note("No provider credentials were stored.", "Provider setup skipped");
+	else if (applied.defaultModel) if ((typeof params.setDefault === "boolean" ? params.setDefault : void 0) ?? await params.prompter.confirm({
+		message: `Set ${applied.defaultModel} as the default model?`,
+		initialValue: true
+	})) {
+		nextConfig = applyDefaultModel(nextConfig, applied.defaultModel);
+		await runProviderModelSelectedHook({
+			config: nextConfig,
+			model: applied.defaultModel,
+			prompter: params.prompter,
+			agentDir: params.agentDir,
+			workspaceDir: params.workspaceDir,
+			env: process.env
+		});
+		await params.prompter.note(`Default model set to ${applied.defaultModel}`, "Model configured");
+	} else await params.prompter.note(`${applied.defaultModel} is available in the model picker.`, "Provider connected");
+	else await params.prompter.note(`${resolved.provider.label} is connected.`, "Provider connected");
+	return nextConfig;
+}
+async function runModelProviderWizard(params) {
+	if (!params.skipIntro) await params.prompter.intro("Model provider setup");
+	const snapshot = await readConfigFileSnapshot();
+	if (snapshot.exists && !snapshot.valid) throw new Error(formatInvalidConfigMessage(snapshot));
+	const config = structuredClone(snapshot.sourceConfig ?? snapshot.config ?? {});
+	const agentId = resolveDefaultAgentId(config);
+	const agentDir = resolveAgentDir(config, agentId);
+	const workspaceDir = resolveAgentWorkspaceDir(config, agentId) ?? resolveDefaultAgentWorkspaceDir();
+	const requestedProvider = readStringValue(params.provider);
+	const requestedMethod = readStringValue(params.authMethod);
+	const manifestChoice = await selectManifestAuthChoice({
+		choices: resolveManifestProviderAuthChoices({
+			config,
+			workspaceDir,
+			env: process.env,
+			includeUntrustedWorkspacePlugins: false
+		}).filter(includesTextInferenceScope),
+		requestedProvider,
+		requestedMethod,
+		prompter: params.prompter
+	});
+	if (manifestChoice) {
+		await replaceConfigFile({
+			nextConfig: await runManifestModelProviderWizard({
+				config,
+				choice: manifestChoice,
+				setDefault: params.setDefault,
+				prompter: params.prompter,
+				agentDir,
+				agentId,
+				workspaceDir
+			}),
+			...snapshot.hash !== void 0 ? { baseHash: snapshot.hash } : {}
+		});
+		invalidateModelAuthStatusCache();
+		await params.prompter.outro("Model provider setup complete.");
+		return;
+	}
+	const providers = listProvidersWithAuthMethods(resolvePluginProviders({
+		config,
+		workspaceDir,
+		mode: "setup",
+		bundledProviderAllowlistCompat: true,
+		bundledProviderVitestCompat: true,
+		...requestedProvider ? {
+			providerRefs: [requestedProvider],
+			activate: true
+		} : {}
+	}));
+	if (providers.length === 0) throw new Error("No model provider auth plugins are available.");
+	const provider = await selectProvider({
+		providers,
+		requestedProvider,
+		prompter: params.prompter
+	});
+	const method = await selectAuthMethod({
+		provider,
+		requestedMethod,
+		prompter: params.prompter
+	});
+	const applied = await runProviderPluginAuthMethod({
+		config,
+		env: process.env,
+		runtime: defaultRuntime,
+		prompter: params.prompter,
+		method,
+		agentDir,
+		agentId,
+		workspaceDir,
+		emitNotes: true,
+		allowSecretRefPrompt: false,
+		secretInputMode: "plaintext",
+		isRemote: false,
+		openUrl: async (url) => {
+			await promptClientOpenUrl(params.prompter, url);
+		},
+		opts: {}
+	});
+	let nextConfig = applied.config;
+	if (applied.profileCount === 0 && !applied.patched && !applied.defaultModel) await params.prompter.note("No provider credentials were stored.", "Provider setup skipped");
+	else if (applied.defaultModel) if ((typeof params.setDefault === "boolean" ? params.setDefault : void 0) ?? await params.prompter.confirm({
+		message: `Set ${applied.defaultModel} as the default model?`,
+		initialValue: true
+	})) {
+		nextConfig = applyDefaultModel(nextConfig, applied.defaultModel);
+		await runProviderModelSelectedHook({
+			config: nextConfig,
+			model: applied.defaultModel,
+			prompter: params.prompter,
+			agentDir,
+			workspaceDir,
+			env: process.env
+		});
+		await params.prompter.note(`Default model set to ${applied.defaultModel}`, "Model configured");
+	} else await params.prompter.note(`${applied.defaultModel} is available in the model picker.`, "Provider connected");
+	else await params.prompter.note(`${provider.label} is connected.`, "Provider connected");
+	await replaceConfigFile({
+		nextConfig,
+		...snapshot.hash !== void 0 ? { baseHash: snapshot.hash } : {}
+	});
+	invalidateModelAuthStatusCache();
+	await params.prompter.outro("Model provider setup complete.");
+}
+//#endregion
+export { runModelProviderWizard };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixelzx/genesis",
-  "version": "2026.6.13-beta.3",
+  "version": "2026.6.13",
   "description": "Multi-channel AI gateway with extensible messaging integrations",
   "keywords": [],
   "homepage": "https://github.com/PIXELZX0/Genesis#readme",

package/dist/abort-Cngo_sE6.js

@@ -1,201 +0,0 @@
-import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
-import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
-import { r as logVerbose } from "./globals-wYf9_gv5.js";
-import { s as parseAgentSessionKey } from "./session-key-utils-DDwuwYKT.js";
-import { p as resolveSessionAgentId } from "./agent-scope-Duyu_T59.js";
-import { u as resolveStorePath } from "./paths-CV1IubzZ.js";
-import { t as loadSessionStore } from "./store-load-TVGyCAt9.js";
-import { l as resolveSessionStoreEntry, o as updateSessionStore } from "./store-CqwPVMdE.js";
-import "./sessions-lhISK_V1.js";
-import { o as resolveInternalSessionKey, s as resolveMainSessionAlias } from "./sessions-helpers-qYgG99le.js";
-import { a as clearSessionQueues } from "./queue-Dmcs434b.js";
-import { h as replyRunRegistry, t as abortEmbeddedPiRun } from "./runs-o2XRtOL_.js";
-import { f as markSubagentRunTerminated, o as getLatestSubagentRunByChildSessionKey, u as listSubagentRunsForController } from "./subagent-registry-B7roWOkp.js";
-import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-iywT5nzF.js";
-import { o as stripMentions, s as stripStructuralPrefixes } from "./mentions-C-JNJVfc.js";
-import { t as resolveCommandAuthorization } from "./command-auth-C8YZ7xNT.js";
-import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-DKNuhGko.js";
-import { n as getAcpSessionManager } from "./manager-Cro57kFq.js";
-const abortDeps = {
-	getAcpSessionManager,
-	abortEmbeddedPiRun,
-	getLatestSubagentRunByChildSessionKey,
-	listSubagentRunsForController,
-	markSubagentRunTerminated
-};
-function formatAbortReplyText(stoppedSubagents) {
-	if (typeof stoppedSubagents !== "number" || stoppedSubagents <= 0) return "⚙️ Agent was aborted.";
-	return `⚙️ Agent was aborted. Stopped ${stoppedSubagents} ${stoppedSubagents === 1 ? "sub-agent" : "sub-agents"}.`;
-}
-function resolveSessionEntryForKey(store, sessionKey) {
-	if (!store || !sessionKey) return {};
-	const resolved = resolveSessionStoreEntry({
-		store,
-		sessionKey
-	});
-	if (resolved.existing) return resolved.legacyKeys.length > 0 ? {
-		entry: resolved.existing,
-		key: resolved.normalizedKey,
-		legacyKeys: resolved.legacyKeys
-	} : {
-		entry: resolved.existing,
-		key: resolved.normalizedKey
-	};
-	return {};
-}
-function normalizeRequesterSessionKey(cfg, key) {
-	const cleaned = normalizeOptionalString(key);
-	if (!cleaned) return;
-	const { mainKey, alias } = resolveMainSessionAlias(cfg);
-	return resolveInternalSessionKey({
-		key: cleaned,
-		alias,
-		mainKey
-	});
-}
-function stopSubagentsForRequester(params) {
-	const requesterKey = normalizeRequesterSessionKey(params.cfg, params.requesterSessionKey);
-	if (!requesterKey) return { stopped: 0 };
-	const dedupedRunsByChildKey = /* @__PURE__ */ new Map();
-	for (const run of abortDeps.listSubagentRunsForController(requesterKey)) {
-		const childKey = normalizeOptionalString(run.childSessionKey);
-		if (!childKey) continue;
-		const latest = abortDeps.getLatestSubagentRunByChildSessionKey(childKey);
-		if (!latest) {
-			const existing = dedupedRunsByChildKey.get(childKey);
-			if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
-			continue;
-		}
-		const latestControllerSessionKey = normalizeOptionalString(latest?.controllerSessionKey) ?? normalizeOptionalString(latest?.requesterSessionKey);
-		if (latest.runId !== run.runId || latestControllerSessionKey !== requesterKey) continue;
-		const existing = dedupedRunsByChildKey.get(childKey);
-		if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
-	}
-	const runs = Array.from(dedupedRunsByChildKey.values());
-	if (runs.length === 0) return { stopped: 0 };
-	const storeCache = /* @__PURE__ */ new Map();
-	const seenChildKeys = /* @__PURE__ */ new Set();
-	let stopped = 0;
-	for (const run of runs) {
-		const childKey = normalizeOptionalString(run.childSessionKey);
-		if (!childKey || seenChildKeys.has(childKey)) continue;
-		seenChildKeys.add(childKey);
-		if (!run.endedAt) {
-			const cleared = clearSessionQueues([childKey]);
-			const parsed = parseAgentSessionKey(childKey);
-			const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });
-			let store = storeCache.get(storePath);
-			if (!store) {
-				store = loadSessionStore(storePath);
-				storeCache.set(storePath, store);
-			}
-			const entry = store[childKey];
-			const sessionId = replyRunRegistry.resolveSessionId(childKey) ?? entry?.sessionId;
-			const aborted = (childKey ? replyRunRegistry.abort(childKey) : false) || (sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false);
-			if (abortDeps.markSubagentRunTerminated({
-				runId: run.runId,
-				childSessionKey: childKey,
-				reason: "killed"
-			}) > 0 || aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0) stopped += 1;
-		}
-		const cascadeResult = stopSubagentsForRequester({
-			cfg: params.cfg,
-			requesterSessionKey: childKey
-		});
-		stopped += cascadeResult.stopped;
-	}
-	if (stopped > 0) logVerbose(`abort: stopped ${stopped} subagent run(s) for ${requesterKey}`);
-	return { stopped };
-}
-async function tryFastAbortFromMessage(params) {
-	const { ctx, cfg } = params;
-	const targetKey = normalizeOptionalString(ctx.CommandTargetSessionKey) ?? normalizeOptionalString(ctx.SessionKey);
-	const raw = stripStructuralPrefixes(ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "");
-	if (!isAbortRequestText(normalizeOptionalLowercaseString(ctx.ChatType) === "group" ? stripMentions(raw, ctx, cfg, resolveSessionAgentId({
-		sessionKey: targetKey ?? ctx.SessionKey ?? "",
-		config: cfg
-	})) : raw)) return {
-		handled: false,
-		aborted: false
-	};
-	const commandAuthorized = ctx.CommandAuthorized;
-	const auth = resolveCommandAuthorization({
-		ctx,
-		cfg,
-		commandAuthorized
-	});
-	if (!auth.isAuthorizedSender) return {
-		handled: false,
-		aborted: false
-	};
-	const agentId = resolveSessionAgentId({
-		sessionKey: targetKey ?? ctx.SessionKey ?? "",
-		config: cfg
-	});
-	const abortKey = targetKey ?? auth.from ?? auth.to;
-	const requesterSessionKey = targetKey ?? ctx.SessionKey ?? abortKey;
-	if (targetKey) {
-		const storePath = resolveStorePath(cfg.session?.store, { agentId });
-		const store = loadSessionStore(storePath);
-		const { entry, key, legacyKeys } = resolveSessionEntryForKey(store, targetKey);
-		const resolvedTargetKey = key ?? targetKey;
-		const acpManager = abortDeps.getAcpSessionManager();
-		if (acpManager.resolveSession({
-			cfg,
-			sessionKey: resolvedTargetKey
-		}).kind !== "none") try {
-			await acpManager.cancelSession({
-				cfg,
-				sessionKey: resolvedTargetKey,
-				reason: "fast-abort"
-			});
-		} catch (error) {
-			logVerbose(`abort: ACP cancel failed for ${resolvedTargetKey}: ${formatErrorMessage(error)}`);
-		}
-		const sessionId = replyRunRegistry.resolveSessionId(resolvedTargetKey) ?? entry?.sessionId;
-		const aborted = replyRunRegistry.abort(resolvedTargetKey) || (sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false);
-		const cleared = clearSessionQueues([resolvedTargetKey, sessionId]);
-		if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`abort: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
-		const abortCutoff = shouldPersistAbortCutoff({
-			commandSessionKey: ctx.SessionKey,
-			targetSessionKey: resolvedTargetKey
-		}) ? resolveAbortCutoffFromContext(ctx) : void 0;
-		if (entry && key) {
-			entry.abortedLastRun = true;
-			applyAbortCutoffToSessionEntry(entry, abortCutoff);
-			entry.updatedAt = Date.now();
-			store[key] = entry;
-			for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete store[legacyKey];
-			await updateSessionStore(storePath, (nextStore) => {
-				const nextEntry = nextStore[key] ?? entry;
-				if (!nextEntry) return;
-				nextEntry.abortedLastRun = true;
-				applyAbortCutoffToSessionEntry(nextEntry, abortCutoff);
-				nextEntry.updatedAt = Date.now();
-				nextStore[key] = nextEntry;
-				for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete nextStore[legacyKey];
-			});
-		} else if (abortKey) setAbortMemory(abortKey, true);
-		const { stopped } = stopSubagentsForRequester({
-			cfg,
-			requesterSessionKey
-		});
-		return {
-			handled: true,
-			aborted,
-			stoppedSubagents: stopped
-		};
-	}
-	if (abortKey) setAbortMemory(abortKey, true);
-	const { stopped } = stopSubagentsForRequester({
-		cfg,
-		requesterSessionKey
-	});
-	return {
-		handled: true,
-		aborted: false,
-		stoppedSubagents: stopped
-	};
-}
-//#endregion
-export { tryFastAbortFromMessage as i, resolveSessionEntryForKey as n, stopSubagentsForRequester as r, formatAbortReplyText as t };

package/dist/abort.runtime-l03tKy6q.js

@@ -1,2 +0,0 @@
-import { i as tryFastAbortFromMessage, t as formatAbortReplyText } from "./abort-Cngo_sE6.js";
-export { formatAbortReplyText, tryFastAbortFromMessage };

package/dist/accounts-D5dnjCYz.js

@@ -1,104 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
-import { l as normalizeResolvedSecretInputString, u as normalizeSecretInputString } from "./types.secrets-BbgGt42I.js";
-import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-CTXHUezn.js";
-import { t as resolveAccountEntry } from "./account-lookup-C8qPhTca.js";
-import "./text-runtime-CFgLIdKf.js";
-import { s as resolveMergedAccountConfig, t as createAccountListHelpers } from "./account-helpers-Cy1bqB4c.js";
-import { o as tryReadSecretFileSync } from "./secret-file-DeXm1iwT.js";
-import "./core-BbuI1nb2.js";
-import "./routing-CMekdi78.js";
-import "./secret-input-sz5hyJkX.js";
-//#region extensions/zalo/src/token.ts
-function readTokenFromFile(tokenFile) {
-	return tryReadSecretFileSync(tokenFile, "Zalo token file", { rejectSymlink: true }) ?? "";
-}
-function resolveZaloToken(config, accountId, options) {
-	const resolvedAccountId = normalizeAccountId(accountId ?? config?.defaultAccount);
-	const isDefaultAccount = resolvedAccountId === DEFAULT_ACCOUNT_ID;
-	const baseConfig = config;
-	const accountConfig = resolveAccountEntry(baseConfig?.accounts, normalizeAccountId(resolvedAccountId));
-	const accountHasBotToken = Boolean(accountConfig && Object.prototype.hasOwnProperty.call(accountConfig, "botToken"));
-	if (accountConfig && accountHasBotToken) {
-		const token = options?.allowUnresolvedSecretRef ? normalizeSecretInputString(accountConfig.botToken) : normalizeResolvedSecretInputString({
-			value: accountConfig.botToken,
-			path: `channels.zalo.accounts.${resolvedAccountId}.botToken`
-		});
-		if (token) return {
-			token,
-			source: "config"
-		};
-		const fileToken = readTokenFromFile(accountConfig.tokenFile);
-		if (fileToken) return {
-			token: fileToken,
-			source: "configFile"
-		};
-	}
-	if (!accountHasBotToken) {
-		const fileToken = readTokenFromFile(accountConfig?.tokenFile);
-		if (fileToken) return {
-			token: fileToken,
-			source: "configFile"
-		};
-	}
-	if (!accountHasBotToken) {
-		const token = options?.allowUnresolvedSecretRef ? normalizeSecretInputString(baseConfig?.botToken) : normalizeResolvedSecretInputString({
-			value: baseConfig?.botToken,
-			path: "channels.zalo.botToken"
-		});
-		if (token) return {
-			token,
-			source: "config"
-		};
-		const fileToken = readTokenFromFile(baseConfig?.tokenFile);
-		if (fileToken) return {
-			token: fileToken,
-			source: "configFile"
-		};
-	}
-	if (isDefaultAccount) {
-		const envToken = process.env.ZALO_BOT_TOKEN?.trim();
-		if (envToken) return {
-			token: envToken,
-			source: "env"
-		};
-	}
-	return {
-		token: "",
-		source: "none"
-	};
-}
-//#endregion
-//#region extensions/zalo/src/accounts.ts
-const { listAccountIds: listZaloAccountIds, resolveDefaultAccountId: resolveDefaultZaloAccountId } = createAccountListHelpers("zalo");
-function mergeZaloAccountConfig(cfg, accountId) {
-	return resolveMergedAccountConfig({
-		channelConfig: cfg.channels?.zalo,
-		accounts: (cfg.channels?.zalo)?.accounts,
-		accountId,
-		omitKeys: ["defaultAccount"]
-	});
-}
-function resolveZaloAccount(params) {
-	const accountId = normalizeAccountId(params.accountId ?? (params.cfg.channels?.zalo)?.defaultAccount);
-	const baseEnabled = (params.cfg.channels?.zalo)?.enabled !== false;
-	const merged = mergeZaloAccountConfig(params.cfg, accountId);
-	const accountEnabled = merged.enabled !== false;
-	const enabled = baseEnabled && accountEnabled;
-	const tokenResolution = resolveZaloToken(params.cfg.channels?.zalo, accountId, { allowUnresolvedSecretRef: params.allowUnresolvedSecretRef });
-	return {
-		accountId,
-		name: normalizeOptionalString(merged.name),
-		enabled,
-		token: tokenResolution.token,
-		tokenSource: tokenResolution.source,
-		config: merged
-	};
-}
-function listEnabledZaloAccounts(cfg) {
-	return listZaloAccountIds(cfg).map((accountId) => resolveZaloAccount({
-		cfg,
-		accountId
-	})).filter((account) => account.enabled);
-}
-//#endregion
-export { resolveZaloToken as a, resolveZaloAccount as i, listZaloAccountIds as n, resolveDefaultZaloAccountId as r, listEnabledZaloAccounts as t };