miladyai 2.0.0-alpha.27

package/dist/config/telegram-custom-commands.js

@@ -0,0 +1,76 @@
+//#region src/config/telegram-custom-commands.ts
+const TELEGRAM_COMMAND_NAME_PATTERN = /^[a-z0-9_]{1,32}$/;
+function normalizeTelegramCommandName(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return "";
+	return (trimmed.startsWith("/") ? trimmed.slice(1) : trimmed).trim().toLowerCase();
+}
+function normalizeTelegramCommandDescription(value) {
+	return value.trim();
+}
+function resolveTelegramCustomCommands(params) {
+	const entries = Array.isArray(params.commands) ? params.commands : [];
+	const reserved = params.reservedCommands ?? /* @__PURE__ */ new Set();
+	const checkReserved = params.checkReserved !== false;
+	const checkDuplicates = params.checkDuplicates !== false;
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	const issues = [];
+	for (let index = 0; index < entries.length; index += 1) {
+		const entry = entries[index];
+		const normalized = normalizeTelegramCommandName(String(entry?.command ?? ""));
+		if (!normalized) {
+			issues.push({
+				index,
+				field: "command",
+				message: "Telegram custom command is missing a command name."
+			});
+			continue;
+		}
+		if (!TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
+			issues.push({
+				index,
+				field: "command",
+				message: `Telegram custom command "/${normalized}" is invalid (use a-z, 0-9, underscore; max 32 chars).`
+			});
+			continue;
+		}
+		if (checkReserved && reserved.has(normalized)) {
+			issues.push({
+				index,
+				field: "command",
+				message: `Telegram custom command "/${normalized}" conflicts with a native command.`
+			});
+			continue;
+		}
+		if (checkDuplicates && seen.has(normalized)) {
+			issues.push({
+				index,
+				field: "command",
+				message: `Telegram custom command "/${normalized}" is duplicated.`
+			});
+			continue;
+		}
+		const description = normalizeTelegramCommandDescription(String(entry?.description ?? ""));
+		if (!description) {
+			issues.push({
+				index,
+				field: "description",
+				message: `Telegram custom command "/${normalized}" is missing a description.`
+			});
+			continue;
+		}
+		if (checkDuplicates) seen.add(normalized);
+		resolved.push({
+			command: normalized,
+			description
+		});
+	}
+	return {
+		commands: resolved,
+		issues
+	};
+}
+
+//#endregion
+export { normalizeTelegramCommandDescription, normalizeTelegramCommandName, resolveTelegramCustomCommands };

package/dist/config/zod-schema.agent-runtime.js

