openclaw 2026.4.29-beta.3 → 2026.4.29

package/dist/accounts-BPHX6IsZ.js

@@ -0,0 +1,107 @@
+import { n as normalizeAccountId$1, r as normalizeOptionalAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-vYgQddVH.js";
+import { t as resolveAccountEntry } from "./account-lookup-DREyAcJ_.js";
+import { o as tryReadSecretFileSync } from "./secret-file-D2xatmvM.js";
+import "./core-D416gENI.js";
+import "./account-resolution-DB9MxTRZ.js";
+//#region extensions/line/src/accounts.ts
+function readFileIfExists(filePath) {
+	return tryReadSecretFileSync(filePath, "LINE credential file", { rejectSymlink: true });
+}
+function resolveToken(params) {
+	const { accountId, baseConfig, accountConfig } = params;
+	if (accountConfig?.channelAccessToken?.trim()) return {
+		token: accountConfig.channelAccessToken.trim(),
+		tokenSource: "config"
+	};
+	const accountFileToken = readFileIfExists(accountConfig?.tokenFile);
+	if (accountFileToken) return {
+		token: accountFileToken,
+		tokenSource: "file"
+	};
+	if (accountId === "default") {
+		if (baseConfig?.channelAccessToken?.trim()) return {
+			token: baseConfig.channelAccessToken.trim(),
+			tokenSource: "config"
+		};
+		const baseFileToken = readFileIfExists(baseConfig?.tokenFile);
+		if (baseFileToken) return {
+			token: baseFileToken,
+			tokenSource: "file"
+		};
+		const envToken = process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim();
+		if (envToken) return {
+			token: envToken,
+			tokenSource: "env"
+		};
+	}
+	return {
+		token: "",
+		tokenSource: "none"
+	};
+}
+function resolveSecret(params) {
+	const { accountId, baseConfig, accountConfig } = params;
+	if (accountConfig?.channelSecret?.trim()) return accountConfig.channelSecret.trim();
+	const accountFileSecret = readFileIfExists(accountConfig?.secretFile);
+	if (accountFileSecret) return accountFileSecret;
+	if (accountId === "default") {
+		if (baseConfig?.channelSecret?.trim()) return baseConfig.channelSecret.trim();
+		const baseFileSecret = readFileIfExists(baseConfig?.secretFile);
+		if (baseFileSecret) return baseFileSecret;
+		const envSecret = process.env.LINE_CHANNEL_SECRET?.trim();
+		if (envSecret) return envSecret;
+	}
+	return "";
+}
+function resolveLineAccount(params) {
+	const cfg = params.cfg;
+	const accountId = normalizeAccountId$1(params.accountId ?? resolveDefaultLineAccountId(cfg));
+	const lineConfig = cfg.channels?.line;
+	const accounts = lineConfig?.accounts;
+	const accountConfig = accountId !== "default" ? resolveAccountEntry(accounts, accountId) : void 0;
+	const { token, tokenSource } = resolveToken({
+		accountId,
+		baseConfig: lineConfig,
+		accountConfig
+	});
+	const secret = resolveSecret({
+		accountId,
+		baseConfig: lineConfig,
+		accountConfig
+	});
+	const { accounts: _ignoredAccounts, defaultAccount: _ignoredDefaultAccount, ...lineBase } = lineConfig ?? {};
+	const mergedConfig = {
+		...lineBase,
+		...accountConfig
+	};
+	const enabled = accountConfig?.enabled ?? (accountId === "default" ? lineConfig?.enabled ?? true : false);
+	return {
+		accountId,
+		name: accountConfig?.name ?? (accountId === "default" ? lineConfig?.name : void 0),
+		enabled,
+		channelAccessToken: token,
+		channelSecret: secret,
+		tokenSource,
+		config: mergedConfig
+	};
+}
+function listLineAccountIds(cfg) {
+	const lineConfig = cfg.channels?.line;
+	const accounts = lineConfig?.accounts;
+	const ids = /* @__PURE__ */ new Set();
+	if (lineConfig?.channelAccessToken?.trim() || lineConfig?.tokenFile || process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim()) ids.add(DEFAULT_ACCOUNT_ID);
+	if (accounts) for (const id of Object.keys(accounts)) ids.add(id);
+	return Array.from(ids);
+}
+function resolveDefaultLineAccountId(cfg) {
+	const preferred = normalizeOptionalAccountId((cfg.channels?.line)?.defaultAccount);
+	if (preferred && listLineAccountIds(cfg).some((accountId) => normalizeAccountId$1(accountId) === preferred)) return preferred;
+	const ids = listLineAccountIds(cfg);
+	if (ids.includes("default")) return DEFAULT_ACCOUNT_ID;
+	return ids[0] ?? "default";
+}
+function normalizeAccountId(accountId) {
+	return normalizeAccountId$1(accountId);
+}
+//#endregion
+export { resolveLineAccount as i, normalizeAccountId as n, resolveDefaultLineAccountId as r, listLineAccountIds as t };

package/dist/accounts-DD0D9_wb.js

@@ -0,0 +1,104 @@
+import { c as normalizeOptionalString } from "./string-coerce-Bje8XVt9.js";
+import { l as normalizeResolvedSecretInputString, u as normalizeSecretInputString } from "./types.secrets-BHp0Y_k0.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-vYgQddVH.js";
+import { t as resolveAccountEntry } from "./account-lookup-DREyAcJ_.js";
+import "./text-runtime-ysqqY1vr.js";
+import { s as resolveMergedAccountConfig, t as createAccountListHelpers } from "./account-helpers-D258dZ17.js";
+import { o as tryReadSecretFileSync } from "./secret-file-D2xatmvM.js";
+import "./core-D416gENI.js";
+import "./routing-BpgWrRrP.js";
+import "./secret-input-BSzzh7Pu.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 };

package/dist/accounts-EiRBSJmP.js

@@ -0,0 +1,2 @@
+import { i as resolveZaloAccount } from "./accounts-DD0D9_wb.js";
+export { resolveZaloAccount };

package/dist/acp-runtime-backend-D_mt0yll.js

@@ -0,0 +1,52 @@
+import { c as normalizeOptionalString } from "./string-coerce-Bje8XVt9.js";
+import "./errors-B6Q4Zgyd.js";
+import "./registry-Bj09X5sS.js";
+//#region src/plugin-sdk/acp-runtime-backend.ts
+let dispatchAcpRuntimePromise = null;
+function loadDispatchAcpRuntime() {
+	dispatchAcpRuntimePromise ??= import("./dispatch-acp.runtime-C_N58Xn0.js");
+	return dispatchAcpRuntimePromise;
+}
+function hasExplicitCommandCandidate(ctx) {
+	if (normalizeOptionalString(ctx.CommandBody)) return true;
+	const normalized = normalizeOptionalString(ctx.BodyForCommands);
+	if (!normalized) return false;
+	return normalized.startsWith("!") || normalized.startsWith("/");
+}
+async function tryDispatchAcpReplyHook(event, ctx) {
+	if (event.sendPolicy === "deny" && !event.suppressUserDelivery && !hasExplicitCommandCandidate(event.ctx) && !event.isTailDispatch) return;
+	const runtime = await loadDispatchAcpRuntime();
+	const bypassForCommand = await runtime.shouldBypassAcpDispatchForCommand(event.ctx, ctx.cfg);
+	if (event.sendPolicy === "deny" && !event.suppressUserDelivery && !bypassForCommand && !event.isTailDispatch) return;
+	const result = await runtime.tryDispatchAcpReply({
+		ctx: event.ctx,
+		cfg: ctx.cfg,
+		dispatcher: ctx.dispatcher,
+		runId: event.runId,
+		sessionKey: event.sessionKey,
+		images: event.images,
+		abortSignal: ctx.abortSignal,
+		inboundAudio: event.inboundAudio,
+		sessionTtsAuto: event.sessionTtsAuto,
+		ttsChannel: event.ttsChannel,
+		suppressUserDelivery: event.suppressUserDelivery,
+		suppressReplyLifecycle: event.suppressReplyLifecycle === true || event.sendPolicy === "deny",
+		sourceReplyDeliveryMode: event.sourceReplyDeliveryMode,
+		shouldRouteToOriginating: event.shouldRouteToOriginating,
+		originatingChannel: event.originatingChannel,
+		originatingTo: event.originatingTo,
+		shouldSendToolSummaries: event.shouldSendToolSummaries,
+		bypassForCommand,
+		onReplyStart: ctx.onReplyStart,
+		recordProcessed: ctx.recordProcessed,
+		markIdle: ctx.markIdle
+	});
+	if (!result) return;
+	return {
+		handled: true,
+		queuedFinal: result.queuedFinal,
+		counts: result.counts
+	};
+}
+//#endregion
+export { tryDispatchAcpReplyHook as t };

package/dist/acp-stateful-target-driver-d2sDvA9f.js

@@ -0,0 +1,89 @@
+import { n as isAcpSessionKey } from "./session-key-utils-BKB1OWzs.js";
+import { u as resolveAgentIdFromSessionKey } from "./session-key-Bd0xquXF.js";
+import { n as readAcpSessionEntry } from "./session-meta-CwbItcDH.js";
+import { c as resolveConfiguredAcpBindingSpecFromRecord } from "./binding-registry-CTa0x_Oa.js";
+import { n as resolveConfiguredAcpBindingSpecBySessionKey } from "./persistent-bindings.resolve-BozEMG3f.js";
+import { n as ensureConfiguredAcpBindingSession, t as ensureConfiguredAcpBindingReady } from "./persistent-bindings.lifecycle-DcSWGgCd.js";
+import { a as performGatewaySessionReset } from "./session-reset-service-CRT9a2Ma.js";
+//#region src/channels/plugins/acp-stateful-target-driver.ts
+function toAcpStatefulBindingTargetDescriptor(params) {
+	const sessionKey = params.sessionKey.trim();
+	if (!sessionKey) return null;
+	const metaAgentId = (readAcpSessionEntry({
+		...params,
+		sessionKey
+	})?.acp)?.agent?.trim();
+	if (metaAgentId) return {
+		kind: "stateful",
+		driverId: "acp",
+		sessionKey,
+		agentId: metaAgentId
+	};
+	const spec = resolveConfiguredAcpBindingSpecBySessionKey({
+		...params,
+		sessionKey
+	});
+	if (!spec) {
+		if (!isAcpSessionKey(sessionKey)) return null;
+		return {
+			kind: "stateful",
+			driverId: "acp",
+			sessionKey,
+			agentId: resolveAgentIdFromSessionKey(sessionKey)
+		};
+	}
+	return {
+		kind: "stateful",
+		driverId: "acp",
+		sessionKey,
+		agentId: spec.agentId,
+		...spec.label ? { label: spec.label } : {}
+	};
+}
+async function ensureAcpTargetReady(params) {
+	const configuredBinding = resolveConfiguredAcpBindingSpecFromRecord(params.bindingResolution.record);
+	if (!configuredBinding) return {
+		ok: false,
+		error: "Configured ACP binding unavailable"
+	};
+	return await ensureConfiguredAcpBindingReady({
+		cfg: params.cfg,
+		configuredBinding: {
+			spec: configuredBinding,
+			record: params.bindingResolution.record
+		}
+	});
+}
+async function ensureAcpTargetSession(params) {
+	const spec = resolveConfiguredAcpBindingSpecFromRecord(params.bindingResolution.record);
+	if (!spec) return {
+		ok: false,
+		sessionKey: params.bindingResolution.statefulTarget.sessionKey,
+		error: "Configured ACP binding unavailable"
+	};
+	return await ensureConfiguredAcpBindingSession({
+		cfg: params.cfg,
+		spec
+	});
+}
+async function resetAcpTargetInPlace(params) {
+	const result = await performGatewaySessionReset({
+		key: params.sessionKey,
+		reason: params.reason,
+		commandSource: params.commandSource ?? "stateful-target:acp-reset-in-place"
+	});
+	if (result.ok) return { ok: true };
+	return {
+		ok: false,
+		error: result.error.message
+	};
+}
+const acpStatefulBindingTargetDriver = {
+	id: "acp",
+	ensureReady: ensureAcpTargetReady,
+	ensureSession: ensureAcpTargetSession,
+	resolveTargetBySessionKey: toAcpStatefulBindingTargetDescriptor,
+	resetInPlace: resetAcpTargetInPlace
+};
+//#endregion
+export { acpStatefulBindingTargetDriver };

package/dist/action-spawn-B36bMvuJ.js

@@ -0,0 +1,47 @@
+import { c as normalizeOptionalString } from "./string-coerce-Bje8XVt9.js";
+import { t as spawnSubagentDirect } from "./subagent-spawn-DCdBvLBu.js";
+import { u as stopWithText } from "./shared-Cwl_Orae.js";
+//#region src/auto-reply/reply/commands-subagents/action-spawn.ts
+async function handleSubagentsSpawnAction(ctx) {
+	const { params, requesterKey, restTokens } = ctx;
+	const requesterSessionEntry = params.sessionStore?.[requesterKey] ?? params.sessionEntry;
+	const agentId = restTokens[0];
+	const taskParts = [];
+	let model;
+	let thinking;
+	for (let i = 1; i < restTokens.length; i++) if (restTokens[i] === "--model" && i + 1 < restTokens.length) {
+		i += 1;
+		model = restTokens[i];
+	} else if (restTokens[i] === "--thinking" && i + 1 < restTokens.length) {
+		i += 1;
+		thinking = restTokens[i];
+	} else taskParts.push(restTokens[i]);
+	const task = taskParts.join(" ").trim();
+	if (!agentId || !task) return stopWithText("Usage: /subagents spawn <agentId> <task> [--model <model>] [--thinking <level>]");
+	const commandTo = normalizeOptionalString(params.command.to) ?? "";
+	const originatingTo = normalizeOptionalString(params.ctx.OriginatingTo) ?? "";
+	const fallbackTo = normalizeOptionalString(params.ctx.To) ?? "";
+	const normalizedTo = originatingTo || commandTo || fallbackTo || void 0;
+	const result = await spawnSubagentDirect({
+		task,
+		agentId,
+		model,
+		thinking,
+		mode: "run",
+		cleanup: "keep",
+		expectsCompletionMessage: true
+	}, {
+		agentSessionKey: requesterKey,
+		agentChannel: params.ctx.OriginatingChannel ?? params.command.channel,
+		agentAccountId: params.ctx.AccountId,
+		agentTo: normalizedTo,
+		agentThreadId: params.ctx.MessageThreadId,
+		agentGroupId: requesterSessionEntry?.groupId ?? null,
+		agentGroupChannel: requesterSessionEntry?.groupChannel ?? null,
+		agentGroupSpace: requesterSessionEntry?.space ?? null
+	});
+	if (result.status === "accepted") return stopWithText(`Spawned subagent ${agentId} (session ${result.childSessionKey}, run ${result.runId?.slice(0, 8)}).`);
+	return stopWithText(`Spawn failed: ${result.error ?? result.status}`);
+}
+//#endregion
+export { handleSubagentsSpawnAction };

package/dist/actions.runtime-BkpClqGK.js

@@ -0,0 +1,5 @@
+import { t as sendMessageZalo } from "./send-B-avOkP5.js";
+//#region extensions/zalo/src/actions.runtime.ts
+const zaloActionsRuntime = { sendMessageZalo };
+//#endregion
+export { zaloActionsRuntime };