remoteclaw 0.1.0-next.87fb2cd → 0.1.0-next.9f7caba

package/dist/agent-BA1XT2jG.js

@@ -0,0 +1,728 @@
+import { u as resolveGatewayPort } from "./paths-BTaH3rLn.js";
+import { _ as supportsXHighThinking, c as formatThinkingLevels, h as normalizeVerboseLevel, l as formatXHighModelHint, p as normalizeThinkLevel } from "./agent-helpers-DlqwUqOd.js";
+import { n as defaultRuntime } from "./runtime-Ds3E9SqF.js";
+import { c as normalizeMainKey, l as resolveAgentIdFromSessionKey, s as normalizeAgentId } from "./session-key-C2n-VILA.js";
+import { a as resolveAgentWorkspaceDir, c as resolveSessionAgentId, n as listAgentIds } from "./agent-scope-Dzc3Pxwr.js";
+import { i as normalizeModelRef, t as isCliProvider } from "./provider-utils-FaBmofiq.js";
+import { t as ensureAgentWorkspace } from "./workspace-DkGLVfOl.js";
+import { a as isInternalMessageChannel, c as normalizeMessageChannel, i as isGatewayMessageChannel, l as resolveMessageChannel, n as isDeliverableMessageChannel, t as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-DF4I2vOK.js";
+import { i as loadConfig } from "./config-BzYPJgWg.js";
+import { t as formatCliCommand } from "./command-format-DgXcqxBt.js";
+import { a as ensureAuthProfileStore } from "./auth-profiles-DJsaxEsz.js";
+import { r as normalizeChannelId, t as getChannelPlugin } from "./plugins-HyUNaoYP.js";
+import { C as resolveSendPolicy, a as getCliSessionId, c as resolveCliRuntimeArgs, f as resolveChannelMessageToolHints, h as applyVerboseOverride, i as resolveSessionDeliveryTarget, l as resolveCliRuntimeEnv, o as setCliSessionId, p as clearSessionAuthProfileOverride, r as resolveOutboundTarget, s as ChannelBridge, u as resolveCliRuntimeProvider } from "./targets-DzGG0A-J.js";
+import { l as resolveSessionFilePathOptions, m as resolveStorePath, u as resolveSessionTranscriptPath } from "./chat-envelope-CRqgofiw.js";
+import { B as resolveChannelResetConfig, F as resolveAndPersistSessionFile, H as resolveSessionResetType, J as resolveExplicitAgentSessionKey, M as parseSessionThreadInfo, R as resolveSessionKey, V as resolveSessionResetPolicy, h as normalizeAccountId, l as updateSessionStore, n as loadSessionStore, z as evaluateSessionFreshness } from "./store-DdUK8zTC.js";
+import { n as deriveSessionTotalTokens, r as hasNonzeroUsage } from "./usage-sF5tij7A.js";
+import { t as resolveGatewayCredentialsFromConfig } from "./credentials-C82aU5z-.js";
+import { a as emitAgentEvent, c as registerAgentRunContext, i as clearAgentRunContext, t as AGENT_LANE_NESTED } from "./lanes-DKkroN9D.js";
+import { n as resolveMessageChannelSelection } from "./channel-selection-CMK4YLlO.js";
+import { a as normalizeOutboundPayloadsForJson, i as normalizeOutboundPayloads, r as formatOutboundPayloadLog, t as deliverOutboundPayloads } from "./deliver-04fDIQb1.js";
+import crypto from "node:crypto";
+
+//#region src/cli/outbound-send-mapping.ts
+function createOutboundSendDepsFromCliSource(deps) {
+	return {
+		sendWhatsApp: deps.sendMessageWhatsApp,
+		sendTelegram: deps.sendMessageTelegram,
+		sendDiscord: deps.sendMessageDiscord,
+		sendSlack: deps.sendMessageSlack,
+		sendSignal: deps.sendMessageSignal,
+		sendIMessage: deps.sendMessageIMessage
+	};
+}
+
+//#endregion
+//#region src/cli/deps.ts
+function createDefaultDeps() {
+	return {
+		sendMessageWhatsApp: async (...args) => {
+			const { sendMessageWhatsApp } = await import("./web-Dbsn7rM8.js");
+			return await sendMessageWhatsApp(...args);
+		},
+		sendMessageTelegram: async (...args) => {
+			const { sendMessageTelegram } = await import("./send-YjzTu9Vf.js").then((n) => n.l);
+			return await sendMessageTelegram(...args);
+		},
+		sendMessageDiscord: async (...args) => {
+			const { sendMessageDiscord } = await import("./send-C2vPu8jr.js").then((n) => n.t);
+			return await sendMessageDiscord(...args);
+		},
+		sendMessageSlack: async (...args) => {
+			const { sendMessageSlack } = await import("./send-ysN09khs.js").then((n) => n.n);
+			return await sendMessageSlack(...args);
+		},
+		sendMessageSignal: async (...args) => {
+			const { sendMessageSignal } = await import("./send-BAki96aY.js").then((n) => n.i);
+			return await sendMessageSignal(...args);
+		},
+		sendMessageIMessage: async (...args) => {
+			const { sendMessageIMessage } = await import("./send-16QFH4iu.js").then((n) => n.n);
+			return await sendMessageIMessage(...args);
+		}
+	};
+}
+function createOutboundSendDeps$1(deps) {
+	return createOutboundSendDepsFromCliSource(deps);
+}
+
+//#endregion
+//#region src/cli/outbound-send-deps.ts
+function createOutboundSendDeps(deps) {
+	return createOutboundSendDepsFromCliSource(deps);
+}
+
+//#endregion
+//#region src/infra/outbound/agent-delivery.ts
+function resolveAgentDeliveryPlan(params) {
+	const requestedRaw = typeof params.requestedChannel === "string" ? params.requestedChannel.trim() : "";
+	const requestedChannel = (requestedRaw ? normalizeMessageChannel(requestedRaw) : void 0) || "last";
+	const explicitTo = typeof params.explicitTo === "string" && params.explicitTo.trim() ? params.explicitTo.trim() : void 0;
+	const normalizedTurnSource = params.turnSourceChannel ? normalizeMessageChannel(params.turnSourceChannel) : void 0;
+	const turnSourceChannel = normalizedTurnSource && isDeliverableMessageChannel(normalizedTurnSource) ? normalizedTurnSource : void 0;
+	const turnSourceTo = typeof params.turnSourceTo === "string" && params.turnSourceTo.trim() ? params.turnSourceTo.trim() : void 0;
+	const turnSourceAccountId = normalizeAccountId(params.turnSourceAccountId);
+	const turnSourceThreadId = params.turnSourceThreadId != null && params.turnSourceThreadId !== "" ? params.turnSourceThreadId : void 0;
+	const baseDelivery = resolveSessionDeliveryTarget({
+		entry: params.sessionEntry,
+		requestedChannel: requestedChannel === INTERNAL_MESSAGE_CHANNEL ? "last" : requestedChannel,
+		explicitTo,
+		explicitThreadId: params.explicitThreadId,
+		turnSourceChannel,
+		turnSourceTo,
+		turnSourceAccountId,
+		turnSourceThreadId
+	});
+	const resolvedChannel = (() => {
+		if (requestedChannel === INTERNAL_MESSAGE_CHANNEL) return INTERNAL_MESSAGE_CHANNEL;
+		if (requestedChannel === "last") {
+			if (baseDelivery.channel && baseDelivery.channel !== INTERNAL_MESSAGE_CHANNEL) return baseDelivery.channel;
+			return INTERNAL_MESSAGE_CHANNEL;
+		}
+		if (isGatewayMessageChannel(requestedChannel)) return requestedChannel;
+		if (baseDelivery.channel && baseDelivery.channel !== INTERNAL_MESSAGE_CHANNEL) return baseDelivery.channel;
+		return INTERNAL_MESSAGE_CHANNEL;
+	})();
+	const deliveryTargetMode = explicitTo ? "explicit" : isDeliverableMessageChannel(resolvedChannel) ? "implicit" : void 0;
+	const resolvedAccountId = normalizeAccountId(params.accountId) ?? (deliveryTargetMode === "implicit" ? baseDelivery.accountId : void 0);
+	let resolvedTo = explicitTo;
+	if (!resolvedTo && isDeliverableMessageChannel(resolvedChannel) && resolvedChannel === baseDelivery.lastChannel) resolvedTo = baseDelivery.lastTo;
+	return {
+		baseDelivery,
+		resolvedChannel,
+		resolvedTo,
+		resolvedAccountId,
+		resolvedThreadId: baseDelivery.threadId,
+		deliveryTargetMode
+	};
+}
+function resolveAgentOutboundTarget(params) {
+	const targetMode = params.targetMode ?? params.plan.deliveryTargetMode ?? (params.plan.resolvedTo ? "explicit" : "implicit");
+	if (!isDeliverableMessageChannel(params.plan.resolvedChannel)) return {
+		resolvedTarget: null,
+		resolvedTo: params.plan.resolvedTo,
+		targetMode
+	};
+	if (params.validateExplicitTarget !== true && params.plan.resolvedTo) return {
+		resolvedTarget: null,
+		resolvedTo: params.plan.resolvedTo,
+		targetMode
+	};
+	const resolvedTarget = resolveOutboundTarget({
+		channel: params.plan.resolvedChannel,
+		to: params.plan.resolvedTo,
+		cfg: params.cfg,
+		accountId: params.plan.resolvedAccountId,
+		mode: targetMode
+	});
+	return {
+		resolvedTarget,
+		resolvedTo: resolvedTarget.ok ? resolvedTarget.to : params.plan.resolvedTo,
+		targetMode
+	};
+}
+
+//#endregion
+//#region src/infra/outbound/envelope.ts
+const isOutboundPayloadJson = (payload) => "mediaUrl" in payload;
+function buildOutboundResultEnvelope(params) {
+	const hasPayloads = params.payloads !== void 0;
+	const payloads = params.payloads === void 0 ? void 0 : params.payloads.length === 0 ? [] : isOutboundPayloadJson(params.payloads[0]) ? [...params.payloads] : normalizeOutboundPayloadsForJson(params.payloads);
+	if (params.flattenDelivery !== false && params.delivery && !params.meta && !hasPayloads) return params.delivery;
+	return {
+		...hasPayloads ? { payloads } : {},
+		...params.meta ? { meta: params.meta } : {},
+		...params.delivery ? { delivery: params.delivery } : {}
+	};
+}
+
+//#endregion
+//#region src/commands/agent/delivery.ts
+const NESTED_LOG_PREFIX = "[agent:nested]";
+function formatNestedLogPrefix(opts) {
+	const parts = [NESTED_LOG_PREFIX];
+	const session = opts.sessionKey ?? opts.sessionId;
+	if (session) parts.push(`session=${session}`);
+	if (opts.runId) parts.push(`run=${opts.runId}`);
+	const channel = opts.messageChannel ?? opts.channel;
+	if (channel) parts.push(`channel=${channel}`);
+	if (opts.to) parts.push(`to=${opts.to}`);
+	if (opts.accountId) parts.push(`account=${opts.accountId}`);
+	return parts.join(" ");
+}
+function logNestedOutput(runtime, opts, output) {
+	const prefix = formatNestedLogPrefix(opts);
+	for (const line of output.split(/\r?\n/)) {
+		if (!line) continue;
+		runtime.log(`${prefix} ${line}`);
+	}
+}
+async function deliverAgentCommandResult(params) {
+	const { cfg, deps, runtime, opts, sessionEntry, payloads, result } = params;
+	const resultMeta = {
+		durationMs: result.run.durationMs,
+		aborted: result.run.aborted,
+		agentMeta: {
+			sessionId: result.run.sessionId,
+			usage: result.run.usage
+		}
+	};
+	const deliver = opts.deliver === true;
+	const bestEffortDeliver = opts.bestEffortDeliver === true;
+	const turnSourceChannel = opts.runContext?.messageChannel ?? opts.messageChannel;
+	const turnSourceTo = opts.runContext?.currentChannelId ?? opts.to;
+	const turnSourceAccountId = opts.runContext?.accountId ?? opts.accountId;
+	const turnSourceThreadId = opts.runContext?.currentThreadTs ?? opts.threadId;
+	const deliveryPlan = resolveAgentDeliveryPlan({
+		sessionEntry,
+		requestedChannel: opts.replyChannel ?? opts.channel,
+		explicitTo: opts.replyTo ?? opts.to,
+		explicitThreadId: opts.threadId,
+		accountId: opts.replyAccountId ?? opts.accountId,
+		wantsDelivery: deliver,
+		turnSourceChannel,
+		turnSourceTo,
+		turnSourceAccountId,
+		turnSourceThreadId
+	});
+	let deliveryChannel = deliveryPlan.resolvedChannel;
+	const explicitChannelHint = (opts.replyChannel ?? opts.channel)?.trim();
+	if (deliver && isInternalMessageChannel(deliveryChannel) && !explicitChannelHint) try {
+		deliveryChannel = (await resolveMessageChannelSelection({ cfg })).channel;
+	} catch {}
+	const effectiveDeliveryPlan = deliveryChannel === deliveryPlan.resolvedChannel ? deliveryPlan : {
+		...deliveryPlan,
+		resolvedChannel: deliveryChannel
+	};
+	const deliveryPlugin = !isInternalMessageChannel(deliveryChannel) ? getChannelPlugin(normalizeChannelId(deliveryChannel) ?? deliveryChannel) : void 0;
+	const isDeliveryChannelKnown = isInternalMessageChannel(deliveryChannel) || Boolean(deliveryPlugin);
+	const targetMode = opts.deliveryTargetMode ?? effectiveDeliveryPlan.deliveryTargetMode ?? (opts.to ? "explicit" : "implicit");
+	const resolvedAccountId = effectiveDeliveryPlan.resolvedAccountId;
+	const resolved = deliver && isDeliveryChannelKnown && deliveryChannel ? resolveAgentOutboundTarget({
+		cfg,
+		plan: effectiveDeliveryPlan,
+		targetMode,
+		validateExplicitTarget: true
+	}) : {
+		resolvedTarget: null,
+		resolvedTo: effectiveDeliveryPlan.resolvedTo,
+		targetMode
+	};
+	const resolvedTarget = resolved.resolvedTarget;
+	const deliveryTarget = resolved.resolvedTo;
+	const resolvedThreadId = deliveryPlan.resolvedThreadId ?? opts.threadId;
+	const resolvedReplyToId = deliveryChannel === "slack" && resolvedThreadId != null ? String(resolvedThreadId) : void 0;
+	const resolvedThreadTarget = deliveryChannel === "slack" ? void 0 : resolvedThreadId;
+	const logDeliveryError = (err) => {
+		const message = `Delivery failed (${deliveryChannel}${deliveryTarget ? ` to ${deliveryTarget}` : ""}): ${String(err)}`;
+		runtime.error?.(message);
+		if (!runtime.error) runtime.log(message);
+	};
+	if (deliver) {
+		if (isInternalMessageChannel(deliveryChannel)) {
+			const err = /* @__PURE__ */ new Error("delivery channel is required: pass --channel/--reply-channel or use a main session with a previous channel");
+			if (!bestEffortDeliver) throw err;
+			logDeliveryError(err);
+		} else if (!isDeliveryChannelKnown) {
+			const err = /* @__PURE__ */ new Error(`Unknown channel: ${deliveryChannel}`);
+			if (!bestEffortDeliver) throw err;
+			logDeliveryError(err);
+		} else if (resolvedTarget && !resolvedTarget.ok) {
+			if (!bestEffortDeliver) throw resolvedTarget.error;
+			logDeliveryError(resolvedTarget.error);
+		}
+	}
+	const normalizedPayloads = normalizeOutboundPayloadsForJson(payloads ?? []);
+	if (opts.json) {
+		runtime.log(JSON.stringify(buildOutboundResultEnvelope({
+			payloads: normalizedPayloads,
+			meta: resultMeta
+		}), null, 2));
+		if (!deliver) return {
+			payloads: normalizedPayloads,
+			meta: resultMeta
+		};
+	}
+	if (!payloads || payloads.length === 0) {
+		runtime.log("No reply from agent.");
+		return {
+			payloads: [],
+			meta: resultMeta
+		};
+	}
+	const deliveryPayloads = normalizeOutboundPayloads(payloads);
+	const logPayload = (payload) => {
+		if (opts.json) return;
+		const output = formatOutboundPayloadLog(payload);
+		if (!output) return;
+		if (opts.lane === AGENT_LANE_NESTED) {
+			logNestedOutput(runtime, opts, output);
+			return;
+		}
+		runtime.log(output);
+	};
+	if (!deliver) for (const payload of deliveryPayloads) logPayload(payload);
+	if (deliver && deliveryChannel && !isInternalMessageChannel(deliveryChannel)) {
+		if (deliveryTarget) {
+			const deliveryAgentId = opts.agentId ?? (opts.sessionKey ? resolveSessionAgentId({
+				sessionKey: opts.sessionKey,
+				config: cfg
+			}) : void 0);
+			await deliverOutboundPayloads({
+				cfg,
+				channel: deliveryChannel,
+				to: deliveryTarget,
+				accountId: resolvedAccountId,
+				payloads: deliveryPayloads,
+				agentId: deliveryAgentId,
+				replyToId: resolvedReplyToId ?? null,
+				threadId: resolvedThreadTarget ?? null,
+				bestEffort: bestEffortDeliver,
+				onError: (err) => logDeliveryError(err),
+				onPayload: logPayload,
+				deps: createOutboundSendDeps(deps)
+			});
+		}
+	}
+	return {
+		payloads: normalizedPayloads,
+		meta: resultMeta
+	};
+}
+
+//#endregion
+//#region src/commands/agent/run-context.ts
+function resolveAgentRunContext(opts) {
+	const merged = opts.runContext ? { ...opts.runContext } : {};
+	const normalizedChannel = resolveMessageChannel(merged.messageChannel ?? opts.messageChannel, opts.replyChannel ?? opts.channel);
+	if (normalizedChannel) merged.messageChannel = normalizedChannel;
+	const normalizedAccountId = normalizeAccountId(merged.accountId ?? opts.accountId);
+	if (normalizedAccountId) merged.accountId = normalizedAccountId;
+	const groupId = (merged.groupId ?? opts.groupId)?.toString().trim();
+	if (groupId) merged.groupId = groupId;
+	const groupChannel = (merged.groupChannel ?? opts.groupChannel)?.toString().trim();
+	if (groupChannel) merged.groupChannel = groupChannel;
+	const groupSpace = (merged.groupSpace ?? opts.groupSpace)?.toString().trim();
+	if (groupSpace) merged.groupSpace = groupSpace;
+	if (merged.currentThreadTs == null && opts.threadId != null && opts.threadId !== "" && opts.threadId !== null) merged.currentThreadTs = String(opts.threadId);
+	if (!merged.currentChannelId && opts.to) {
+		const trimmedTo = opts.to.trim();
+		if (trimmedTo) merged.currentChannelId = trimmedTo;
+	}
+	return merged;
+}
+
+//#endregion
+//#region src/commands/agent/session-store.ts
+async function updateSessionStoreAfterAgentRun(params) {
+	const { cfg, sessionId, sessionKey, storePath, sessionStore, defaultProvider, defaultModel, fallbackProvider, fallbackModel, result } = params;
+	const runUsage = result.run.usage;
+	const usage = runUsage ? {
+		input: runUsage.inputTokens,
+		output: runUsage.outputTokens,
+		cacheRead: runUsage.cacheReadTokens,
+		cacheWrite: runUsage.cacheWriteTokens
+	} : void 0;
+	const modelUsed = fallbackModel ?? defaultModel;
+	const providerUsed = fallbackProvider ?? defaultProvider;
+	const contextTokens = params.contextTokensOverride ?? 2e5;
+	const next = {
+		...sessionStore[sessionKey] ?? {
+			sessionId,
+			updatedAt: Date.now()
+		},
+		sessionId,
+		updatedAt: Date.now(),
+		contextTokens
+	};
+	next.modelProvider = providerUsed;
+	next.model = modelUsed;
+	if (isCliProvider(providerUsed, cfg)) {
+		const cliSessionId = result.run.sessionId?.trim();
+		if (cliSessionId) setCliSessionId(next, providerUsed, cliSessionId);
+	}
+	next.abortedLastRun = result.run.aborted ?? false;
+	if (hasNonzeroUsage(usage)) {
+		const input = usage.input ?? 0;
+		const output = usage.output ?? 0;
+		const totalTokens = deriveSessionTotalTokens({
+			usage,
+			contextTokens
+		}) ?? input;
+		next.inputTokens = input;
+		next.outputTokens = output;
+		next.totalTokens = totalTokens;
+		next.totalTokensFresh = true;
+		next.cacheRead = usage.cacheRead ?? 0;
+		next.cacheWrite = usage.cacheWrite ?? 0;
+	}
+	sessionStore[sessionKey] = next;
+	await updateSessionStore(storePath, (store) => {
+		store[sessionKey] = next;
+	});
+}
+
+//#endregion
+//#region src/commands/agent/session.ts
+function resolveSessionKeyForRequest(opts) {
+	const sessionCfg = opts.cfg.session;
+	const scope = sessionCfg?.scope ?? "per-sender";
+	const mainKey = normalizeMainKey(sessionCfg?.mainKey);
+	const explicitSessionKey = opts.sessionKey?.trim() || resolveExplicitAgentSessionKey({
+		cfg: opts.cfg,
+		agentId: opts.agentId
+	});
+	const storeAgentId = resolveAgentIdFromSessionKey(explicitSessionKey);
+	const storePath = resolveStorePath(sessionCfg?.store, { agentId: storeAgentId });
+	const sessionStore = loadSessionStore(storePath);
+	const ctx = opts.to?.trim() ? { From: opts.to } : void 0;
+	let sessionKey = explicitSessionKey ?? (ctx ? resolveSessionKey(scope, ctx, mainKey) : void 0);
+	if (!explicitSessionKey && opts.sessionId && (!sessionKey || sessionStore[sessionKey]?.sessionId !== opts.sessionId)) {
+		const foundKey = Object.keys(sessionStore).find((key) => sessionStore[key]?.sessionId === opts.sessionId);
+		if (foundKey) sessionKey = foundKey;
+	}
+	if (opts.sessionId && !explicitSessionKey && (!sessionKey || sessionStore[sessionKey]?.sessionId !== opts.sessionId)) {
+		const allAgentIds = listAgentIds(opts.cfg);
+		for (const agentId of allAgentIds) {
+			if (agentId === storeAgentId) continue;
+			const altStorePath = resolveStorePath(sessionCfg?.store, { agentId });
+			const altStore = loadSessionStore(altStorePath);
+			const foundKey = Object.keys(altStore).find((key) => altStore[key]?.sessionId === opts.sessionId);
+			if (foundKey) return {
+				sessionKey: foundKey,
+				sessionStore: altStore,
+				storePath: altStorePath
+			};
+		}
+	}
+	return {
+		sessionKey,
+		sessionStore,
+		storePath
+	};
+}
+function resolveSession(opts) {
+	const sessionCfg = opts.cfg.session;
+	const { sessionKey, sessionStore, storePath } = resolveSessionKeyForRequest({
+		cfg: opts.cfg,
+		to: opts.to,
+		sessionId: opts.sessionId,
+		sessionKey: opts.sessionKey,
+		agentId: opts.agentId
+	});
+	const now = Date.now();
+	const sessionEntry = sessionKey ? sessionStore[sessionKey] : void 0;
+	const resetPolicy = resolveSessionResetPolicy({
+		sessionCfg,
+		resetType: resolveSessionResetType({ sessionKey }),
+		resetOverride: resolveChannelResetConfig({
+			sessionCfg,
+			channel: sessionEntry?.lastChannel ?? sessionEntry?.channel
+		})
+	});
+	const fresh = sessionEntry ? evaluateSessionFreshness({
+		updatedAt: sessionEntry.updatedAt,
+		now,
+		policy: resetPolicy
+	}).fresh : false;
+	return {
+		sessionId: opts.sessionId?.trim() || (fresh ? sessionEntry?.sessionId : void 0) || crypto.randomUUID(),
+		sessionKey,
+		sessionEntry,
+		sessionStore,
+		storePath,
+		isNewSession: !fresh && !opts.sessionId,
+		persistedThinking: fresh && sessionEntry?.thinkingLevel ? normalizeThinkLevel(sessionEntry.thinkingLevel) : void 0,
+		persistedVerbose: fresh && sessionEntry?.verboseLevel ? normalizeVerboseLevel(sessionEntry.verboseLevel) : void 0
+	};
+}
+
+//#endregion
+//#region src/commands/agent.ts
+async function persistSessionEntry(params) {
+	params.sessionStore[params.sessionKey] = params.entry;
+	await updateSessionStore(params.storePath, (store) => {
+		store[params.sessionKey] = params.entry;
+	});
+}
+/**
+* Create a SessionMap-compatible adapter that bridges the agent command
+* session store to the ChannelBridge's SessionMap interface.
+*
+* `get()` returns the CLI session ID from the session entry.
+* `set()` is a no-op — session updates are handled by the caller after the run.
+*/
+function createSessionMapAdapter(params) {
+	return {
+		async get() {
+			return params.getSessionId();
+		},
+		async set() {},
+		async delete() {}
+	};
+}
+/** Resolve gateway URL from config for local gateway. */
+function resolveGatewayUrlFromConfig(cfg) {
+	return `ws://127.0.0.1:${resolveGatewayPort(cfg)}`;
+}
+/** Resolve gateway auth token from config. */
+function resolveGatewayTokenFromConfig(cfg) {
+	return resolveGatewayCredentialsFromConfig({
+		cfg,
+		env: process.env
+	}).token ?? "";
+}
+/** Build a ChannelMessage from the CLI command context. */
+function buildCliChannelMessage(params) {
+	return {
+		id: params.runId,
+		text: params.text,
+		from: params.accountId ?? "cli",
+		channelId: params.channelId ?? "",
+		provider: params.messageChannel ?? "cli",
+		timestamp: params.timestamp,
+		replyToId: params.threadId,
+		messageToolHints: params.messageToolHints?.length ? params.messageToolHints : void 0,
+		senderIsOwner: true
+	};
+}
+async function agentCommand(opts, runtime = defaultRuntime, deps = createDefaultDeps()) {
+	const body = (opts.message ?? "").trim();
+	if (!body) throw new Error("Message (--message) is required");
+	if (!opts.to && !opts.sessionId && !opts.sessionKey && !opts.agentId) throw new Error("Pass --to <E.164>, --session-id, or --agent to choose a session");
+	const cfg = loadConfig();
+	const agentIdOverrideRaw = opts.agentId?.trim();
+	const agentIdOverride = agentIdOverrideRaw ? normalizeAgentId(agentIdOverrideRaw) : void 0;
+	if (agentIdOverride) {
+		if (!listAgentIds(cfg).includes(agentIdOverride)) throw new Error(`Unknown agent id "${agentIdOverrideRaw}". Use "${formatCliCommand("remoteclaw agents list")}" to see configured agents.`);
+	}
+	if (agentIdOverride && opts.sessionKey) {
+		const sessionAgentId = resolveAgentIdFromSessionKey(opts.sessionKey);
+		if (sessionAgentId !== agentIdOverride) throw new Error(`Agent id "${agentIdOverrideRaw}" does not match session key agent "${sessionAgentId}".`);
+	}
+	const agentCfg = cfg.agents?.defaults;
+	const thinkingLevelsHint = formatThinkingLevels("unknown", "unknown");
+	const thinkOverride = normalizeThinkLevel(opts.thinking);
+	const thinkOnce = normalizeThinkLevel(opts.thinkingOnce);
+	if (opts.thinking && !thinkOverride) throw new Error(`Invalid thinking level. Use one of: ${thinkingLevelsHint}.`);
+	if (opts.thinkingOnce && !thinkOnce) throw new Error(`Invalid one-shot thinking level. Use one of: ${thinkingLevelsHint}.`);
+	const verboseOverride = normalizeVerboseLevel(opts.verbose);
+	if (opts.verbose && !verboseOverride) throw new Error("Invalid verbose level. Use \"on\", \"full\", or \"off\".");
+	if (opts.timeout !== void 0) {
+		const timeoutSecondsRaw = Number.parseInt(String(opts.timeout), 10);
+		if (Number.isNaN(timeoutSecondsRaw) || timeoutSecondsRaw < 0) throw new Error("--timeout must be a non-negative integer (seconds; 0 means no timeout)");
+	}
+	const { sessionId, sessionKey, sessionEntry: resolvedSessionEntry, sessionStore, storePath, isNewSession: _isNewSession, persistedThinking, persistedVerbose } = resolveSession({
+		cfg,
+		to: opts.to,
+		sessionId: opts.sessionId,
+		sessionKey: opts.sessionKey,
+		agentId: agentIdOverride
+	});
+	const sessionAgentId = agentIdOverride ?? resolveSessionAgentId({
+		sessionKey: sessionKey ?? opts.sessionKey?.trim(),
+		config: cfg
+	});
+	const workspaceDir = await ensureAgentWorkspace(resolveAgentWorkspaceDir(cfg, sessionAgentId));
+	let sessionEntry = resolvedSessionEntry;
+	const runId = opts.runId?.trim() || sessionId;
+	try {
+		if (opts.deliver === true) {
+			if (resolveSendPolicy({
+				cfg,
+				entry: sessionEntry,
+				sessionKey,
+				channel: sessionEntry?.channel,
+				chatType: sessionEntry?.chatType
+			}) === "deny") throw new Error("send blocked by session policy");
+		}
+		let resolvedThinkLevel = thinkOnce ?? thinkOverride ?? persistedThinking ?? agentCfg?.thinkingDefault;
+		const resolvedVerboseLevel = verboseOverride ?? persistedVerbose ?? agentCfg?.verboseDefault;
+		if (sessionKey) registerAgentRunContext(runId, {
+			sessionKey,
+			verboseLevel: resolvedVerboseLevel
+		});
+		if (sessionStore && sessionKey) {
+			const next = {
+				...sessionStore[sessionKey] ?? sessionEntry ?? {
+					sessionId,
+					updatedAt: Date.now()
+				},
+				sessionId,
+				updatedAt: Date.now()
+			};
+			if (thinkOverride) next.thinkingLevel = thinkOverride;
+			applyVerboseOverride(next, verboseOverride);
+			await persistSessionEntry({
+				sessionStore,
+				sessionKey,
+				storePath,
+				entry: next
+			});
+			sessionEntry = next;
+		}
+		const { provider: defaultProvider, model: defaultModel } = normalizeModelRef("unknown", "unknown");
+		let provider = defaultProvider;
+		let model = defaultModel;
+		const storedProviderOverride = sessionEntry?.providerOverride?.trim();
+		const storedModelOverride = sessionEntry?.modelOverride?.trim();
+		if (storedModelOverride) {
+			const normalizedStored = normalizeModelRef(storedProviderOverride || defaultProvider, storedModelOverride);
+			provider = normalizedStored.provider;
+			model = normalizedStored.model;
+		}
+		if (sessionEntry) {
+			const authProfileId = sessionEntry.authProfileOverride;
+			if (authProfileId) {
+				const entry = sessionEntry;
+				const profile = ensureAuthProfileStore().profiles[authProfileId];
+				if (!profile || profile.provider !== provider) {
+					if (sessionStore && sessionKey) await clearSessionAuthProfileOverride({
+						sessionEntry: entry,
+						sessionStore,
+						sessionKey,
+						storePath
+					});
+				}
+			}
+		}
+		if (!resolvedThinkLevel) resolvedThinkLevel = agentCfg?.thinkingDefault ?? void 0;
+		if (resolvedThinkLevel === "xhigh" && !supportsXHighThinking(provider, model)) {
+			if (Boolean(thinkOnce || thinkOverride)) throw new Error(`Thinking level "xhigh" is only supported for ${formatXHighModelHint()}.`);
+			resolvedThinkLevel = "high";
+			if (sessionEntry && sessionStore && sessionKey && sessionEntry.thinkingLevel === "xhigh") {
+				const entry = sessionEntry;
+				entry.thinkingLevel = "high";
+				entry.updatedAt = Date.now();
+				await persistSessionEntry({
+					sessionStore,
+					sessionKey,
+					storePath,
+					entry
+				});
+			}
+		}
+		const sessionPathOpts = resolveSessionFilePathOptions({
+			agentId: sessionAgentId,
+			storePath
+		});
+		if (sessionStore && sessionKey) {
+			const threadIdFromSessionKey = parseSessionThreadInfo(sessionKey).threadId;
+			const fallbackSessionFile = !sessionEntry?.sessionFile ? resolveSessionTranscriptPath(sessionId, sessionAgentId, opts.threadId ?? threadIdFromSessionKey) : void 0;
+			sessionEntry = (await resolveAndPersistSessionFile({
+				sessionId,
+				sessionKey,
+				sessionStore,
+				storePath,
+				sessionEntry,
+				agentId: sessionPathOpts?.agentId,
+				sessionsDir: sessionPathOpts?.sessionsDir,
+				fallbackSessionFile
+			})).sessionEntry;
+		}
+		const startedAt = Date.now();
+		let result;
+		const fallbackProvider = provider;
+		const fallbackModel = model;
+		try {
+			const runContext = resolveAgentRunContext(opts);
+			const messageChannel = resolveMessageChannel(runContext.messageChannel, opts.replyChannel ?? opts.channel);
+			const sessionMap = createSessionMapAdapter({ getSessionId: () => getCliSessionId(sessionEntry, provider) });
+			const bridge = new ChannelBridge({
+				provider: resolveCliRuntimeProvider(cfg),
+				sessionMap,
+				gatewayUrl: resolveGatewayUrlFromConfig(cfg),
+				gatewayToken: resolveGatewayTokenFromConfig(cfg),
+				workspaceDir,
+				runtimeArgs: resolveCliRuntimeArgs(cfg),
+				runtimeEnv: resolveCliRuntimeEnv(cfg)
+			});
+			const messageToolHints = resolveChannelMessageToolHints({
+				cfg,
+				channel: messageChannel,
+				accountId: runContext.accountId ?? opts.accountId
+			});
+			const message = buildCliChannelMessage({
+				runId,
+				text: body,
+				accountId: runContext.accountId ?? opts.accountId,
+				channelId: opts.to,
+				messageChannel,
+				threadId: opts.threadId != null ? String(opts.threadId) : void 0,
+				timestamp: Date.now(),
+				messageToolHints
+			});
+			result = await bridge.handle(message, void 0, opts.abortSignal);
+			emitAgentEvent({
+				runId,
+				stream: "lifecycle",
+				data: {
+					phase: "end",
+					startedAt,
+					endedAt: Date.now(),
+					aborted: result.run.aborted ?? false
+				}
+			});
+		} catch (err) {
+			emitAgentEvent({
+				runId,
+				stream: "lifecycle",
+				data: {
+					phase: "error",
+					startedAt,
+					endedAt: Date.now(),
+					error: String(err)
+				}
+			});
+			throw err;
+		}
+		if (sessionStore && sessionKey) await updateSessionStoreAfterAgentRun({
+			cfg,
+			contextTokensOverride: agentCfg?.contextTokens,
+			sessionId,
+			sessionKey,
+			storePath,
+			sessionStore,
+			defaultProvider: provider,
+			defaultModel: model,
+			fallbackProvider,
+			fallbackModel,
+			result
+		});
+		const payloads = result.payloads ?? [];
+		return await deliverAgentCommandResult({
+			cfg,
+			deps,
+			runtime,
+			opts,
+			sessionEntry,
+			result,
+			payloads
+		});
+	} finally {
+		clearAgentRunContext(runId);
+	}
+}
+
+//#endregion
+export { createOutboundSendDeps as a, resolveAgentOutboundTarget as i, resolveSessionKeyForRequest as n, createDefaultDeps as o, resolveAgentDeliveryPlan as r, createOutboundSendDeps$1 as s, agentCommand as t };