@@ -0,0 +1,519 @@
+import { parseDurationMs } from "../cli/parse-duration.js";
+import { BlockStreamingChunkSchema, BlockStreamingCoalesceSchema, CliBackendSchema, GroupChatSchema, HumanDelaySchema, IdentitySchema, ToolsLinksSchema, ToolsMediaSchema } from "./zod-schema.core.js";
+import { z } from "zod";
+
+//#region src/config/zod-schema.agent-runtime.ts
+const HeartbeatSchema = z.object({
+	every: z.string().optional(),
+	activeHours: z.object({
+		start: z.string().optional(),
+		end: z.string().optional(),
+		timezone: z.string().optional()
+	}).strict().optional(),
+	model: z.string().optional(),
+	session: z.string().optional(),
+	includeReasoning: z.boolean().optional(),
+	target: z.string().optional(),
+	to: z.string().optional(),
+	prompt: z.string().optional(),
+	ackMaxChars: z.number().int().nonnegative().optional()
+}).strict().superRefine((val, ctx) => {
+	if (!val.every) return;
+	try {
+		parseDurationMs(val.every, { defaultUnit: "m" });
+	} catch {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["every"],
+			message: "invalid duration (use ms, s, m, h)"
+		});
+	}
+	const active = val.activeHours;
+	if (!active) return;
+	const timePattern = /^([01]\d|2[0-3]|24):([0-5]\d)$/;
+	const validateTime = (raw, opts, path) => {
+		if (!raw) return;
+		if (!timePattern.test(raw)) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["activeHours", path],
+				message: "invalid time (use \"HH:MM\" 24h format)"
+			});
+			return;
+		}
+		const [hourStr, minuteStr] = raw.split(":");
+		const hour = Number(hourStr);
+		if (hour === 24 && Number(minuteStr) !== 0) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["activeHours", path],
+				message: "invalid time (24:00 is the only allowed 24:xx value)"
+			});
+			return;
+		}
+		if (hour === 24 && !opts.allow24) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["activeHours", path],
+			message: "invalid time (start cannot be 24:00)"
+		});
+	};
+	validateTime(active.start, { allow24: false }, "start");
+	validateTime(active.end, { allow24: true }, "end");
+}).optional();
+const SandboxDockerSchema = z.object({
+	image: z.string().optional(),
+	containerPrefix: z.string().optional(),
+	workdir: z.string().optional(),
+	readOnlyRoot: z.boolean().optional(),
+	tmpfs: z.array(z.string()).optional(),
+	network: z.string().optional(),
+	user: z.string().optional(),
+	capDrop: z.array(z.string()).optional(),
+	env: z.record(z.string(), z.string()).optional(),
+	setupCommand: z.string().optional(),
+	pidsLimit: z.number().int().positive().optional(),
+	memory: z.union([z.string(), z.number()]).optional(),
+	memorySwap: z.union([z.string(), z.number()]).optional(),
+	cpus: z.number().positive().optional(),
+	ulimits: z.record(z.string(), z.union([
+		z.string(),
+		z.number(),
+		z.object({
+			soft: z.number().int().nonnegative().optional(),
+			hard: z.number().int().nonnegative().optional()
+		}).strict()
+	])).optional(),
+	seccompProfile: z.string().optional(),
+	apparmorProfile: z.string().optional(),
+	dns: z.array(z.string()).optional(),
+	extraHosts: z.array(z.string()).optional(),
+	binds: z.array(z.string()).optional()
+}).strict().optional();
+const SandboxBrowserSchema = z.object({
+	enabled: z.boolean().optional(),
+	image: z.string().optional(),
+	containerPrefix: z.string().optional(),
+	cdpPort: z.number().int().positive().optional(),
+	vncPort: z.number().int().positive().optional(),
+	noVncPort: z.number().int().positive().optional(),
+	headless: z.boolean().optional(),
+	enableNoVnc: z.boolean().optional(),
+	allowHostControl: z.boolean().optional(),
+	autoStart: z.boolean().optional(),
+	autoStartTimeoutMs: z.number().int().positive().optional()
+}).strict().optional();
+const SandboxPruneSchema = z.object({
+	idleHours: z.number().int().nonnegative().optional(),
+	maxAgeDays: z.number().int().nonnegative().optional()
+}).strict().optional();
+const ToolPolicyBaseSchema = z.object({
+	allow: z.array(z.string()).optional(),
+	alsoAllow: z.array(z.string()).optional(),
+	deny: z.array(z.string()).optional()
+}).strict();
+const validateToolPolicyConflict = (scope, value, ctx) => {
+	if (value.allow && value.allow.length > 0 && value.alsoAllow && value.alsoAllow.length > 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `${scope} cannot set both allow and alsoAllow in the same scope (merge alsoAllow into allow, or remove allow and use profile + alsoAllow)`
+	});
+};
+const makeToolPolicySchema = (scope) => ToolPolicyBaseSchema.superRefine((value, ctx) => {
+	validateToolPolicyConflict(scope, value, ctx);
+});
+const ToolsWebSearchSchema = z.object({
+	enabled: z.boolean().optional(),
+	provider: z.union([z.literal("brave"), z.literal("perplexity")]).optional(),
+	apiKey: z.string().optional(),
+	maxResults: z.number().int().positive().optional(),
+	timeoutSeconds: z.number().int().positive().optional(),
+	cacheTtlMinutes: z.number().nonnegative().optional(),
+	perplexity: z.object({
+		apiKey: z.string().optional(),
+		baseUrl: z.string().optional(),
+		model: z.string().optional()
+	}).strict().optional()
+}).strict().optional();
+const ToolsWebFetchSchema = z.object({
+	enabled: z.boolean().optional(),
+	maxChars: z.number().int().positive().optional(),
+	maxCharsCap: z.number().int().positive().optional(),
+	timeoutSeconds: z.number().int().positive().optional(),
+	cacheTtlMinutes: z.number().nonnegative().optional(),
+	maxRedirects: z.number().int().nonnegative().optional(),
+	userAgent: z.string().optional()
+}).strict().optional();
+const ToolsWebSchema = z.object({
+	search: ToolsWebSearchSchema,
+	fetch: ToolsWebFetchSchema
+}).strict().optional();
+const ToolProfileSchema = z.union([
+	z.literal("minimal"),
+	z.literal("coding"),
+	z.literal("messaging"),
+	z.literal("full")
+]).optional();
+const ToolPolicySchema = makeToolPolicySchema("tools policy").optional();
+const ToolPolicyWithProfileSchema = makeToolPolicySchema("tools.byProvider policy").extend({ profile: ToolProfileSchema }).strict();
+const ElevatedAllowFromSchema = z.record(z.string(), z.array(z.union([z.string(), z.number()]))).optional();
+const AgentSandboxSchema = z.object({
+	mode: z.union([
+		z.literal("off"),
+		z.literal("non-main"),
+		z.literal("all")
+	]).optional(),
+	workspaceAccess: z.union([
+		z.literal("none"),
+		z.literal("ro"),
+		z.literal("rw")
+	]).optional(),
+	sessionToolsVisibility: z.union([z.literal("spawned"), z.literal("all")]).optional(),
+	scope: z.union([
+		z.literal("session"),
+		z.literal("agent"),
+		z.literal("shared")
+	]).optional(),
+	perSession: z.boolean().optional(),
+	workspaceRoot: z.string().optional(),
+	docker: SandboxDockerSchema,
+	browser: SandboxBrowserSchema,
+	prune: SandboxPruneSchema
+}).strict().optional();
+const AgentToolsSchema = z.object({
+	profile: ToolProfileSchema,
+	allow: z.array(z.string()).optional(),
+	alsoAllow: z.array(z.string()).optional(),
+	deny: z.array(z.string()).optional(),
+	byProvider: z.record(z.string(), ToolPolicyWithProfileSchema).optional(),
+	elevated: z.object({
+		enabled: z.boolean().optional(),
+		allowFrom: ElevatedAllowFromSchema
+	}).strict().optional(),
+	exec: z.object({
+		host: z.enum([
+			"sandbox",
+			"gateway",
+			"node"
+		]).optional(),
+		security: z.enum([
+			"deny",
+			"allowlist",
+			"full"
+		]).optional(),
+		ask: z.enum([
+			"off",
+			"on-miss",
+			"always"
+		]).optional(),
+		node: z.string().optional(),
+		pathPrepend: z.array(z.string()).optional(),
+		safeBins: z.array(z.string()).optional(),
+		backgroundMs: z.number().int().positive().optional(),
+		timeoutSec: z.number().int().positive().optional(),
+		approvalRunningNoticeMs: z.number().int().nonnegative().optional(),
+		cleanupMs: z.number().int().positive().optional(),
+		notifyOnExit: z.boolean().optional(),
+		applyPatch: z.object({
+			enabled: z.boolean().optional(),
+			allowModels: z.array(z.string()).optional()
+		}).strict().optional()
+	}).strict().optional(),
+	sandbox: z.object({ tools: ToolPolicySchema }).strict().optional()
+}).strict().superRefine((value, ctx) => {
+	validateToolPolicyConflict("agent tools", value, ctx);
+}).optional();
+const MemorySearchSchema = z.object({
+	enabled: z.boolean().optional(),
+	sources: z.array(z.union([z.literal("memory"), z.literal("sessions")])).optional(),
+	extraPaths: z.array(z.string()).optional(),
+	experimental: z.object({ sessionMemory: z.boolean().optional() }).strict().optional(),
+	provider: z.union([
+		z.literal("openai"),
+		z.literal("local"),
+		z.literal("gemini")
+	]).optional(),
+	remote: z.object({
+		baseUrl: z.string().optional(),
+		apiKey: z.string().optional(),
+		headers: z.record(z.string(), z.string()).optional(),
+		batch: z.object({
+			enabled: z.boolean().optional(),
+			wait: z.boolean().optional(),
+			concurrency: z.number().int().positive().optional(),
+			pollIntervalMs: z.number().int().nonnegative().optional(),
+			timeoutMinutes: z.number().int().positive().optional()
+		}).strict().optional()
+	}).strict().optional(),
+	fallback: z.union([
+		z.literal("openai"),
+		z.literal("gemini"),
+		z.literal("local"),
+		z.literal("none")
+	]).optional(),
+	model: z.string().optional(),
+	local: z.object({
+		modelPath: z.string().optional(),
+		modelCacheDir: z.string().optional()
+	}).strict().optional(),
+	store: z.object({
+		driver: z.literal("sqlite").optional(),
+		path: z.string().optional(),
+		vector: z.object({
+			enabled: z.boolean().optional(),
+			extensionPath: z.string().optional()
+		}).strict().optional()
+	}).strict().optional(),
+	chunking: z.object({
+		tokens: z.number().int().positive().optional(),
+		overlap: z.number().int().nonnegative().optional()
+	}).strict().optional(),
+	sync: z.object({
+		onSessionStart: z.boolean().optional(),
+		onSearch: z.boolean().optional(),
+		watch: z.boolean().optional(),
+		watchDebounceMs: z.number().int().nonnegative().optional(),
+		intervalMinutes: z.number().int().nonnegative().optional(),
+		sessions: z.object({
+			deltaBytes: z.number().int().nonnegative().optional(),
+			deltaMessages: z.number().int().nonnegative().optional()
+		}).strict().optional()
+	}).strict().optional(),
+	query: z.object({
+		maxResults: z.number().int().positive().optional(),
+		minScore: z.number().min(0).max(1).optional(),
+		hybrid: z.object({
+			enabled: z.boolean().optional(),
+			vectorWeight: z.number().min(0).max(1).optional(),
+			textWeight: z.number().min(0).max(1).optional(),
+			candidateMultiplier: z.number().int().positive().optional()
+		}).strict().optional()
+	}).strict().optional(),
+	cache: z.object({
+		enabled: z.boolean().optional(),
+		maxEntries: z.number().int().positive().optional()
+	}).strict().optional()
+}).strict().optional();
+const AgentModelSchema = z.union([z.string(), z.object({
+	primary: z.string().optional(),
+	fallbacks: z.array(z.string()).optional()
+}).strict()]);
+const AgentEntrySchema = z.object({
+	id: z.string(),
+	default: z.boolean().optional(),
+	name: z.string().optional(),
+	workspace: z.string().optional(),
+	agentDir: z.string().optional(),
+	model: AgentModelSchema.optional(),
+	skills: z.array(z.string()).optional(),
+	memorySearch: MemorySearchSchema,
+	humanDelay: HumanDelaySchema.optional(),
+	heartbeat: HeartbeatSchema,
+	identity: IdentitySchema,
+	groupChat: GroupChatSchema,
+	subagents: z.object({
+		allowAgents: z.array(z.string()).optional(),
+		model: z.union([z.string(), z.object({
+			primary: z.string().optional(),
+			fallbacks: z.array(z.string()).optional()
+		}).strict()]).optional(),
+		thinking: z.string().optional()
+	}).strict().optional(),
+	sandbox: AgentSandboxSchema,
+	tools: AgentToolsSchema
+}).strict();
+const ToolsSchema = z.object({
+	profile: ToolProfileSchema,
+	allow: z.array(z.string()).optional(),
+	alsoAllow: z.array(z.string()).optional(),
+	deny: z.array(z.string()).optional(),
+	byProvider: z.record(z.string(), ToolPolicyWithProfileSchema).optional(),
+	web: ToolsWebSchema,
+	media: ToolsMediaSchema,
+	links: ToolsLinksSchema,
+	message: z.object({
+		allowCrossContextSend: z.boolean().optional(),
+		crossContext: z.object({
+			allowWithinProvider: z.boolean().optional(),
+			allowAcrossProviders: z.boolean().optional(),
+			marker: z.object({
+				enabled: z.boolean().optional(),
+				prefix: z.string().optional(),
+				suffix: z.string().optional()
+			}).strict().optional()
+		}).strict().optional(),
+		broadcast: z.object({ enabled: z.boolean().optional() }).strict().optional()
+	}).strict().optional(),
+	agentToAgent: z.object({
+		enabled: z.boolean().optional(),
+		allow: z.array(z.string()).optional()
+	}).strict().optional(),
+	elevated: z.object({
+		enabled: z.boolean().optional(),
+		allowFrom: ElevatedAllowFromSchema
+	}).strict().optional(),
+	exec: z.object({
+		host: z.enum([
+			"sandbox",
+			"gateway",
+			"node"
+		]).optional(),
+		security: z.enum([
+			"deny",
+			"allowlist",
+			"full"
+		]).optional(),
+		ask: z.enum([
+			"off",
+			"on-miss",
+			"always"
+		]).optional(),
+		node: z.string().optional(),
+		pathPrepend: z.array(z.string()).optional(),
+		safeBins: z.array(z.string()).optional(),
+		backgroundMs: z.number().int().positive().optional(),
+		timeoutSec: z.number().int().positive().optional(),
+		cleanupMs: z.number().int().positive().optional(),
+		notifyOnExit: z.boolean().optional(),
+		applyPatch: z.object({
+			enabled: z.boolean().optional(),
+			allowModels: z.array(z.string()).optional()
+		}).strict().optional()
+	}).strict().optional(),
+	subagents: z.object({ tools: ToolPolicySchema }).strict().optional(),
+	sandbox: z.object({ tools: ToolPolicySchema }).strict().optional()
+}).strict().superRefine((value, ctx) => {
+	validateToolPolicyConflict("tools", value, ctx);
+}).optional();
+const AgentDefaultsSchema = z.object({
+	model: z.object({
+		primary: z.string().optional(),
+		fallbacks: z.array(z.string()).optional()
+	}).strict().optional(),
+	imageModel: z.object({
+		primary: z.string().optional(),
+		fallbacks: z.array(z.string()).optional()
+	}).strict().optional(),
+	models: z.record(z.string(), z.object({
+		alias: z.string().optional(),
+		params: z.record(z.string(), z.unknown()).optional()
+	}).strict()).optional(),
+	workspace: z.string().optional(),
+	adminEntityId: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "invalid UUID format").optional(),
+	repoRoot: z.string().optional(),
+	skipBootstrap: z.boolean().optional(),
+	bootstrapMaxChars: z.number().int().positive().optional(),
+	enableBootstrapProviders: z.boolean().optional(),
+	userTimezone: z.string().optional(),
+	timeFormat: z.union([
+		z.literal("auto"),
+		z.literal("12"),
+		z.literal("24")
+	]).optional(),
+	envelopeTimezone: z.string().optional(),
+	envelopeTimestamp: z.union([z.literal("on"), z.literal("off")]).optional(),
+	envelopeElapsed: z.union([z.literal("on"), z.literal("off")]).optional(),
+	contextTokens: z.number().int().positive().optional(),
+	cliBackends: z.record(z.string(), CliBackendSchema).optional(),
+	memorySearch: MemorySearchSchema,
+	contextPruning: z.object({
+		mode: z.union([z.literal("off"), z.literal("cache-ttl")]).optional(),
+		ttl: z.string().optional(),
+		keepLastAssistants: z.number().int().nonnegative().optional(),
+		softTrimRatio: z.number().min(0).max(1).optional(),
+		hardClearRatio: z.number().min(0).max(1).optional(),
+		minPrunableToolChars: z.number().int().nonnegative().optional(),
+		tools: z.object({
+			allow: z.array(z.string()).optional(),
+			deny: z.array(z.string()).optional()
+		}).strict().optional(),
+		softTrim: z.object({
+			maxChars: z.number().int().nonnegative().optional(),
+			headChars: z.number().int().nonnegative().optional(),
+			tailChars: z.number().int().nonnegative().optional()
+		}).strict().optional(),
+		hardClear: z.object({
+			enabled: z.boolean().optional(),
+			placeholder: z.string().optional()
+		}).strict().optional()
+	}).strict().optional(),
+	compaction: z.object({
+		mode: z.union([z.literal("default"), z.literal("safeguard")]).optional(),
+		reserveTokensFloor: z.number().int().nonnegative().optional(),
+		maxHistoryShare: z.number().min(.1).max(.9).optional(),
+		memoryFlush: z.object({
+			enabled: z.boolean().optional(),
+			softThresholdTokens: z.number().int().nonnegative().optional(),
+			prompt: z.string().optional(),
+			systemPrompt: z.string().optional()
+		}).strict().optional()
+	}).strict().optional(),
+	thinkingDefault: z.union([
+		z.literal("off"),
+		z.literal("minimal"),
+		z.literal("low"),
+		z.literal("medium"),
+		z.literal("high"),
+		z.literal("xhigh")
+	]).optional(),
+	verboseDefault: z.union([
+		z.literal("off"),
+		z.literal("on"),
+		z.literal("full")
+	]).optional(),
+	elevatedDefault: z.union([
+		z.literal("off"),
+		z.literal("on"),
+		z.literal("ask"),
+		z.literal("full")
+	]).optional(),
+	blockStreamingDefault: z.union([z.literal("off"), z.literal("on")]).optional(),
+	blockStreamingBreak: z.union([z.literal("text_end"), z.literal("message_end")]).optional(),
+	blockStreamingChunk: BlockStreamingChunkSchema.optional(),
+	blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+	humanDelay: HumanDelaySchema.optional(),
+	timeoutSeconds: z.number().int().positive().optional(),
+	mediaMaxMb: z.number().positive().optional(),
+	typingIntervalSeconds: z.number().int().positive().optional(),
+	typingMode: z.union([
+		z.literal("never"),
+		z.literal("instant"),
+		z.literal("thinking"),
+		z.literal("message")
+	]).optional(),
+	heartbeat: HeartbeatSchema,
+	maxConcurrent: z.number().int().positive().optional(),
+	subagents: z.object({
+		maxConcurrent: z.number().int().positive().optional(),
+		archiveAfterMinutes: z.number().int().positive().optional(),
+		model: z.union([z.string(), z.object({
+			primary: z.string().optional(),
+			fallbacks: z.array(z.string()).optional()
+		}).strict()]).optional(),
+		thinking: z.string().optional()
+	}).strict().optional(),
+	sandbox: z.object({
+		mode: z.union([
+			z.literal("off"),
+			z.literal("non-main"),
+			z.literal("all")
+		]).optional(),
+		workspaceAccess: z.union([
+			z.literal("none"),
+			z.literal("ro"),
+			z.literal("rw")
+		]).optional(),
+		sessionToolsVisibility: z.union([z.literal("spawned"), z.literal("all")]).optional(),
+		scope: z.union([
+			z.literal("session"),
+			z.literal("agent"),
+			z.literal("shared")
+		]).optional(),
+		perSession: z.boolean().optional(),
+		workspaceRoot: z.string().optional(),
+		docker: SandboxDockerSchema,
+		browser: SandboxBrowserSchema,
+		prune: SandboxPruneSchema
+	}).strict().optional()
+}).strict().optional();
+
+//#endregion
+export { AgentDefaultsSchema, AgentEntrySchema, ToolPolicySchema, ToolsSchema };