openclaw/dist/commands-system-prompt-LuWgMVey.mjs

Multi-channel AI gateway with extensible messaging integrations

import { t as createSubsystemLogger } from "./subsystem-4NzR43uz.mjs";
import { d as resolveAgentWorkspaceDir } from "./agent-scope-config-BEk6-ThS.mjs";
import { t as normalizeChatType } from "./chat-type-qwvaeaJu.mjs";
import { i as listRegisteredPluginAgentPromptGuidance } from "./command-registry-state-BXL4nUAg.mjs";
import { n as resolveSandboxRuntimeStatus } from "./runtime-status-BBzhhE6k.mjs";
import { t as prepareTtsPreferences } from "./tts-preferences-O074cDlX.mjs";
import { i as resolveNodeExecEligibility } from "./exec-defaults-aistZeP6.mjs";
import { n as createOpenClawCodingToolsAsync } from "./agent-tools-Bpi7xWYy.mjs";
import { t as isAcpRuntimeSpawnAvailable } from "./availability-DCCVp-oz.mjs";
import { n as resolveSessionSkillExecutionWorkspace } from "./workspace-skill-roots-CL28VeX5.mjs";
import { n as resolveRuntimeSkillsPrompt } from "./skills-prompt-B98c20Xe.mjs";
import { i as resolveBootstrapContextForRun, r as makeBootstrapWarn } from "./bootstrap-files-BVIOGOj-.mjs";
import { t as ensureSandboxWorkspaceForSession } from "./context-BwDVZiBb.mjs";
import "./sandbox-GCAKkjF5.mjs";
import { a as resolveAgentPromptSurfaceForSessionKey } from "./system-prompt-CIvDrwqR.mjs";
import { t as resolveAgentRuntimePrompt } from "./runtime-prompt-Y9Cg_C0f.mjs";
import { n as resolveEmbeddedFullAccessState } from "./sandbox-info-DK7KQSLQ.mjs";
import { t as buildConfiguredAgentSystemPrompt } from "./system-prompt-config-CfLRdkZp.mjs";
import { t as getRemoteSkillEligibility } from "./remote-BR-nu0nb.mjs";
import { t as resolveReusableWorkspaceSkillSnapshot } from "./session-snapshot-MxHdExzn.mjs";
import { t as resolveRuntimePolicySessionKey } from "./runtime-policy-session-key-BfYuB8uy.mjs";
//#region src/auto-reply/reply/commands-system-prompt.ts
const log = createSubsystemLogger("auto-reply/commands-system-prompt");
function resolveCommandSkillsEligibility(params) {
	const withRemote = (nodeSkills) => ({
		nodeSkills,
		remote: getRemoteSkillEligibility({ advertiseExecNode: nodeSkills.canExec })
	});
	try {
		return withRemote(resolveNodeExecEligibility({
			cfg: params.config,
			sessionEntry: params.sessionEntry,
			sessionKey: params.sessionKey,
			agentId: params.agentId
		}));
	} catch {
		try {
			return withRemote({ canExec: false });
		} catch {
			return { nodeSkills: { canExec: false } };
		}
	}
}
async function resolveCommandSkillsPrompt(params) {
	let skillsSnapshot;
	try {
		skillsSnapshot = (await resolveReusableWorkspaceSkillSnapshot({
			workspaceDir: resolveAgentWorkspaceDir(params.config, params.agentId),
			executionWorkspaceDir: params.executionWorkspaceDir,
			executionWorkspaceFileHost: params.executionWorkspaceFileHost,
			config: params.config,
			agentId: params.agentId,
			resolveEligibility: () => ({
				...params.eligibility,
				remote: getRemoteSkillEligibility({ advertiseExecNode: params.eligibility?.nodeSkills?.canExec ?? false })
			}),
			existingSnapshot: params.skillsSnapshot,
			skillFilter: params.skillsSnapshot?.skillFilter,
			skillOverrides: params.skillsSnapshot?.skillOverrides,
			watch: false
		})).snapshot;
	} catch {
		return "";
	}
	if (params.sandboxed) try {
		const sandboxWorkspace = await ensureSandboxWorkspaceForSession({
			skillsSnapshot,
			config: params.config,
			agentId: params.sandboxAgentId,
			sessionKey: params.sessionKey,
			workspaceDir: params.workspaceDir
		});
		if (!sandboxWorkspace) return "";
		if (sandboxWorkspace.containerWorkdir) {
			const { prompt } = await resolveRuntimeSkillsPrompt({
				sandbox: {
					enabled: true,
					containerWorkdir: sandboxWorkspace.containerWorkdir,
					skillsEligibility: sandboxWorkspace.skillsEligibility,
					skillsWorkspaceDir: sandboxWorkspace.skillsWorkspaceDir || void 0,
					skillUsagePaths: sandboxWorkspace.skillUsagePaths,
					workspaceAccess: sandboxWorkspace.workspaceAccess
				},
				skillsAnchorWorkspace: sandboxWorkspace.workspaceDir,
				skillsSnapshot,
				config: params.config,
				agentId: params.agentId
			});
			return prompt;
		}
	} catch {
		return "";
	}
	return skillsSnapshot.prompt;
}
async function resolveCommandsSystemPromptBundle(params) {
	const workspaceDir = params.workspaceDir;
	const targetSessionEntry = params.sessionStore?.[params.sessionKey] ?? params.sessionEntry;
	const sessionAgentId = params.agentId;
	const { bootstrapFiles, contextFiles: injectedFiles } = await resolveBootstrapContextForRun({
		workspaceDir,
		config: params.cfg,
		sessionKey: params.sessionKey,
		sessionId: targetSessionEntry?.sessionId,
		chatType: targetSessionEntry?.chatType,
		agentId: sessionAgentId,
		warn: makeBootstrapWarn({
			sessionLabel: params.sessionKey,
			workspaceDir,
			warn: (message) => log.warn(message)
		})
	});
	const toolPolicySessionKey = resolveRuntimePolicySessionKey({
		agentId: sessionAgentId,
		cfg: params.cfg,
		ctx: params.ctx,
		sessionKey: params.sessionKey
	});
	const sandboxRuntime = resolveSandboxRuntimeStatus({
		cfg: params.cfg,
		agentId: sessionAgentId,
		sessionKey: params.sessionKey,
		classificationSessionKey: toolPolicySessionKey
	});
	const skillsEligibility = resolveCommandSkillsEligibility({
		agentId: sessionAgentId,
		config: params.cfg,
		sessionEntry: targetSessionEntry,
		sessionKey: params.sessionKey
	});
	const skillsPrompt = await resolveCommandSkillsPrompt({
		agentId: sessionAgentId,
		config: params.cfg,
		eligibility: skillsEligibility,
		sandboxAgentId: sandboxRuntime.classificationAgentId,
		sandboxed: sandboxRuntime.sandboxed,
		sessionKey: toolPolicySessionKey,
		workspaceDir,
		...resolveSessionSkillExecutionWorkspace(targetSessionEntry?.worktree?.canonicalWorkspaceDir, workspaceDir),
		skillsSnapshot: targetSessionEntry?.skillsSnapshot
	});
	let tools;
	try {
		tools = await createOpenClawCodingToolsAsync({
			config: params.cfg,
			agentId: sessionAgentId,
			workspaceDir,
			sessionKey: toolPolicySessionKey,
			allowGatewaySubagentBinding: true,
			messageProvider: params.command.channel,
			groupId: targetSessionEntry?.groupId ?? void 0,
			groupChannel: targetSessionEntry?.groupChannel ?? void 0,
			groupSpace: targetSessionEntry?.space ?? void 0,
			spawnedBy: targetSessionEntry?.spawnedBy ?? void 0,
			senderId: params.command.senderId,
			senderName: params.ctx.SenderName,
			senderUsername: params.ctx.SenderUsername,
			senderE164: params.ctx.SenderE164,
			modelProvider: params.provider,
			modelId: params.model
		});
	} catch {
		tools = [];
	}
	const toolNames = tools.map((t) => t.name);
	const promptSurface = resolveAgentPromptSurfaceForSessionKey(params.sessionKey);
	const accountId = params.command.accountId ?? params.ctx.AccountId;
	const { runtimeInfo, userTimezone, userDate, reactionGuidance, messageToolHints } = await resolveAgentRuntimePrompt({
		config: params.cfg,
		agentId: sessionAgentId,
		workspaceDir,
		cwd: process.cwd(),
		sessionKey: params.sessionKey,
		sessionId: targetSessionEntry?.sessionId,
		model: `${params.provider}/${params.model}`,
		channel: params.command.channel,
		accountId,
		chatType: normalizeChatType(params.ctx.ChatType ?? targetSessionEntry?.chatType)
	});
	const fullAccessState = resolveEmbeddedFullAccessState({ execElevated: {
		enabled: params.elevated.enabled,
		allowed: params.elevated.allowed,
		defaultLevel: params.resolvedElevatedLevel ?? "off"
	} });
	const sandboxInfo = sandboxRuntime.sandboxed ? {
		enabled: true,
		workspaceDir,
		workspaceAccess: "rw",
		elevated: {
			allowed: params.elevated.allowed,
			defaultLevel: params.resolvedElevatedLevel ?? "off",
			fullAccessAvailable: fullAccessState.available,
			...fullAccessState.blockedReason ? { fullAccessBlockedReason: fullAccessState.blockedReason } : {}
		}
	} : { enabled: false };
	const { getPreparedModelCatalogOwnerSnapshot } = await import("./prepared-model-catalog-lJotEjrx.mjs");
	const preparedModelRuntime = getPreparedModelCatalogOwnerSnapshot({
		config: params.cfg,
		agentId: sessionAgentId,
		workspaceDir
	});
	return {
		systemPrompt: buildConfiguredAgentSystemPrompt({
			preparedTtsPreferences: params.opts?.preparedTtsPreferences ?? await prepareTtsPreferences(),
			config: params.cfg,
			preparedModelRuntime,
			agentId: sessionAgentId,
			workspaceDir,
			reasoningLevel: params.resolvedReasoningLevel,
			extraSystemPrompt: void 0,
			ownerNumbers: void 0,
			reasoningTagHint: false,
			toolNames,
			userTimezone,
			userDate,
			contextFiles: injectedFiles,
			skillsPrompt,
			acpEnabled: isAcpRuntimeSpawnAvailable({
				config: params.cfg,
				sandboxed: sandboxRuntime.sandboxed
			}),
			promptSurface,
			nativeCommandGuidanceLines: listRegisteredPluginAgentPromptGuidance({ surface: promptSurface }),
			reactionGuidance,
			messageToolHints,
			runtimeInfo,
			sandboxInfo
		}),
		tools,
		skillsPrompt,
		bootstrapFiles,
		injectedFiles,
		sandboxRuntime
	};
}
//#endregion
export { resolveCommandsSystemPromptBundle as t };