opencode-tbot 0.1.0

package/dist/plugin.js

@@ -0,0 +1,4198 @@
+import { i as preparePluginConfiguration, s as loadAppConfig } from "./assets/plugin-config-Crgl_PZz.js";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { basename, dirname, extname } from "node:path";
+import { z } from "zod";
+import { OpenRouter } from "@openrouter/sdk";
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
+import { randomUUID } from "node:crypto";
+import { run } from "@grammyjs/runner";
+import { Bot, InlineKeyboard } from "grammy";
+//#region src/infra/utils/redact.ts
+var REDACTED = "[REDACTED]";
+var DEFAULT_PREVIEW_LENGTH = 160;
+var TELEGRAM_TOKEN_PATTERN = /\b\d{6,}:[A-Za-z0-9_-]{20,}\b/g;
+var BEARER_TOKEN_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/-]+=*\b/gi;
+var NAMED_SECRET_PATTERN = /\b(api[_\s-]?key|token|secret|password)\b(\s*[:=]\s*)([^\s,;]+)/gi;
+var API_KEY_LIKE_PATTERN = /\b(?:sk|pk)_[A-Za-z0-9_-]{10,}\b/g;
+function redactSensitiveText(input) {
+	return input.replace(BEARER_TOKEN_PATTERN, `Bearer ${REDACTED}`).replace(TELEGRAM_TOKEN_PATTERN, REDACTED).replace(NAMED_SECRET_PATTERN, (_, name, separator) => `${name}${separator}${REDACTED}`).replace(API_KEY_LIKE_PATTERN, REDACTED);
+}
+function createRedactedPreview(input, maxLength = DEFAULT_PREVIEW_LENGTH) {
+	const redacted = redactSensitiveText(input).replace(/\s+/g, " ").trim();
+	if (redacted.length <= maxLength) return redacted;
+	return `${redacted.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+//#endregion
+//#region src/infra/logger/index.ts
+var DEFAULT_SERVICE_NAME = "opencode-tbot";
+var LEVEL_PRIORITY = {
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40
+};
+function createOpenCodeAppLogger(client, options = {}) {
+	const service = normalizeServiceName(options.service);
+	const minimumLevel = normalizeLogLevel(options.level);
+	let queue = Promise.resolve();
+	const enqueue = (level, input, message) => {
+		if (LEVEL_PRIORITY[level] < LEVEL_PRIORITY[minimumLevel]) return;
+		const { extra, text } = normalizeLogArguments(input, message);
+		const payload = {
+			service,
+			level,
+			message: text,
+			...extra ? { extra } : {}
+		};
+		queue = queue.catch(() => void 0).then(async () => {
+			try {
+				await client.app.log(payload);
+			} catch {}
+		});
+	};
+	return {
+		debug(input, message) {
+			enqueue("debug", input, message);
+		},
+		info(input, message) {
+			enqueue("info", input, message);
+		},
+		warn(input, message) {
+			enqueue("warn", input, message);
+		},
+		error(input, message) {
+			enqueue("error", input, message);
+		},
+		async flush() {
+			await queue.catch(() => void 0);
+		}
+	};
+}
+function normalizeServiceName(value) {
+	const normalized = value?.trim();
+	return normalized && normalized.length > 0 ? normalized : DEFAULT_SERVICE_NAME;
+}
+function normalizeLogLevel(value) {
+	switch (value?.trim().toLowerCase()) {
+		case "debug": return "debug";
+		case "warn": return "warn";
+		case "error": return "error";
+		default: return "info";
+	}
+}
+function normalizeLogArguments(input, message) {
+	if (typeof input === "string") return { text: input };
+	if (message && message.trim().length > 0) {
+		const extra = serializeExtra(input);
+		return {
+			...extra ? { extra } : {},
+			text: message.trim()
+		};
+	}
+	if (input instanceof Error) return {
+		extra: serializeExtra(input) ?? void 0,
+		text: input.message.trim() || input.name
+	};
+	const extra = serializeExtra(input);
+	return {
+		...extra ? { extra } : {},
+		text: "log"
+	};
+}
+function serializeExtra(input) {
+	if (input === null || input === void 0) return null;
+	if (input instanceof Error) return { error: serializeError(input) };
+	if (Array.isArray(input)) return { items: input.map((item) => sanitizeValue(item)) };
+	if (typeof input !== "object") return { value: sanitizeValue(input) };
+	return sanitizeRecord(input);
+}
+function sanitizeRecord(record) {
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, isSensitiveKey(key) ? redactSensitiveFieldValue(value) : sanitizeValue(value)]));
+}
+function sanitizeValue(value) {
+	if (value instanceof Error) return serializeError(value);
+	if (Array.isArray(value)) return value.map((item) => sanitizeValue(item));
+	if (typeof value === "string") return redactSensitiveText(value);
+	if (!value || typeof value !== "object") return value;
+	return sanitizeRecord(value);
+}
+function serializeError(error) {
+	return {
+		name: error.name,
+		message: redactSensitiveText(error.message),
+		...error.stack ? { stack: redactSensitiveText(error.stack) } : {},
+		..."data" in error && error.data && typeof error.data === "object" ? { data: sanitizeValue(error.data) } : {}
+	};
+}
+function isSensitiveKey(key) {
+	return /token|secret|api[-_]?key|authorization|password/iu.test(key);
+}
+function redactSensitiveFieldValue(value) {
+	if (typeof value === "string" && value.trim().length > 0) return "[REDACTED]";
+	if (Array.isArray(value)) return value.map(() => "[REDACTED]");
+	if (value && typeof value === "object") return "[REDACTED]";
+	return value;
+}
+//#endregion
+//#region src/repositories/pending-action.repo.ts
+var FilePendingActionRepository = class {
+	constructor(store) {
+		this.store = store;
+	}
+	async getByChatId(chatId) {
+		return (await this.store.read()).pendingActions[String(chatId)] ?? null;
+	}
+	async set(action) {
+		await this.store.update((state) => {
+			state.pendingActions[String(action.chatId)] = action;
+		});
+	}
+	async clear(chatId) {
+		await this.store.update((state) => {
+			delete state.pendingActions[String(chatId)];
+		});
+	}
+};
+//#endregion
+//#region src/repositories/permission-approval.repo.ts
+function buildApprovalKey(requestId, chatId) {
+	return `${requestId}:${chatId}`;
+}
+var FilePermissionApprovalRepository = class {
+	constructor(store) {
+		this.store = store;
+	}
+	async listByRequestId(requestId) {
+		const state = await this.store.read();
+		return Object.values(state.pendingPermissions).filter((approval) => approval.requestId === requestId);
+	}
+	async set(approval) {
+		await this.store.update((state) => {
+			state.pendingPermissions[buildApprovalKey(approval.requestId, approval.chatId)] = approval;
+		});
+	}
+};
+//#endregion
+//#region src/repositories/session.repo.ts
+var FileSessionRepository = class {
+	constructor(store) {
+		this.store = store;
+	}
+	async getByChatId(chatId) {
+		return (await this.store.read()).sessions[String(chatId)] ?? null;
+	}
+	async listBySessionId(sessionId) {
+		const state = await this.store.read();
+		return Object.values(state.sessions).filter((binding) => binding.sessionId === sessionId);
+	}
+	async setCurrent(binding) {
+		await this.store.update((state) => {
+			state.sessions[String(binding.chatId)] = binding;
+		});
+	}
+	async touch(chatId) {
+		await this.store.update((state) => {
+			const current = state.sessions[String(chatId)];
+			if (!current) return;
+			state.sessions[String(chatId)] = {
+				...current,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		});
+	}
+};
+//#endregion
+//#region src/services/opencode/opencode.client.ts
+function buildOpenCodeSdkConfig(options) {
+	const apiKey = options.apiKey?.trim();
+	return {
+		baseUrl: options.baseUrl,
+		...apiKey ? { auth: apiKey } : {}
+	};
+}
+var EMPTY_RESPONSE_TEXT = "OpenCode returned empty response.";
+var STRUCTURED_REPLY_SCHEMA = {
+	type: "json_schema",
+	retryCount: 2,
+	schema: {
+		type: "object",
+		additionalProperties: false,
+		required: ["body_md"],
+		properties: { body_md: {
+			type: "string",
+			description: "Markdown body only. Do not include duration, token usage, or any footer. Do not wrap the whole answer in ```md or ```markdown fences. Use Markdown formatting directly unless the user explicitly asks for raw Markdown source."
+		} }
+	}
+};
+var SDK_OPTIONS = {
+	responseStyle: "data",
+	throwOnError: true
+};
+var StructuredReplySchema = z.object({ body_md: z.string() });
+var OpenCodeClient = class {
+	client;
+	fetchFn;
+	modelCache = {
+		expiresAt: 0,
+		promise: null,
+		value: null
+	};
+	constructor(options, client, fetchFn = fetch) {
+		if (!options && !client) throw new Error("OpenCodeClient requires either base URL options or an injected SDK client.");
+		this.client = client ?? createOpencodeClient(buildOpenCodeSdkConfig(options));
+		this.fetchFn = fetchFn;
+	}
+	async getHealth() {
+		return unwrapSdkData(await this.client.global.health(SDK_OPTIONS));
+	}
+	async abortSession(sessionId) {
+		return unwrapSdkData(await this.client.session.abort({ sessionID: sessionId }, SDK_OPTIONS));
+	}
+	async getPath() {
+		return unwrapSdkData(await this.client.path.get(void 0, SDK_OPTIONS));
+	}
+	async listLspStatuses(directory) {
+		return unwrapSdkData(await this.client.lsp.status(directory ? { directory } : void 0, SDK_OPTIONS));
+	}
+	async listMcpStatuses(directory) {
+		return unwrapSdkData(await this.client.mcp.status(directory ? { directory } : void 0, SDK_OPTIONS));
+	}
+	async getSessionStatuses() {
+		return unwrapSdkData(await this.client.session.status(void 0, SDK_OPTIONS));
+	}
+	async listProjects() {
+		return unwrapSdkData(await this.client.project.list(void 0, SDK_OPTIONS));
+	}
+	async listSessions() {
+		return unwrapSdkData(await this.client.session.list(void 0, SDK_OPTIONS));
+	}
+	async getCurrentProject() {
+		return unwrapSdkData(await this.client.project.current(void 0, SDK_OPTIONS));
+	}
+	async createSessionForDirectory(directory, title) {
+		return unwrapSdkData(await this.client.session.create(title ? {
+			directory,
+			title
+		} : { directory }, SDK_OPTIONS));
+	}
+	async renameSession(sessionId, title) {
+		return unwrapSdkData(await this.client.session.update({
+			sessionID: sessionId,
+			title
+		}, SDK_OPTIONS));
+	}
+	async listAgents() {
+		return unwrapSdkData(await this.client.app.agents(void 0, SDK_OPTIONS));
+	}
+	async listPendingPermissions(directory) {
+		return unwrapSdkData(await this.client.permission.list(directory ? { directory } : void 0, SDK_OPTIONS));
+	}
+	async replyToPermission(requestId, reply, message) {
+		return unwrapSdkData(await this.client.permission.reply({
+			requestID: requestId,
+			reply,
+			...message?.trim() ? { message: message.trim() } : {}
+		}, SDK_OPTIONS));
+	}
+	async listModels() {
+		const now = Date.now();
+		if (this.modelCache.value && this.modelCache.expiresAt > now) return this.modelCache.value;
+		if (this.modelCache.promise) return this.modelCache.promise;
+		const refreshPromise = this.loadModels().finally(() => {
+			if (this.modelCache.promise === refreshPromise) this.modelCache.promise = null;
+		});
+		this.modelCache.promise = refreshPromise;
+		return refreshPromise;
+	}
+	async promptSession(input) {
+		const startedAt = Date.now();
+		const promptText = input.prompt?.trim() ?? "";
+		const parts = [...promptText ? [{
+			type: "text",
+			text: promptText
+		}] : [], ...(input.files ?? []).map((file) => ({
+			type: "file",
+			filename: file.filename,
+			mime: file.mime,
+			url: file.url
+		}))];
+		if (parts.length === 0) throw new Error("Prompt requires text or file attachments.");
+		const data = unwrapSdkData(await this.client.session.prompt({
+			sessionID: input.sessionId,
+			...input.agent ? { agent: input.agent } : {},
+			...input.structured ? { format: STRUCTURED_REPLY_SCHEMA } : {},
+			...input.model ? { model: input.model } : {},
+			...input.variant ? { variant: input.variant } : {},
+			parts
+		}, SDK_OPTIONS));
+		const finishedAt = Date.now();
+		const bodyMd = input.structured ? extractStructuredMarkdown(data.info?.structured) : null;
+		const fallbackText = extractTextFromParts(data.parts) || bodyMd || EMPTY_RESPONSE_TEXT;
+		return {
+			assistantError: data.info?.error ?? null,
+			bodyMd,
+			fallbackText,
+			info: data.info ?? null,
+			metrics: extractPromptMetrics(data.info, startedAt, finishedAt),
+			parts: data.parts,
+			structured: data.info?.structured ?? null
+		};
+	}
+	async loadModels() {
+		const [configResponse, providersResponse] = await Promise.all([this.client.config.get(void 0, SDK_OPTIONS), this.client.config.providers(void 0, SDK_OPTIONS)]);
+		const config = unwrapSdkData(configResponse);
+		const providerCatalog = unwrapSdkData(providersResponse);
+		const providerAvailability = await resolveProviderAvailability(config, this.fetchFn);
+		const models = buildSelectableModels(config, providerCatalog.providers, providerAvailability);
+		this.modelCache = {
+			expiresAt: Date.now() + 6e4,
+			promise: null,
+			value: models
+		};
+		return models;
+	}
+};
+function createOpenCodeClientFromSdkClient(client, fetchFn = fetch) {
+	return new OpenCodeClient(void 0, client, fetchFn);
+}
+function buildSelectableModels(config, providers, providerAvailability = /* @__PURE__ */ new Map()) {
+	const configuredProviders = config.provider ?? {};
+	const providersById = new Map(providers.map((provider) => [provider.id, provider]));
+	const models = /* @__PURE__ */ new Map();
+	for (const [providerId, providerConfig] of Object.entries(configuredProviders)) {
+		const configuredModels = providerConfig.models ?? {};
+		for (const [configuredModelKey, modelConfig] of Object.entries(configuredModels)) {
+			const model = buildConfiguredModel(providerId, providerConfig, configuredModelKey, modelConfig, providersById.get(providerId), providerAvailability.get(providerId) ?? null);
+			if (model) models.set(model.qualifiedId, model);
+		}
+	}
+	for (const provider of providers) for (const model of buildCatalogProviderModels(provider, providerAvailability.get(provider.id) ?? null)) if (!models.has(model.qualifiedId)) models.set(model.qualifiedId, model);
+	return [...models.values()];
+}
+function buildConfiguredModel(providerId, providerConfig, configuredModelKey, modelConfig, providerCatalog, availableModelIds) {
+	const modelId = modelConfig.id ?? configuredModelKey;
+	const catalogModel = providerCatalog?.models[modelId];
+	if (!isTextModel(modelConfig, catalogModel)) return null;
+	if (!isModelAvailable(modelId, availableModelIds)) return null;
+	return {
+		id: modelId,
+		providerID: providerId,
+		providerName: resolveProviderDisplayName(providerId, providerConfig, providerCatalog),
+		name: modelConfig.name ?? catalogModel?.name ?? modelId,
+		qualifiedId: `${providerId}/${modelId}`,
+		reasoning: modelConfig.reasoning ?? catalogModel?.capabilities.reasoning ?? false,
+		variants: normalizeVariants(modelConfig.variants ?? catalogModel?.variants)
+	};
+}
+function buildCatalogProviderModels(provider, availableModelIds) {
+	return Object.values(provider.models).filter((model) => isCatalogTextModel(model) && isModelAvailable(model.id, availableModelIds)).map((model) => ({
+		id: model.id,
+		providerID: provider.id,
+		providerName: provider.name,
+		name: model.name,
+		qualifiedId: `${provider.id}/${model.id}`,
+		reasoning: model.capabilities.reasoning,
+		variants: normalizeVariants(model.variants)
+	}));
+}
+function isTextModel(modelConfig, catalogModel) {
+	if (modelConfig.modalities) return modelConfig.modalities.input.includes("text") && modelConfig.modalities.output.includes("text");
+	if (catalogModel) return catalogModel.capabilities.input.text && catalogModel.capabilities.output.text;
+	return true;
+}
+function isCatalogTextModel(catalogModel) {
+	return catalogModel.capabilities.input.text && catalogModel.capabilities.output.text;
+}
+function isModelAvailable(modelId, availableModelIds) {
+	return availableModelIds === null || availableModelIds.has(modelId);
+}
+function resolveProviderDisplayName(providerId, providerConfig, providerCatalog) {
+	if (providerConfig.name) return providerConfig.name;
+	const configuredBaseUrl = extractConfiguredBaseUrl(providerConfig);
+	if (configuredBaseUrl) {
+		const host = safeParseUrlHost(configuredBaseUrl);
+		const label = providerCatalog?.name ?? providerId;
+		return host ? `${label} (${host})` : label;
+	}
+	return providerCatalog?.name ?? providerId;
+}
+function extractConfiguredBaseUrl(providerConfig) {
+	const options = providerConfig.options;
+	if (!options || typeof options !== "object") return null;
+	const baseUrl = "baseURL" in options ? options.baseURL : null;
+	return typeof baseUrl === "string" && baseUrl.trim().length > 0 ? baseUrl.trim() : null;
+}
+function safeParseUrlHost(value) {
+	try {
+		return new URL(value).host || null;
+	} catch {
+		return null;
+	}
+}
+function normalizeVariants(variants) {
+	if (!variants) return {};
+	return Object.fromEntries(Object.entries(variants).filter(([, config]) => !config?.disabled).map(([variant, config]) => {
+		return [variant, Object.fromEntries(Object.entries(config).filter(([key]) => key !== "disabled"))];
+	}));
+}
+function extractTextFromParts(parts) {
+	return parts.filter((part) => part.type === "text").map((part) => part.text).join("").trim();
+}
+function extractStructuredMarkdown(structured) {
+	const parsed = StructuredReplySchema.safeParse(structured);
+	if (!parsed.success) return null;
+	const bodyMd = parsed.data.body_md.replace(/\r\n?/g, "\n").trim();
+	return bodyMd.length > 0 ? bodyMd : null;
+}
+function extractPromptMetrics(info, startedAt, finishedAt) {
+	const createdAt = typeof info?.time?.created === "number" && Number.isFinite(info.time.created) ? info.time.created : null;
+	const completedAt = typeof info?.time?.completed === "number" && Number.isFinite(info.time.completed) ? info.time.completed : null;
+	const completedDuration = createdAt !== null && completedAt !== null ? completedAt - createdAt : null;
+	return {
+		durationMs: completedDuration !== null && completedDuration >= 0 ? completedDuration : Math.max(0, finishedAt - startedAt),
+		tokens: extractTokenMetrics(info)
+	};
+}
+function extractTokenMetrics(info) {
+	if (!info?.tokens) return {
+		total: null,
+		input: null,
+		output: null,
+		reasoning: null,
+		cacheRead: null,
+		cacheWrite: null
+	};
+	const input = coerceFiniteNumber(info.tokens.input);
+	const output = coerceFiniteNumber(info.tokens.output);
+	const reasoning = coerceFiniteNumber(info.tokens.reasoning);
+	const cacheRead = coerceFiniteNumber(info.tokens.cache?.read);
+	const cacheWrite = coerceFiniteNumber(info.tokens.cache?.write);
+	const total = coerceFiniteNumber(info.tokens.total);
+	const fallbackTotal = sumTokenMetrics(input, output, cacheRead, cacheWrite);
+	return {
+		total: total ?? fallbackTotal,
+		input,
+		output,
+		reasoning,
+		cacheRead,
+		cacheWrite
+	};
+}
+function coerceFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function sumTokenMetrics(...values) {
+	if (values.every((value) => value === null)) return null;
+	const total = values.reduce((sum, value) => sum + (value ?? 0), 0);
+	return Number.isFinite(total) ? total : null;
+}
+function unwrapSdkData(response) {
+	if (response && typeof response === "object" && "data" in response) return response.data;
+	return response;
+}
+async function resolveProviderAvailability(config, fetchFn) {
+	const configuredProviders = Object.entries(config.provider ?? {});
+	const availabilityEntries = await Promise.all(configuredProviders.map(async ([providerId, providerConfig]) => [providerId, await fetchProviderAvailableModelIds(providerConfig, fetchFn)]));
+	return new Map(availabilityEntries);
+}
+async function fetchProviderAvailableModelIds(providerConfig, fetchFn) {
+	const baseUrl = extractConfiguredBaseUrl(providerConfig);
+	const apiKey = extractConfiguredApiKey(providerConfig);
+	if (!baseUrl || !apiKey) return null;
+	try {
+		const response = await fetchFn(buildModelsEndpointUrl(baseUrl), {
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				Accept: "application/json"
+			},
+			signal: AbortSignal.timeout(1e4)
+		});
+		if (!response.ok) return null;
+		const modelIds = extractModelIdsFromPayload(await response.json());
+		return modelIds ? new Set(modelIds) : null;
+	} catch {
+		return null;
+	}
+}
+function extractConfiguredApiKey(providerConfig) {
+	const options = providerConfig.options;
+	if (!options || typeof options !== "object") return null;
+	const apiKey = "apiKey" in options ? options.apiKey : null;
+	return typeof apiKey === "string" && apiKey.trim().length > 0 ? apiKey.trim() : null;
+}
+function buildModelsEndpointUrl(baseUrl) {
+	const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+	return new URL("models", normalizedBaseUrl).toString();
+}
+function extractModelIdsFromPayload(payload) {
+	if (Array.isArray(payload)) return payload.map(extractModelId).filter((id) => !!id);
+	if (payload && typeof payload === "object" && "data" in payload && Array.isArray(payload.data)) return payload.data.map(extractModelId).filter((id) => !!id);
+	return null;
+}
+function extractModelId(value) {
+	if (typeof value === "string" && value.trim().length > 0) return value.trim();
+	if (value && typeof value === "object" && "id" in value) {
+		const id = value.id;
+		return typeof id === "string" && id.trim().length > 0 ? id.trim() : null;
+	}
+	return null;
+}
+//#endregion
+//#region src/services/storage/bot-state.ts
+function createDefaultOpencodeTbotState() {
+	return {
+		version: 1,
+		sessions: {},
+		pendingActions: {},
+		pendingPermissions: {}
+	};
+}
+//#endregion
+//#region src/services/storage/json-state-store.ts
+var JsonStateStore = class {
+	createDefaultState;
+	filePath;
+	statePromise = null;
+	writeQueue = Promise.resolve();
+	constructor(options) {
+		this.createDefaultState = options.createDefaultState;
+		this.filePath = options.filePath;
+	}
+	async read() {
+		return cloneState(await this.loadState());
+	}
+	async update(mutator) {
+		const nextStatePromise = this.writeQueue.then(async () => {
+			const draft = cloneState(await this.loadState());
+			mutator(draft);
+			await writeStateFile(this.filePath, draft);
+			this.statePromise = Promise.resolve(draft);
+			return cloneState(draft);
+		});
+		this.writeQueue = nextStatePromise.then(() => void 0, () => void 0);
+		return nextStatePromise;
+	}
+	async loadState() {
+		if (!this.statePromise) this.statePromise = readStateFile(this.filePath, this.createDefaultState);
+		return this.statePromise;
+	}
+};
+async function readStateFile(filePath, createDefaultState) {
+	try {
+		const content = await readFile(filePath, "utf8");
+		return JSON.parse(content);
+	} catch (error) {
+		if (isMissingFileError(error)) return createDefaultState();
+		throw error;
+	}
+}
+async function writeStateFile(filePath, state) {
+	await mkdir(dirname(filePath), { recursive: true });
+	const temporaryFilePath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+	await writeFile(temporaryFilePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+	await rename(temporaryFilePath, filePath);
+}
+function cloneState(state) {
+	return JSON.parse(JSON.stringify(state));
+}
+function isMissingFileError(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+//#endregion
+//#region src/services/telegram/telegram.client.ts
+var TelegramFileDownloadError = class extends Error {
+	data;
+	constructor(message) {
+		super(message);
+		this.name = "TelegramFileDownloadError";
+		this.data = { message };
+	}
+};
+var VoiceMessageUnsupportedError = class extends Error {
+	data;
+	constructor(message) {
+		super(message);
+		this.name = "VoiceMessageUnsupportedError";
+		this.data = { message };
+	}
+};
+var TelegramFileClient = class {
+	baseUrl;
+	fetchFn;
+	constructor(options, fetchFn = fetch) {
+		this.baseUrl = options.baseUrl ?? buildTelegramFileApiRoot(options.apiRoot, options.botToken);
+		this.fetchFn = fetchFn;
+	}
+	async downloadFile(input) {
+		const filePath = input.filePath.trim();
+		if (!filePath) throw new TelegramFileDownloadError("Telegram did not provide a downloadable file path.");
+		let response;
+		try {
+			response = await this.fetchFn(new URL(filePath, this.baseUrl));
+		} catch (error) {
+			throw new TelegramFileDownloadError(extractErrorMessage$1(error) ?? "Failed to download the Telegram voice file.");
+		}
+		if (!response.ok) throw new TelegramFileDownloadError(await buildDownloadFailureMessage(response));
+		const data = new Uint8Array(await response.arrayBuffer());
+		if (data.byteLength === 0) throw new TelegramFileDownloadError("Telegram returned an empty voice file.");
+		return {
+			data,
+			mimeType: response.headers.get("content-type")
+		};
+	}
+};
+function buildTelegramFileApiRoot(apiRoot, botToken) {
+	return `${(apiRoot ?? "https://api.telegram.org").trim().replace(/\/+$/u, "")}/file/bot${botToken}/`;
+}
+async function buildDownloadFailureMessage(response) {
+	const normalizedText = (await safeReadResponseText(response))?.trim();
+	return normalizedText ? `Telegram file download failed with status ${response.status}: ${normalizedText}` : `Telegram file download failed with status ${response.status}.`;
+}
+async function safeReadResponseText(response) {
+	try {
+		const text = await response.text();
+		return text.trim().length > 0 ? text : null;
+	} catch {
+		return null;
+	}
+}
+function extractErrorMessage$1(error) {
+	return error instanceof Error && error.message.trim().length > 0 ? error.message.trim() : null;
+}
+//#endregion
+//#region src/services/session-activity/foreground-session-tracker.ts
+var ForegroundSessionTracker = class {
+	counts = /* @__PURE__ */ new Map();
+	begin(sessionId) {
+		const currentCount = this.counts.get(sessionId) ?? 0;
+		this.counts.set(sessionId, currentCount + 1);
+		return () => {
+			this.decrement(sessionId);
+		};
+	}
+	clear(sessionId) {
+		const wasForeground = this.counts.has(sessionId);
+		this.counts.delete(sessionId);
+		return wasForeground;
+	}
+	isForeground(sessionId) {
+		return this.counts.has(sessionId);
+	}
+	decrement(sessionId) {
+		const currentCount = this.counts.get(sessionId);
+		if (!currentCount || currentCount <= 1) {
+			this.counts.delete(sessionId);
+			return;
+		}
+		this.counts.set(sessionId, currentCount - 1);
+	}
+};
+var NOOP_FOREGROUND_SESSION_TRACKER = {
+	begin() {
+		return () => void 0;
+	},
+	clear() {
+		return false;
+	},
+	isForeground() {
+		return false;
+	}
+};
+//#endregion
+//#region src/services/voice-transcription/openrouter-voice.client.ts
+var VoiceTranscriptionNotConfiguredError = class extends Error {
+	data;
+	constructor(message) {
+		super(message);
+		this.name = "VoiceTranscriptionNotConfiguredError";
+		this.data = { message };
+	}
+};
+var VoiceTranscriptionFailedError = class extends Error {
+	data;
+	constructor(message) {
+		super(message);
+		this.name = "VoiceTranscriptionFailedError";
+		this.data = { message };
+	}
+};
+var VoiceTranscriptEmptyError = class extends Error {
+	data;
+	constructor(message) {
+		super(message);
+		this.name = "VoiceTranscriptEmptyError";
+		this.data = { message };
+	}
+};
+var DisabledVoiceTranscriptionClient = class {
+	async transcribe() {
+		throw new VoiceTranscriptionNotConfiguredError("Set openrouter.apiKey in tbot.config.json to enable Telegram voice transcription.");
+	}
+};
+var OpenRouterVoiceTranscriptionClient = class {
+	model;
+	sdk;
+	timeoutMs;
+	transcriptionPrompt;
+	constructor(options, sdk) {
+		this.model = options.model;
+		this.sdk = sdk;
+		this.timeoutMs = options.timeoutMs;
+		this.transcriptionPrompt = options.transcriptionPrompt?.trim() || null;
+	}
+	async transcribe(input) {
+		const format = resolveAudioFormat(input.filename, input.mimeType);
+		const audioData = toBase64(input.data);
+		const prompt = buildTranscriptionPrompt(this.transcriptionPrompt);
+		let response;
+		try {
+			response = await this.sdk.chat.send({ chatGenerationParams: {
+				messages: [{
+					role: "user",
+					content: [{
+						type: "text",
+						text: prompt
+					}, {
+						type: "input_audio",
+						inputAudio: {
+							data: audioData,
+							format
+						}
+					}]
+				}],
+				model: this.model,
+				stream: false,
+				temperature: 0
+			} }, { timeoutMs: this.timeoutMs });
+		} catch (error) {
+			throw new VoiceTranscriptionFailedError(extractErrorMessage(error) ?? "Failed to reach OpenRouter voice transcription.");
+		}
+		return { text: extractTranscript(response) };
+	}
+};
+var MIME_TYPE_FORMAT_MAP = {
+	"audio/aac": "aac",
+	"audio/aiff": "aiff",
+	"audio/flac": "flac",
+	"audio/m4a": "m4a",
+	"audio/mp3": "mp3",
+	"audio/mp4": "m4a",
+	"audio/mpeg": "mp3",
+	"audio/ogg": "ogg",
+	"audio/wav": "wav",
+	"audio/wave": "wav",
+	"audio/x-aac": "aac",
+	"audio/x-aiff": "aiff",
+	"audio/x-flac": "flac",
+	"audio/x-m4a": "m4a",
+	"audio/x-wav": "wav",
+	"audio/vnd.wave": "wav"
+};
+var FILE_EXTENSION_FORMAT_MAP = {
+	".aac": "aac",
+	".aif": "aiff",
+	".aiff": "aiff",
+	".flac": "flac",
+	".m4a": "m4a",
+	".mp3": "mp3",
+	".oga": "ogg",
+	".ogg": "ogg",
+	".wav": "wav"
+};
+function resolveAudioFormat(filename, mimeType) {
+	const normalizedMimeType = mimeType?.trim().toLowerCase() || null;
+	if (normalizedMimeType && MIME_TYPE_FORMAT_MAP[normalizedMimeType]) return MIME_TYPE_FORMAT_MAP[normalizedMimeType];
+	const extension = extname(basename(filename).trim()).toLowerCase();
+	if (extension && FILE_EXTENSION_FORMAT_MAP[extension]) return FILE_EXTENSION_FORMAT_MAP[extension];
+	return "ogg";
+}
+function toBase64(data) {
+	const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+	return Buffer.from(bytes).toString("base64");
+}
+function buildTranscriptionPrompt(transcriptionPrompt) {
+	const basePrompt = [
+		"Transcribe the provided audio verbatim.",
+		"Return only the transcript text.",
+		"Do not translate, summarize, explain, or add speaker labels.",
+		"If the audio is empty or unintelligible, return an empty string."
+	].join(" ");
+	return transcriptionPrompt ? `${basePrompt}\n\nAdditional instructions: ${transcriptionPrompt}` : basePrompt;
+}
+function extractTranscript(response) {
+	const content = response.choices?.[0]?.message?.content;
+	if (typeof content === "string") return content.trim();
+	if (!Array.isArray(content)) return "";
+	return content.flatMap((item) => isTextContentItem(item) ? [item.text.trim()] : []).filter((text) => text.length > 0).join("\n").trim();
+}
+function isTextContentItem(value) {
+	return !!value && typeof value === "object" && "type" in value && value.type === "text" && "text" in value && typeof value.text === "string";
+}
+function extractErrorMessage(error) {
+	return error instanceof Error && error.message.trim().length > 0 ? error.message.trim() : null;
+}
+//#endregion
+//#region src/services/voice-transcription/voice-transcription.service.ts
+var VoiceTranscriptionService = class {
+	constructor(client) {
+		this.client = client;
+	}
+	async transcribeVoice(input) {
+		const text = (await this.client.transcribe(input)).text.trim();
+		if (!text) throw new VoiceTranscriptEmptyError("Voice transcription returned empty text.");
+		return { text };
+	}
+};
+//#endregion
+//#region src/use-cases/abort-prompt.usecase.ts
+var AbortPromptUseCase = class {
+	constructor(sessionRepo, opencodeClient) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+	}
+	async execute(input) {
+		const binding = await this.sessionRepo.getByChatId(input.chatId);
+		if (!binding?.sessionId) return {
+			sessionId: null,
+			status: "no_session",
+			sessionStatus: null
+		};
+		const sessionId = binding.sessionId;
+		const sessionStatus = (await this.opencodeClient.getSessionStatuses())[sessionId] ?? null;
+		if (!sessionStatus || sessionStatus.type === "idle") return {
+			sessionId,
+			status: "not_running",
+			sessionStatus
+		};
+		return {
+			sessionId,
+			status: await this.opencodeClient.abortSession(sessionId) ? "aborted" : "not_running",
+			sessionStatus
+		};
+	}
+};
+//#endregion
+//#region src/use-cases/session-creation.ts
+async function createAndBindCurrentProjectSession(sessionRepo, opencodeClient, input) {
+	const binding = input.binding ?? await sessionRepo.getByChatId(input.chatId);
+	const project = await opencodeClient.getCurrentProject();
+	const title = normalizeOptionalText(input.title);
+	const session = await opencodeClient.createSessionForDirectory(project.worktree, title ?? void 0);
+	const nextBinding = {
+		chatId: input.chatId,
+		sessionId: session.id,
+		projectId: session.projectID,
+		directory: session.directory,
+		agentName: binding?.agentName ?? null,
+		modelProviderId: binding?.modelProviderId ?? null,
+		modelId: binding?.modelId ?? null,
+		modelVariant: binding?.modelVariant ?? null,
+		language: binding?.language ?? null,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await sessionRepo.setCurrent(nextBinding);
+	return {
+		binding: nextBinding,
+		project,
+		session
+	};
+}
+function normalizeOptionalText(value) {
+	const normalized = value?.trim();
+	return normalized ? normalized : null;
+}
+//#endregion
+//#region src/use-cases/create-session.usecase.ts
+var CreateSessionUseCase = class {
+	constructor(sessionRepo, opencodeClient, logger) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+		this.logger = logger;
+	}
+	async execute(input) {
+		const binding = await this.sessionRepo.getByChatId(input.chatId);
+		const result = await createAndBindCurrentProjectSession(this.sessionRepo, this.opencodeClient, {
+			chatId: input.chatId,
+			title: input.title,
+			binding
+		});
+		this.logger.info({
+			chatId: input.chatId,
+			sessionId: result.session.id,
+			projectId: result.session.projectID,
+			directory: result.session.directory,
+			title: input.title?.trim() || null
+		}, "session created");
+		return { session: result.session };
+	}
+};
+//#endregion
+//#region src/use-cases/get-health.usecase.ts
+var GetHealthUseCase = class {
+	constructor(opencodeClient) {
+		this.opencodeClient = opencodeClient;
+	}
+	async execute() {
+		return this.opencodeClient.getHealth();
+	}
+};
+//#endregion
+//#region src/use-cases/get-path.usecase.ts
+var GetPathUseCase = class {
+	constructor(opencodeClient) {
+		this.opencodeClient = opencodeClient;
+	}
+	async execute() {
+		return this.opencodeClient.getPath();
+	}
+};
+//#endregion
+//#region src/use-cases/get-status.usecase.ts
+var GetStatusUseCase = class {
+	constructor(getHealthUseCase, getPathUseCase, listLspUseCase, listMcpUseCase) {
+		this.getHealthUseCase = getHealthUseCase;
+		this.getPathUseCase = getPathUseCase;
+		this.listLspUseCase = listLspUseCase;
+		this.listMcpUseCase = listMcpUseCase;
+	}
+	async execute(input) {
+		const [health, path, lsp, mcp] = await Promise.allSettled([
+			this.getHealthUseCase.execute(),
+			this.getPathUseCase.execute(),
+			this.listLspUseCase.execute({ chatId: input.chatId }),
+			this.listMcpUseCase.execute({ chatId: input.chatId })
+		]);
+		return {
+			health: mapSettledResult(health),
+			path: mapSettledResult(path),
+			lsp: mapSettledResult(lsp),
+			mcp: mapSettledResult(mcp)
+		};
+	}
+};
+function mapSettledResult(result) {
+	if (result.status === "fulfilled") return {
+		data: result.value,
+		status: "ok"
+	};
+	return {
+		error: result.reason,
+		status: "error"
+	};
+}
+function resolveSelectedAgent(agents, requestedAgentName) {
+	const visibleAgents = agents.filter((agent) => !agent.hidden);
+	if (requestedAgentName) {
+		const requestedAgent = visibleAgents.find((agent) => agent.name === requestedAgentName);
+		if (requestedAgent) return requestedAgent;
+	}
+	return visibleAgents.find((agent) => agent.name === "build") ?? null;
+}
+//#endregion
+//#region src/use-cases/binding-update.ts
+async function persistBindingUpdate(sessionRepo, binding, updates) {
+	const nextBinding = {
+		...binding,
+		...updates,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await sessionRepo.setCurrent(nextBinding);
+	return nextBinding;
+}
+async function clearStoredAgentSelection(sessionRepo, binding) {
+	return persistBindingUpdate(sessionRepo, binding, { agentName: null });
+}
+async function clearStoredModelSelection(sessionRepo, binding) {
+	return persistBindingUpdate(sessionRepo, binding, {
+		modelProviderId: null,
+		modelId: null,
+		modelVariant: null
+	});
+}
+async function clearStoredModelVariant(sessionRepo, binding) {
+	return persistBindingUpdate(sessionRepo, binding, { modelVariant: null });
+}
+async function clearStoredSessionContext(sessionRepo, binding) {
+	return persistBindingUpdate(sessionRepo, binding, {
+		sessionId: null,
+		projectId: null,
+		directory: null
+	});
+}
+//#endregion
+//#region src/use-cases/list-agents.usecase.ts
+var ListAgentsUseCase = class {
+	constructor(sessionRepo, opencodeClient) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+	}
+	async execute(input) {
+		let [binding, agents] = await Promise.all([this.sessionRepo.getByChatId(input.chatId), this.opencodeClient.listAgents()]);
+		const visibleAgents = agents.filter((agent) => !agent.hidden);
+		const currentAgent = resolveSelectedAgent(visibleAgents, binding?.agentName);
+		if (binding?.agentName && currentAgent?.name !== binding.agentName) binding = await clearStoredAgentSelection(this.sessionRepo, binding);
+		return {
+			agents: visibleAgents,
+			currentAgentName: currentAgent?.name ?? null
+		};
+	}
+};
+//#endregion
+//#region src/use-cases/list-lsp.usecase.ts
+var ListLspUseCase = class {
+	constructor(sessionRepo, opencodeClient) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+	}
+	async execute(input) {
+		let binding = await this.sessionRepo.getByChatId(input.chatId);
+		if (binding?.projectId && binding.directory) {
+			if (!hasMatchingProject$2(await this.opencodeClient.listProjects(), binding)) binding = await clearStoredSessionContext(this.sessionRepo, binding);
+		}
+		const projectContext = binding?.projectId && binding.directory ? {
+			projectId: binding.projectId,
+			directory: binding.directory
+		} : await this.getCurrentProjectContext();
+		const statuses = await this.opencodeClient.listLspStatuses(projectContext.directory);
+		return {
+			currentDirectory: projectContext.directory,
+			statuses: [...statuses].sort(compareLspStatuses)
+		};
+	}
+	async getCurrentProjectContext() {
+		const currentProject = await this.opencodeClient.getCurrentProject();
+		return {
+			projectId: currentProject.id,
+			directory: currentProject.worktree
+		};
+	}
+};
+function compareLspStatuses(left, right) {
+	return left.name.localeCompare(right.name) || left.root.localeCompare(right.root) || left.id.localeCompare(right.id);
+}
+function hasMatchingProject$2(projects, binding) {
+	return projects.some((project) => project.id === binding.projectId && project.worktree === binding.directory);
+}
+//#endregion
+//#region src/use-cases/list-mcp.usecase.ts
+var ListMcpUseCase = class {
+	constructor(sessionRepo, opencodeClient) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+	}
+	async execute(input) {
+		let binding = await this.sessionRepo.getByChatId(input.chatId);
+		if (binding?.projectId && binding.directory) {
+			if (!hasMatchingProject$1(await this.opencodeClient.listProjects(), binding)) binding = await clearStoredSessionContext(this.sessionRepo, binding);
+		}
+		const projectContext = binding?.projectId && binding.directory ? {
+			projectId: binding.projectId,
+			directory: binding.directory
+		} : await this.getCurrentProjectContext();
+		const statuses = await this.opencodeClient.listMcpStatuses(projectContext.directory);
+		return {
+			currentDirectory: projectContext.directory,
+			statuses: Object.entries(statuses).sort(([left], [right]) => left.localeCompare(right)).map(([name, status]) => ({
+				name,
+				status
+			}))
+		};
+	}
+	async getCurrentProjectContext() {
+		const currentProject = await this.opencodeClient.getCurrentProject();
+		return {
+			projectId: currentProject.id,
+			directory: currentProject.worktree
+		};
+	}
+};
+function hasMatchingProject$1(projects, binding) {
+	return projects.some((project) => project.id === binding.projectId && project.worktree === binding.directory);
+}
+//#endregion
+//#region src/use-cases/list-models.usecase.ts
+var ListModelsUseCase = class {
+	constructor(sessionRepo, opencodeClient) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+	}
+	async execute(input) {
+		let [binding, models] = await Promise.all([this.sessionRepo.getByChatId(input.chatId), this.opencodeClient.listModels()]);
+		if (binding?.modelProviderId && binding?.modelId) {
+			const selectedModel = models.find((model) => model.providerID === binding?.modelProviderId && model.id === binding?.modelId);
+			if (!selectedModel) binding = await clearStoredModelSelection(this.sessionRepo, binding);
+			else if (binding.modelVariant && !(binding.modelVariant in selectedModel.variants)) binding = await clearStoredModelVariant(this.sessionRepo, binding);
+		}
+		return {
+			models,
+			currentModelProviderId: binding?.modelProviderId ?? null,
+			currentModelId: binding?.modelId ?? null,
+			currentModelVariant: binding?.modelVariant ?? null
+		};
+	}
+};
+//#endregion
+//#region src/use-cases/list-sessions.usecase.ts
+var ListSessionsUseCase = class {
+	constructor(sessionRepo, opencodeClient) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+	}
+	async execute(input) {
+		let binding = await this.sessionRepo.getByChatId(input.chatId);
+		const [sessions, projects] = await Promise.all([this.opencodeClient.listSessions(), binding?.projectId && binding.directory ? this.opencodeClient.listProjects() : Promise.resolve(null)]);
+		if (binding?.projectId && binding.directory && !hasMatchingProject(projects, binding)) binding = await clearStoredSessionContext(this.sessionRepo, binding);
+		if (binding?.sessionId && binding.projectId && !hasMatchingSession(sessions, binding)) binding = await clearStoredSessionContext(this.sessionRepo, binding);
+		const projectContext = binding?.projectId && binding.directory ? {
+			projectId: binding.projectId,
+			directory: binding.directory
+		} : await this.getCurrentProjectContext();
+		return {
+			sessions: sessions.filter((session) => session.projectID === projectContext.projectId),
+			currentProjectId: projectContext.projectId,
+			currentDirectory: projectContext.directory,
+			currentSessionId: binding?.projectId === projectContext.projectId ? binding.sessionId : null
+		};
+	}
+	async getCurrentProjectContext() {
+		const currentProject = await this.opencodeClient.getCurrentProject();
+		return {
+			projectId: currentProject.id,
+			directory: currentProject.worktree
+		};
+	}
+};
+function hasMatchingProject(projects, binding) {
+	if (!projects) return true;
+	return projects.some((project) => project.id === binding.projectId && project.worktree === binding.directory);
+}
+function hasMatchingSession(sessions, binding) {
+	return sessions.some((session) => session.id === binding.sessionId && session.projectID === binding.projectId);
+}
+//#endregion
+//#region src/use-cases/rename-session.usecase.ts
+var RenameSessionUseCase = class {
+	constructor(sessionRepo, opencodeClient, logger) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+		this.logger = logger;
+	}
+	async execute(input) {
+		const title = input.title.trim();
+		if (!title) throw new Error("Session title cannot be empty.");
+		const [binding, sessions] = await Promise.all([this.sessionRepo.getByChatId(input.chatId), this.opencodeClient.listSessions()]);
+		const currentProjectId = binding?.projectId ?? (await this.opencodeClient.getCurrentProject()).id;
+		const session = sessions.find((item) => item.id === input.sessionId && item.projectID === currentProjectId);
+		if (!session) return { found: false };
+		const renamedSession = await this.opencodeClient.renameSession(session.id, title);
+		this.logger.info({
+			chatId: input.chatId,
+			sessionId: renamedSession.id,
+			projectId: renamedSession.projectID,
+			title: renamedSession.title
+		}, "session renamed");
+		return {
+			found: true,
+			session: renamedSession
+		};
+	}
+};
+//#endregion
+//#region src/use-cases/send-prompt.usecase.ts
+var SendPromptUseCase = class {
+	constructor(sessionRepo, opencodeClient, logger, foregroundSessionTracker = NOOP_FOREGROUND_SESSION_TRACKER) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+		this.logger = logger;
+		this.foregroundSessionTracker = foregroundSessionTracker;
+	}
+	async execute(input) {
+		const files = input.files ?? [];
+		const promptText = buildPromptText(input.text, files);
+		if (!promptText && files.length === 0) throw new Error("Prompt requires text or file attachments.");
+		let binding = await this.sessionRepo.getByChatId(input.chatId);
+		if (binding?.projectId && binding.directory) {
+			if (!(await this.opencodeClient.listProjects()).find((project) => project.id === binding?.projectId && project.worktree === binding.directory)) binding = await this.clearInvalidSessionContext(input.chatId, binding, "saved project is no longer available");
+		}
+		if (binding?.sessionId && binding.projectId) {
+			if (!(await this.opencodeClient.listSessions()).find((session) => session.id === binding?.sessionId && session.projectID === binding.projectId)) binding = await this.clearInvalidSessionContext(input.chatId, binding, "saved session is no longer available");
+		}
+		if (!binding || !binding.sessionId || !binding.projectId || !binding.directory) {
+			const createdSession = await createAndBindCurrentProjectSession(this.sessionRepo, this.opencodeClient, {
+				chatId: input.chatId,
+				binding
+			});
+			binding = createdSession.binding;
+			this.logger.info({
+				chatId: input.chatId,
+				sessionId: createdSession.session.id,
+				projectId: createdSession.session.projectID,
+				directory: createdSession.session.directory
+			}, "session created");
+		}
+		if (binding?.modelProviderId && binding?.modelId) {
+			const selectedModel = (await this.opencodeClient.listModels()).find((model) => model.providerID === binding?.modelProviderId && model.id === binding?.modelId);
+			if (!selectedModel) {
+				binding = await clearStoredModelSelection(this.sessionRepo, binding);
+				this.logger.warn?.({ chatId: input.chatId }, "selected model is no longer available, falling back to OpenCode default");
+			} else if (binding.modelVariant && !(binding.modelVariant in selectedModel.variants)) {
+				binding = await clearStoredModelVariant(this.sessionRepo, binding);
+				this.logger.warn?.({
+					chatId: input.chatId,
+					providerId: selectedModel.providerID,
+					modelId: selectedModel.id
+				}, "selected model variant is no longer available, falling back to default variant");
+			}
+		}
+		if (!binding || !binding.sessionId || !binding.projectId) throw new Error("Failed to initialize chat session.");
+		let activeBinding = binding;
+		const model = activeBinding.modelProviderId && activeBinding.modelId ? {
+			providerID: activeBinding.modelProviderId,
+			modelID: activeBinding.modelId
+		} : null;
+		const selectedAgent = resolveSelectedAgent(await this.opencodeClient.listAgents(), activeBinding.agentName);
+		if (activeBinding.agentName && selectedAgent?.name !== activeBinding.agentName) {
+			activeBinding = await clearStoredAgentSelection(this.sessionRepo, activeBinding);
+			this.logger.warn?.({ chatId: input.chatId }, "selected agent is no longer available, falling back to OpenCode default");
+		}
+		const endForegroundSession = this.foregroundSessionTracker.begin(activeBinding.sessionId);
+		let result;
+		try {
+			result = await this.opencodeClient.promptSession({
+				sessionId: activeBinding.sessionId,
+				prompt: promptText,
+				...files.length > 0 ? { files } : {},
+				...selectedAgent ? { agent: selectedAgent.name } : {},
+				structured: true,
+				...model ? { model } : {},
+				...activeBinding.modelVariant ? { variant: activeBinding.modelVariant } : {}
+			});
+		} finally {
+			endForegroundSession();
+		}
+		await this.sessionRepo.touch(input.chatId);
+		return {
+			assistantReply: result,
+			sessionId: activeBinding.sessionId,
+			projectId: activeBinding.projectId
+		};
+	}
+	async clearInvalidSessionContext(chatId, binding, reason) {
+		const nextBinding = await clearStoredSessionContext(this.sessionRepo, binding);
+		this.logger.warn?.({ chatId }, `${reason}, falling back to the current OpenCode project`);
+		return nextBinding;
+	}
+};
+function buildPromptText(text, files) {
+	const trimmedText = text?.trim() ?? "";
+	if (!files.some(isImageFile)) return trimmedText;
+	const promptSections = [[
+		"System note for this turn:",
+		"The user attached one or more images in this message and you can inspect those images directly.",
+		"Ignore any earlier statements in this conversation claiming that you could not view images or attachments, because those may have come from a previous model or an earlier limitation.",
+		"If an image is blurry or unreadable, say that it is blurry or unreadable instead of saying that you cannot view images."
+	].join(" ")];
+	if (trimmedText) promptSections.push(trimmedText);
+	return promptSections.join("\n\n");
+}
+function isImageFile(file) {
+	return file.mime.trim().toLowerCase().startsWith("image/");
+}
+//#endregion
+//#region src/use-cases/switch-agent.usecase.ts
+var SwitchAgentUseCase = class {
+	constructor(sessionRepo, opencodeClient, logger) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+		this.logger = logger;
+	}
+	async execute(input) {
+		const [binding, agents] = await Promise.all([this.sessionRepo.getByChatId(input.chatId), this.opencodeClient.listAgents()]);
+		const agent = agents.find((item) => item.name === input.agentName && !item.hidden);
+		if (!agent) return { found: false };
+		await this.sessionRepo.setCurrent({
+			chatId: input.chatId,
+			sessionId: binding?.sessionId ?? null,
+			projectId: binding?.projectId ?? null,
+			directory: binding?.directory ?? null,
+			agentName: agent.name,
+			modelProviderId: binding?.modelProviderId ?? null,
+			modelId: binding?.modelId ?? null,
+			modelVariant: binding?.modelVariant ?? null,
+			language: binding?.language ?? null,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		this.logger.info({
+			chatId: input.chatId,
+			agentName: agent.name
+		}, "agent switched");
+		return {
+			found: true,
+			agent
+		};
+	}
+};
+//#endregion
+//#region src/use-cases/switch-model.usecase.ts
+var SwitchModelUseCase = class {
+	constructor(sessionRepo, opencodeClient, logger) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+		this.logger = logger;
+	}
+	async execute(input) {
+		const [binding, models] = await Promise.all([this.sessionRepo.getByChatId(input.chatId), this.opencodeClient.listModels()]);
+		const model = models.find((item) => item.providerID === input.providerId && item.id === input.modelId);
+		if (!model) return { found: false };
+		const variant = input.variant ?? null;
+		if (variant && !(variant in model.variants)) return { found: false };
+		await this.sessionRepo.setCurrent({
+			chatId: input.chatId,
+			sessionId: binding?.sessionId ?? null,
+			projectId: binding?.projectId ?? null,
+			directory: binding?.directory ?? null,
+			agentName: binding?.agentName ?? null,
+			modelProviderId: model.providerID,
+			modelId: model.id,
+			modelVariant: variant,
+			language: binding?.language ?? null,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		this.logger.info({
+			chatId: input.chatId,
+			providerId: model.providerID,
+			modelId: model.id,
+			variant
+		}, "model switched");
+		return {
+			found: true,
+			model,
+			variant
+		};
+	}
+};
+//#endregion
+//#region src/use-cases/switch-session.usecase.ts
+var SwitchSessionUseCase = class {
+	constructor(sessionRepo, opencodeClient, logger) {
+		this.sessionRepo = sessionRepo;
+		this.opencodeClient = opencodeClient;
+		this.logger = logger;
+	}
+	async execute(input) {
+		const [binding, sessions] = await Promise.all([this.sessionRepo.getByChatId(input.chatId), this.opencodeClient.listSessions()]);
+		const currentProjectId = binding?.projectId ?? (await this.opencodeClient.getCurrentProject()).id;
+		const session = sessions.find((item) => item.id === input.sessionId && item.projectID === currentProjectId);
+		if (!session) return { found: false };
+		await this.sessionRepo.setCurrent({
+			chatId: input.chatId,
+			sessionId: session.id,
+			projectId: session.projectID,
+			directory: session.directory,
+			agentName: binding?.agentName ?? null,
+			modelProviderId: binding?.modelProviderId ?? null,
+			modelId: binding?.modelId ?? null,
+			modelVariant: binding?.modelVariant ?? null,
+			language: binding?.language ?? null,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		this.logger.info({
+			chatId: input.chatId,
+			sessionId: session.id,
+			projectId: session.projectID,
+			directory: session.directory
+		}, "session switched");
+		return {
+			found: true,
+			session
+		};
+	}
+};
+//#endregion
+//#region src/use-cases/upload-file.usecase.ts
+var ImageFileDownloadError = class extends Error {
+	data;
+	constructor(message) {
+		super(message);
+		this.name = "ImageFileDownloadError";
+		this.data = { message };
+	}
+};
+var ImageMessageUnsupportedError = class extends Error {
+	data;
+	constructor(message) {
+		super(message);
+		this.name = "ImageMessageUnsupportedError";
+		this.data = { message };
+	}
+};
+var UploadFileUseCase = class {
+	constructor(telegramFileClient) {
+		this.telegramFileClient = telegramFileClient;
+	}
+	async execute(input) {
+		if (input.expectedType !== "image") throw new ImageMessageUnsupportedError("Only image uploads are supported.");
+		let download;
+		try {
+			download = await this.telegramFileClient.downloadFile({ filePath: input.filePath });
+		} catch (error) {
+			if (error instanceof TelegramFileDownloadError) throw new ImageFileDownloadError(error.message);
+			throw error;
+		}
+		const mimeType = normalizeMimeType(input.mimeType ?? download.mimeType);
+		if (!mimeType.startsWith("image/")) throw new ImageMessageUnsupportedError(`Unsupported image MIME type: ${mimeType}`);
+		return {
+			filename: resolveFilename(input.filename, input.filePath, mimeType),
+			mime: mimeType,
+			url: buildDataUrl(download.data, mimeType)
+		};
+	}
+};
+function buildDataUrl(data, mimeType) {
+	return `data:${mimeType};base64,${Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64")}`;
+}
+function normalizeMimeType(value) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized && normalized.length > 0 ? normalized : "application/octet-stream";
+}
+function resolveFilename(explicitFilename, filePath, mimeType) {
+	const preferredFilename = explicitFilename?.trim();
+	if (preferredFilename) return preferredFilename;
+	const filePathFilename = filePath.split("/").at(-1)?.trim();
+	if (filePathFilename) return filePathFilename;
+	return `telegram-upload${resolveExtension(mimeType)}`;
+}
+function resolveExtension(mimeType) {
+	switch (mimeType) {
+		case "image/jpeg": return ".jpg";
+		case "image/png": return ".png";
+		case "image/webp": return ".webp";
+		case "image/gif": return ".gif";
+		default: return "";
+	}
+}
+//#endregion
+//#region src/app/container.ts
+function createAppContainer(config, client) {
+	const logger = createOpenCodeAppLogger(client, { level: config.logLevel });
+	return createContainer(config, createOpenCodeClientFromSdkClient(client), logger);
+}
+function createContainer(config, opencodeClient, logger) {
+	const stateStore = new JsonStateStore({
+		filePath: config.stateFilePath,
+		createDefaultState: createDefaultOpencodeTbotState
+	});
+	const pendingActionRepo = new FilePendingActionRepository(stateStore);
+	const permissionApprovalRepo = new FilePermissionApprovalRepository(stateStore);
+	const sessionRepo = new FileSessionRepository(stateStore);
+	const foregroundSessionTracker = new ForegroundSessionTracker();
+	const telegramFileClient = new TelegramFileClient({
+		botToken: config.telegramBotToken,
+		apiRoot: config.telegramApiRoot
+	});
+	const uploadFileUseCase = new UploadFileUseCase(telegramFileClient);
+	const voiceTranscriptionService = new VoiceTranscriptionService(createVoiceTranscriptionClient(config.openrouter));
+	const abortPromptUseCase = new AbortPromptUseCase(sessionRepo, opencodeClient);
+	const createSessionUseCase = new CreateSessionUseCase(sessionRepo, opencodeClient, logger);
+	const getHealthUseCase = new GetHealthUseCase(opencodeClient);
+	const getPathUseCase = new GetPathUseCase(opencodeClient);
+	const listAgentsUseCase = new ListAgentsUseCase(sessionRepo, opencodeClient);
+	const listLspUseCase = new ListLspUseCase(sessionRepo, opencodeClient);
+	const listMcpUseCase = new ListMcpUseCase(sessionRepo, opencodeClient);
+	const getStatusUseCase = new GetStatusUseCase(getHealthUseCase, getPathUseCase, listLspUseCase, listMcpUseCase);
+	const listModelsUseCase = new ListModelsUseCase(sessionRepo, opencodeClient);
+	const listSessionsUseCase = new ListSessionsUseCase(sessionRepo, opencodeClient);
+	const renameSessionUseCase = new RenameSessionUseCase(sessionRepo, opencodeClient, logger);
+	const sendPromptUseCase = new SendPromptUseCase(sessionRepo, opencodeClient, logger, foregroundSessionTracker);
+	const switchAgentUseCase = new SwitchAgentUseCase(sessionRepo, opencodeClient, logger);
+	const switchModelUseCase = new SwitchModelUseCase(sessionRepo, opencodeClient, logger);
+	const switchSessionUseCase = new SwitchSessionUseCase(sessionRepo, opencodeClient, logger);
+	let disposed = false;
+	return {
+		abortPromptUseCase,
+		createSessionUseCase,
+		getHealthUseCase,
+		getPathUseCase,
+		getStatusUseCase,
+		listAgentsUseCase,
+		listLspUseCase,
+		listMcpUseCase,
+		logger,
+		listModelsUseCase,
+		listSessionsUseCase,
+		pendingActionRepo,
+		renameSessionUseCase,
+		sessionRepo,
+		sendPromptUseCase,
+		voiceTranscriptionService,
+		switchAgentUseCase,
+		switchModelUseCase,
+		switchSessionUseCase,
+		telegramFileClient,
+		uploadFileUseCase,
+		opencodeClient,
+		foregroundSessionTracker,
+		permissionApprovalRepo,
+		async dispose() {
+			if (disposed) return;
+			disposed = true;
+			logger.info({ filePath: config.stateFilePath }, "disposing telegram bot container");
+			await logger.flush();
+		}
+	};
+}
+function createVoiceTranscriptionClient(config) {
+	return config.configured && config.apiKey ? new OpenRouterVoiceTranscriptionClient({
+		model: config.model,
+		timeoutMs: config.timeoutMs,
+		transcriptionPrompt: config.transcriptionPrompt
+	}, new OpenRouter({
+		apiKey: config.apiKey,
+		timeoutMs: config.timeoutMs
+	})) : new DisabledVoiceTranscriptionClient();
+}
+//#endregion
+//#region src/app/bootstrap.ts
+function bootstrapPluginApp(client, configSource = {}, options = {}) {
+	const config = loadAppConfig(configSource, options);
+	return {
+		config,
+		container: createAppContainer(config, client)
+	};
+}
+//#endregion
+//#region src/services/permission/telegram-approval.ts
+function buildPermissionApprovalMessage(request) {
+	const patterns = request.patterns.length > 0 ? request.patterns.map((pattern) => `- ${pattern}`).join("\n") : "- (none)";
+	return [
+		"*Permission Request*",
+		"",
+		`Permission: \`${escapeMarkdownV2(request.permission)}\``,
+		`Session: \`${escapeMarkdownV2(request.sessionID)}\``,
+		"",
+		"Patterns:",
+		patterns
+	].join("\n");
+}
+function buildPermissionApprovalResolvedMessage(requestId, reply) {
+	return [
+		"Permission request resolved.",
+		"",
+		`Request: ${requestId}`,
+		`Reply: ${reply}`
+	].join("\n");
+}
+function buildPermissionApprovalKeyboard(requestId) {
+	return { inline_keyboard: [[
+		{
+			text: "Allow once",
+			callback_data: buildPermissionApprovalCallbackData("once", requestId)
+		},
+		{
+			text: "Always allow",
+			callback_data: buildPermissionApprovalCallbackData("always", requestId)
+		},
+		{
+			text: "Reject",
+			callback_data: buildPermissionApprovalCallbackData("reject", requestId)
+		}
+	]] };
+}
+function buildPermissionApprovalCallbackData(reply, requestId) {
+	return `permission:${reply}:${requestId}`;
+}
+function parsePermissionApprovalCallbackData(data) {
+	if (!data.startsWith("permission:")) return null;
+	const [, reply, requestId] = data.split(":", 3);
+	if (!requestId || !isPermissionApprovalReply(reply)) return null;
+	return {
+		reply,
+		requestId
+	};
+}
+function isPermissionApprovalReply(value) {
+	return value === "once" || value === "always" || value === "reject";
+}
+function escapeMarkdownV2(value) {
+	return value.replaceAll(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+}
+//#endregion
+//#region src/app/plugin-events.ts
+async function handleTelegramBotPluginEvent(runtime, event) {
+	switch (event.type) {
+		case "permission.asked":
+			await handlePermissionAsked(runtime, event.properties);
+			return;
+		case "permission.replied":
+			await handlePermissionReplied(runtime, event.properties.requestID, event.properties.reply);
+			return;
+		case "session.error":
+			await handleSessionError(runtime, event.properties.sessionID, event.properties.error);
+			return;
+		case "session.idle":
+			await handleSessionIdle(runtime, event.properties.sessionID);
+			return;
+		default: return;
+	}
+}
+async function handlePermissionAsked(runtime, request) {
+	const bindings = await runtime.container.sessionRepo.listBySessionId(request.sessionID);
+	const approvals = await runtime.container.permissionApprovalRepo.listByRequestId(request.id);
+	const approvedChatIds = new Set(approvals.map((approval) => approval.chatId));
+	for (const binding of bindings) {
+		if (approvedChatIds.has(binding.chatId)) continue;
+		try {
+			const message = await runtime.bot.api.sendMessage(binding.chatId, buildPermissionApprovalMessage(request), {
+				parse_mode: "MarkdownV2",
+				reply_markup: buildPermissionApprovalKeyboard(request.id)
+			});
+			await runtime.container.permissionApprovalRepo.set({
+				requestId: request.id,
+				sessionId: request.sessionID,
+				chatId: binding.chatId,
+				messageId: message.message_id,
+				status: "pending",
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		} catch (error) {
+			runtime.container.logger.error({
+				error,
+				chatId: binding.chatId,
+				requestId: request.id
+			}, "failed to deliver permission request to Telegram");
+		}
+	}
+}
+async function handlePermissionReplied(runtime, requestId, reply) {
+	const approvals = await runtime.container.permissionApprovalRepo.listByRequestId(requestId);
+	await Promise.all(approvals.map(async (approval) => {
+		try {
+			await runtime.bot.api.editMessageText(approval.chatId, approval.messageId, buildPermissionApprovalResolvedMessage(requestId, reply));
+		} catch (error) {
+			runtime.container.logger.warn({
+				error,
+				chatId: approval.chatId,
+				requestId
+			}, "failed to update Telegram permission message");
+		}
+		await runtime.container.permissionApprovalRepo.set(toResolvedApproval(approval, reply));
+	}));
+}
+async function handleSessionError(runtime, sessionId, error) {
+	if (!sessionId) {
+		runtime.container.logger.error({ error }, "session error received without a session id");
+		return;
+	}
+	if (runtime.container.foregroundSessionTracker.isForeground(sessionId)) {
+		runtime.container.logger.warn({
+			error,
+			sessionId
+		}, "session error suppressed for foreground Telegram session");
+		return;
+	}
+	await notifyBoundChats(runtime, sessionId, `Session failed.\n\nSession: ${sessionId}\nError: ${error?.data?.message?.trim() || error?.name?.trim() || "Unknown session error."}`);
+}
+async function handleSessionIdle(runtime, sessionId) {
+	if (runtime.container.foregroundSessionTracker.clear(sessionId)) {
+		runtime.container.logger.info({ sessionId }, "session idle notification suppressed for foreground Telegram session");
+		return;
+	}
+	await notifyBoundChats(runtime, sessionId, `Session finished.\n\nSession: ${sessionId}`);
+}
+async function notifyBoundChats(runtime, sessionId, text) {
+	const bindings = await runtime.container.sessionRepo.listBySessionId(sessionId);
+	const chatIds = [...new Set(bindings.map((binding) => binding.chatId))];
+	await Promise.all(chatIds.map(async (chatId) => {
+		try {
+			await runtime.bot.api.sendMessage(chatId, text);
+		} catch (error) {
+			runtime.container.logger.warn({
+				error,
+				chatId,
+				sessionId
+			}, "failed to notify Telegram chat about session event");
+		}
+	}));
+}
+function toResolvedApproval(approval, reply) {
+	return {
+		...approval,
+		status: reply,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+var SUPPORTED_BOT_LANGUAGES = ["en", "zh-CN"];
+var EN_BOT_COPY = {
+	commands: {
+		start: "Welcome and quick start",
+		help: "Show commands and examples",
+		status: "Show system status",
+		new: "Create a new session",
+		agents: "View and switch agents",
+		sessions: "View and switch sessions",
+		cancel: "Cancel rename or abort running request",
+		model: "View and switch models",
+		language: "View and switch language"
+	},
+	start: { lines: [
+		"# Welcome to opencode-tbot",
+		"",
+		"Talk to your OpenCode server from Telegram.",
+		"",
+		"## What you can send",
+		"- Text prompts",
+		"- Images with an optional caption",
+		"- Voice messages (requires OpenRouter voice transcription)",
+		"",
+		"## Quick start",
+		"1. Run `/status` to confirm the server is ready.",
+		"2. Run `/new [title]` to create a fresh session.",
+		"3. Send a text, image, or voice message.",
+		"",
+		"Use `/help` to see the full command list and examples."
+	] },
+	help: { lines: [
+		"# Help",
+		"",
+		"Use this bot to chat with OpenCode from Telegram.",
+		"",
+		"## Commands",
+		"- `/status` Check server, workspace, MCP, and LSP status",
+		"- `/new [title]` Create a new session",
+		"- `/sessions` View, switch, or rename sessions",
+		"- `/agents` View and switch agents",
+		"- `/model` View and switch models and reasoning levels",
+		"- `/language` Switch the bot display language",
+		"- `/cancel` Cancel session rename or abort the running request",
+		"",
+		"## Examples",
+		"- `/new bug triage`",
+		"- Send a plain text message directly",
+		"- Send an image with a caption",
+		"- Send a voice message if OpenRouter voice transcription is configured"
+	] },
+	systemStatus: { title: "System Status" },
+	common: {
+		notSelected: "Not selected",
+		openCodeDefault: "Not selected (using OpenCode default)",
+		previousPage: "Previous",
+		nextPage: "Next",
+		page(currentPage, totalPages) {
+			return `Page ${currentPage}/${totalPages}`;
+		}
+	},
+	status: {
+		processing: "Processing...",
+		alreadyProcessing: "Another request is still running. Wait for it to finish before sending a new prompt."
+	},
+	prompt: { emptyResponse: "OpenCode returned empty response." },
+	replyMetrics: {
+		durationLabel: "Duration",
+		tokensLabel: "Tokens",
+		totalLabel: "total",
+		inputLabel: "input",
+		outputLabel: "output",
+		reasoningLabel: "reasoning",
+		cacheReadLabel: "cache.read",
+		cacheWriteLabel: "cache.write",
+		notAvailable: "n/a"
+	},
+	abort: {
+		noSession: "No active session is bound to this chat yet.",
+		notRunning: "No request is currently running for the current session.",
+		aborted: "Abort signal sent to the current session."
+	},
+	errors: {
+		unexpected: "Unexpected error.",
+		providerAuth: "Provider authentication failed.",
+		requestAborted: "Request was aborted.",
+		structuredOutput: "Structured output validation failed.",
+		voiceNotConfigured: "Voice transcription is not configured.",
+		voiceDownload: "Failed to download the Telegram voice file.",
+		voiceTranscription: "Voice transcription failed.",
+		voiceEmpty: "Voice transcription returned empty text.",
+		voiceUnsupported: "Voice message file is too large or unsupported.",
+		imageDownload: "Failed to download the Telegram image file.",
+		imageUnsupported: "Image file is too large or unsupported.",
+		outputLength: "Reply hit the model output limit.",
+		contextOverflow: "Conversation exceeded the model context window.",
+		providerRequest: "Provider request failed.",
+		notFound: "Requested resource was not found.",
+		badRequest: "Request was rejected by OpenCode.",
+		causeLabel: "Cause",
+		retryableLabel: "retryable",
+		statusCodeLabel: "status"
+	},
+	health: {
+		title: "Server Health",
+		status(healthy) {
+			return `Status: ${healthy ? "healthy" : "unhealthy"}`;
+		},
+		version(version) {
+			return `Version: ${version}`;
+		}
+	},
+	path: {
+		title: "Current Paths",
+		home(path) {
+			return `Home: ${path}`;
+		},
+		state(path) {
+			return `State: ${path}`;
+		},
+		config(path) {
+			return `Config: ${path}`;
+		},
+		worktree(path) {
+			return `Worktree: ${path}`;
+		},
+		directory(path) {
+			return `Current working directory: ${path}`;
+		}
+	},
+	sessions: {
+		none: "No sessions available in the current project.",
+		title: "Session List",
+		actionTitle: "Session Actions",
+		chooseAction: "Choose what to do with this session.",
+		currentProject(worktree) {
+			return `Current project: ${worktree}`;
+		},
+		currentSession(session) {
+			return `Current session: ${session}`;
+		},
+		selectedSession(session) {
+			return `Selected session: ${session}`;
+		},
+		switched: "Session switched.",
+		created: "Session created.",
+		renamed: "Session renamed.",
+		renameCancelled: "Session rename cancelled.",
+		renameEmpty: "Session name cannot be empty. Send a new name or /cancel.",
+		renameExpired: "The session is no longer available. Run /sessions again.",
+		renamePendingInput: "Waiting for the new session name. Send plain text or /cancel.",
+		renamePrompt(session) {
+			return [
+				`Rename session: ${session}`,
+				"Send the new session name as your next text message.",
+				"Send /cancel to cancel."
+			].join("\n");
+		},
+		switchAction: "Switch",
+		renameAction: "Rename",
+		backToList: "Back",
+		expired: "The session is no longer available. Run /sessions again."
+	},
+	lsp: {
+		none: "No LSP servers detected for the current project.",
+		title: "LSP Servers",
+		currentProject(worktree) {
+			return `Current project: ${worktree}`;
+		},
+		connected: "connected",
+		error: "error"
+	},
+	mcp: {
+		none: "No MCP servers configured for the current project.",
+		title: "MCP Servers",
+		currentProject(worktree) {
+			return `Current project: ${worktree}`;
+		},
+		connected: "connected",
+		disabled: "disabled",
+		needsAuth: "needs auth",
+		failed(error) {
+			return `failed: ${error}`;
+		},
+		needsClientRegistration(error) {
+			return `needs client registration: ${error}`;
+		}
+	},
+	agents: {
+		none: "No agents available.",
+		title: "Agent List",
+		current(agent) {
+			return `Current agent: ${agent}`;
+		},
+		switched: "Agent switched.",
+		expired: "The agent is no longer available. Run /agents again."
+	},
+	models: {
+		none: "No models available.",
+		title: "Model List",
+		configuredOnly: "Only models currently available in OpenCode and connected providers are shown.",
+		current(model) {
+			return `Current model: ${model}`;
+		},
+		switched: "Model switched.",
+		currentReasoningLevel(variant) {
+			return `Current reasoning level: ${variant}`;
+		},
+		reasoningLevel(variant) {
+			return `Reasoning level: ${variant}`;
+		},
+		noReasoningLevels: "This model has no selectable reasoning levels.",
+		reasoningLevelsTitle: "Reasoning Levels",
+		model(model) {
+			return `Model: ${model}`;
+		},
+		modelNumber(modelIndex) {
+			return `Model number: ${modelIndex}`;
+		},
+		expired: "The model is no longer available. Run /model again.",
+		reasoningLevelExpired: "The reasoning level is no longer available. Run /model again.",
+		defaultReasoningLevel: "default"
+	},
+	language: {
+		title: "Language",
+		choose: "Choose the display language for bot menus and replies.",
+		current(label) {
+			return `Current language: ${label}`;
+		},
+		switched: "Language switched.",
+		expired: "The language option is no longer available. Run /language again.",
+		labels: {
+			en: "English",
+			"zh-CN": "Simplified Chinese"
+		}
+	}
+};
+var ZH_CN_BOT_COPY = {
+	commands: {
+		start: "查看欢迎与快速开始",
+		help: "查看命令说明与示例",
+		status: "查看系统状态",
+		new: "新建会话",
+		agents: "查看并切换代理",
+		sessions: "查看并切换会话",
+		cancel: "取消重命名或中止运行中的请求",
+		model: "查看并切换模型",
+		language: "查看并切换语言"
+	},
+	start: { lines: [
+		"# 欢迎使用 opencode-tbot",
+		"",
+		"通过 Telegram 直接和 OpenCode 服务对话。",
+		"",
+		"## 支持的输入",
+		"- 文本消息",
+		"- 图片 (可附带 caption)",
+		"- 语音消息 (需先配置 OpenRouter 语音转写)",
+		"",
+		"## 快速开始",
+		"1. 先运行 `/status` 确认服务状态正常。",
+		"2. 运行 `/new [title]` 创建一个新会话。",
+		"3. 直接发送文本、图片或语音消息。",
+		"",
+		"更多命令和示例请查看 `/help`。"
+	] },
+	help: { lines: [
+		"# 帮助",
+		"",
+		"使用这个机器人可以通过 Telegram 与 OpenCode 对话。",
+		"",
+		"## 命令",
+		"- `/status` 查看服务、工作区、MCP 和 LSP 状态",
+		"- `/new [title]` 创建一个新会话",
+		"- `/sessions` 查看、切换或重命名会话",
+		"- `/agents` 查看并切换代理",
+		"- `/model` 查看并切换模型与推理级别",
+		"- `/language` 切换机器人的显示语言",
+		"- `/cancel` 取消会话重命名或中止当前请求",
+		"",
+		"## 示例",
+		"- `/new bug triage`",
+		"- 直接发送一条文本消息",
+		"- 发送一张带 caption 的图片",
+		"- 如果已配置 OpenRouter 语音转写，直接发送语音消息"
+	] },
+	systemStatus: { title: "系统状态" },
+	common: {
+		notSelected: "未选择",
+		openCodeDefault: "未选择（使用 OpenCode 默认值）",
+		previousPage: "上一页",
+		nextPage: "下一页",
+		page(currentPage, totalPages) {
+			return `第 ${currentPage}/${totalPages} 页`;
+		}
+	},
+	status: {
+		processing: "处理中...",
+		alreadyProcessing: "另一个请求仍在运行。请等待其完成后再发送新的提示词。"
+	},
+	prompt: { emptyResponse: "OpenCode 返回了空响应。" },
+	replyMetrics: {
+		durationLabel: "耗时",
+		tokensLabel: "令牌数",
+		totalLabel: "总计",
+		inputLabel: "输入",
+		outputLabel: "输出",
+		reasoningLabel: "推理",
+		cacheReadLabel: "缓存读取",
+		cacheWriteLabel: "缓存写入",
+		notAvailable: "不可用"
+	},
+	abort: {
+		noSession: "当前聊天还没有绑定活动会话。",
+		notRunning: "当前会话没有正在运行的请求。",
+		aborted: "已向当前会话发送中止信号。"
+	},
+	errors: {
+		unexpected: "发生未知错误。",
+		providerAuth: "Provider 认证失败。",
+		requestAborted: "请求已中止。",
+		structuredOutput: "结构化输出校验失败。",
+		voiceNotConfigured: "未配置语音转写服务。",
+		voiceDownload: "下载 Telegram 语音文件失败。",
+		voiceTranscription: "语音转写失败。",
+		voiceEmpty: "语音转写结果为空。",
+		voiceUnsupported: "语音文件过大或不受支持。",
+		imageDownload: "下载 Telegram 图片文件失败。",
+		imageUnsupported: "图片文件过大或不受支持。",
+		outputLength: "回复触发了模型输出长度上限。",
+		contextOverflow: "会话已超过模型上下文窗口。",
+		providerRequest: "Provider 请求失败。",
+		notFound: "请求的资源不存在。",
+		badRequest: "OpenCode 拒绝了该请求。",
+		causeLabel: "原因",
+		retryableLabel: "可重试",
+		statusCodeLabel: "状态码"
+	},
+	health: {
+		title: "服务健康状态",
+		status(healthy) {
+			return `状态: ${healthy ? "健康" : "异常"}`;
+		},
+		version(version) {
+			return `版本: ${version}`;
+		}
+	},
+	path: {
+		title: "当前路径",
+		home(path) {
+			return `主目录: ${path}`;
+		},
+		state(path) {
+			return `状态目录: ${path}`;
+		},
+		config(path) {
+			return `配置文件: ${path}`;
+		},
+		worktree(path) {
+			return `工作树: ${path}`;
+		},
+		directory(path) {
+			return `当前工作目录: ${path}`;
+		}
+	},
+	sessions: {
+		none: "当前项目下没有可用会话。",
+		title: "会话列表",
+		actionTitle: "会话操作",
+		chooseAction: "请选择对该会话执行的操作。",
+		currentProject(worktree) {
+			return `当前项目: ${worktree}`;
+		},
+		currentSession(session) {
+			return `当前会话: ${session}`;
+		},
+		selectedSession(session) {
+			return `目标会话: ${session}`;
+		},
+		switched: "会话已切换。",
+		created: "会话已创建。",
+		renamed: "会话已重命名。",
+		renameCancelled: "已取消会话重命名。",
+		renameEmpty: "会话名称不能为空。请重新发送名称或发送 /cancel。",
+		renameExpired: "该会话已不可用。请重新运行 /sessions。",
+		renamePendingInput: "当前正在等待新的会话名称。请发送纯文本或 /cancel。",
+		renamePrompt(session) {
+			return [
+				`重命名会话: ${session}`,
+				"请发送新的会话名称。",
+				"发送 /cancel 取消。"
+			].join("\n");
+		},
+		switchAction: "切换",
+		renameAction: "重命名",
+		backToList: "返回列表",
+		expired: "该会话已不可用。请重新运行 /sessions。"
+	},
+	lsp: {
+		none: "当前项目未检测到 LSP。",
+		title: "LSP 服务",
+		currentProject(worktree) {
+			return `当前项目: ${worktree}`;
+		},
+		connected: "已连接",
+		error: "异常"
+	},
+	mcp: {
+		none: "当前项目未配置 MCP。",
+		title: "MCP 服务",
+		currentProject(worktree) {
+			return `当前项目: ${worktree}`;
+		},
+		connected: "已连接",
+		disabled: "已禁用",
+		needsAuth: "需要认证",
+		failed(error) {
+			return `失败: ${error}`;
+		},
+		needsClientRegistration(error) {
+			return `需要客户端注册: ${error}`;
+		}
+	},
+	agents: {
+		none: "没有可用代理。",
+		title: "代理列表",
+		current(agent) {
+			return `当前代理: ${agent}`;
+		},
+		switched: "代理已切换。",
+		expired: "该代理已不可用。请重新运行 /agents。"
+	},
+	models: {
+		none: "没有可用模型。",
+		title: "模型列表",
+		configuredOnly: "仅显示当前在 OpenCode 和已连接 provider 中实际可用的模型。",
+		current(model) {
+			return `当前模型: ${model}`;
+		},
+		switched: "模型已切换。",
+		currentReasoningLevel(variant) {
+			return `当前推理级别: ${variant}`;
+		},
+		reasoningLevel(variant) {
+			return `推理级别: ${variant}`;
+		},
+		noReasoningLevels: "该模型没有可选的推理级别。",
+		reasoningLevelsTitle: "推理级别",
+		model(model) {
+			return `模型: ${model}`;
+		},
+		modelNumber(modelIndex) {
+			return `模型编号: ${modelIndex}`;
+		},
+		expired: "该模型已不可用。请重新运行 /model。",
+		reasoningLevelExpired: "该推理级别已不可用。请重新运行 /model。",
+		defaultReasoningLevel: "默认"
+	},
+	language: {
+		title: "语言",
+		choose: "选择机器人菜单和回复信息的显示语言。",
+		current(label) {
+			return `当前语言: ${label}`;
+		},
+		switched: "语言已切换。",
+		expired: "该语言选项已不可用。请重新运行 /language。",
+		labels: {
+			en: "English",
+			"zh-CN": "简体中文"
+		}
+	}
+};
+var BOT_COPY = EN_BOT_COPY;
+function isBotLanguage(value) {
+	return SUPPORTED_BOT_LANGUAGES.includes(value);
+}
+function normalizeBotLanguage(value) {
+	if (!value) return "en";
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "zh-cn" || normalized === "zh-hans" || normalized === "zh") return "zh-CN";
+	return "en";
+}
+function getBotCopy(language = "en") {
+	return normalizeBotLanguage(language) === "zh-CN" ? ZH_CN_BOT_COPY : EN_BOT_COPY;
+}
+function getLanguageLabel(language, copy = BOT_COPY) {
+	return copy.language.labels[language];
+}
+//#endregion
+//#region src/bot/commands/command-list.ts
+function getTelegramCommands(language = "en") {
+	const copy = getBotCopy(language);
+	return [
+		{
+			command: "start",
+			description: copy.commands.start
+		},
+		{
+			command: "help",
+			description: copy.commands.help
+		},
+		{
+			command: "status",
+			description: copy.commands.status
+		},
+		{
+			command: "new",
+			description: copy.commands.new
+		},
+		{
+			command: "agents",
+			description: copy.commands.agents
+		},
+		{
+			command: "sessions",
+			description: copy.commands.sessions
+		},
+		{
+			command: "cancel",
+			description: copy.commands.cancel
+		},
+		{
+			command: "model",
+			description: copy.commands.model
+		},
+		{
+			command: "language",
+			description: copy.commands.language
+		}
+	];
+}
+var TELEGRAM_COMMANDS = getTelegramCommands();
+//#endregion
+//#region src/bot/commands/sync-commands.ts
+var TELEGRAM_COMMAND_SYNC_SCOPES = [{ type: "default" }, { type: "all_private_chats" }];
+async function syncTelegramCommands(bot, logger) {
+	await Promise.all(TELEGRAM_COMMAND_SYNC_SCOPES.map((scope) => bot.api.setMyCommands(TELEGRAM_COMMANDS, { scope })));
+	logger.info({
+		commands: TELEGRAM_COMMANDS.map((command) => command.command),
+		scopes: TELEGRAM_COMMAND_SYNC_SCOPES.map((scope) => scope.type)
+	}, "telegram commands synced");
+}
+async function syncTelegramCommandsForChat(api, chatId, language) {
+	await api.setMyCommands(getTelegramCommands(language), { scope: {
+		type: "chat",
+		chat_id: chatId
+	} });
+}
+//#endregion
+//#region src/bot/i18n.ts
+async function getChatLanguage(sessionRepo, chatId) {
+	if (!chatId) return "en";
+	return normalizeBotLanguage((await sessionRepo.getByChatId(chatId))?.language);
+}
+async function getChatCopy(sessionRepo, chatId) {
+	return getBotCopy(await getChatLanguage(sessionRepo, chatId));
+}
+async function setChatLanguage(sessionRepo, chatId, language) {
+	const binding = await sessionRepo.getByChatId(chatId);
+	await sessionRepo.setCurrent({
+		chatId,
+		sessionId: binding?.sessionId ?? null,
+		projectId: binding?.projectId ?? null,
+		directory: binding?.directory ?? null,
+		agentName: binding?.agentName ?? null,
+		modelProviderId: binding?.modelProviderId ?? null,
+		modelId: binding?.modelId ?? null,
+		modelVariant: binding?.modelVariant ?? null,
+		language,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+var NUMBERED_BUTTONS_PER_ROW = 5;
+function buildModelsKeyboard(models, requestedPage, copy = BOT_COPY) {
+	const page = getModelsPage(models, requestedPage);
+	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (_, index) => `model:pick:${page.startIndex + index + 1}`);
+	appendPaginationButtons(keyboard, page.page, page.totalPages, "model:page", copy);
+	return {
+		keyboard,
+		page
+	};
+}
+function buildAgentsKeyboard(agents, requestedPage, copy = BOT_COPY) {
+	const page = getAgentsPage(agents, requestedPage);
+	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (_, index) => `agents:select:${page.startIndex + index + 1}`);
+	appendPaginationButtons(keyboard, page.page, page.totalPages, "agents:page", copy);
+	return {
+		keyboard,
+		page
+	};
+}
+function buildSessionsKeyboard(sessions, requestedPage, copy = BOT_COPY) {
+	const page = getSessionsPage(sessions, requestedPage);
+	const keyboard = buildNumberedKeyboard(page.items, page.startIndex, (session) => `sessions:pick:${page.page}:${session.id}`);
+	appendPaginationButtons(keyboard, page.page, page.totalPages, "sessions:page", copy);
+	return {
+		keyboard,
+		page
+	};
+}
+function buildSessionActionKeyboard(sessionId, page, copy = BOT_COPY) {
+	return new InlineKeyboard().text(copy.sessions.switchAction, `sessions:switch:${page}:${sessionId}`).text(copy.sessions.renameAction, `sessions:rename:${page}:${sessionId}`).row().text(copy.sessions.backToList, `sessions:back:${page}`);
+}
+function buildModelVariantsKeyboard(variants, modelIndex) {
+	return buildNumberedKeyboard(variants, 0, (_, index) => `model:variant:${modelIndex}:${index + 1}`);
+}
+function buildLanguageKeyboard(currentLanguage, copy = BOT_COPY) {
+	const keyboard = new InlineKeyboard();
+	SUPPORTED_BOT_LANGUAGES.forEach((language, index) => {
+		const label = currentLanguage === language ? `[${getLanguageLabel(language, copy)}]` : getLanguageLabel(language, copy);
+		keyboard.text(label, `language:select:${language}`);
+		if (index !== SUPPORTED_BOT_LANGUAGES.length - 1) keyboard.row();
+	});
+	return keyboard;
+}
+function getModelsPage(models, requestedPage) {
+	return getPagedItems(models, requestedPage, 10);
+}
+function getAgentsPage(agents, requestedPage) {
+	return getPagedItems(agents, requestedPage, 10);
+}
+function getSessionsPage(sessions, requestedPage) {
+	return getPagedItems(sessions, requestedPage, 10);
+}
+function buildNumberedKeyboard(items, startIndex, buildCallbackData) {
+	const keyboard = new InlineKeyboard();
+	items.forEach((item, index) => {
+		const displayIndex = startIndex + index + 1;
+		keyboard.text(`${displayIndex}`, buildCallbackData(item, index));
+		if (index !== items.length - 1 && (index + 1) % NUMBERED_BUTTONS_PER_ROW === 0) keyboard.row();
+	});
+	return keyboard;
+}
+function appendPaginationButtons(keyboard, page, totalPages, prefix, copy) {
+	if (totalPages <= 1) return;
+	if (page > 0) keyboard.text(copy.common.previousPage, `${prefix}:${page - 1}`);
+	if (page < totalPages - 1) keyboard.text(copy.common.nextPage, `${prefix}:${page + 1}`);
+}
+function getPagedItems(items, requestedPage, pageSize) {
+	const totalPages = Math.max(1, Math.ceil(items.length / pageSize));
+	const page = clampPage(requestedPage, totalPages);
+	const startIndex = page * pageSize;
+	return {
+		items: items.slice(startIndex, startIndex + pageSize),
+		page,
+		startIndex,
+		totalPages
+	};
+}
+function clampPage(page, totalPages) {
+	if (!Number.isInteger(page) || page < 0) return 0;
+	return Math.min(page, totalPages - 1);
+}
+//#endregion
+//#region src/bot/presenters/error.presenter.ts
+function presentError(error, copy = BOT_COPY) {
+	const presented = normalizeError(error, copy);
+	return presented.cause ? `${presented.message}\n${copy.errors.causeLabel}: ${presented.cause}` : presented.message;
+}
+function normalizeError(error, copy) {
+	if (isNamedError(error, "ProviderAuthError")) return {
+		message: copy.errors.providerAuth,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "MessageAbortedError")) return {
+		message: copy.errors.requestAborted,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "StructuredOutputError")) return {
+		message: copy.errors.structuredOutput,
+		cause: joinNonEmptyParts([extractMessage(error.data), extractRetries(error.data)])
+	};
+	if (isNamedError(error, "VoiceTranscriptionNotConfiguredError")) return {
+		message: copy.errors.voiceNotConfigured,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "TelegramFileDownloadError")) return {
+		message: copy.errors.voiceDownload,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "VoiceTranscriptionFailedError")) return {
+		message: copy.errors.voiceTranscription,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "VoiceTranscriptEmptyError")) return {
+		message: copy.errors.voiceEmpty,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "VoiceMessageUnsupportedError")) return {
+		message: copy.errors.voiceUnsupported,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "ImageFileDownloadError")) return {
+		message: copy.errors.imageDownload,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "ImageMessageUnsupportedError")) return {
+		message: copy.errors.imageUnsupported,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "MessageOutputLengthError")) return {
+		message: copy.errors.outputLength,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "ContextOverflowError")) return {
+		message: copy.errors.contextOverflow,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isNamedError(error, "APIError")) return {
+		message: copy.errors.providerRequest,
+		cause: joinNonEmptyParts([
+			extractMessage(error.data),
+			extractStatusCode(error.data, copy),
+			extractRetryable(error.data, copy)
+		])
+	};
+	if (isNamedError(error, "NotFoundError")) return {
+		message: copy.errors.notFound,
+		cause: extractMessage(error.data) ?? null
+	};
+	if (isBadRequestError(error)) return {
+		message: copy.errors.badRequest,
+		cause: extractBadRequestCause(error)
+	};
+	if (error instanceof Error) return {
+		message: error.name === "AbortError" ? copy.errors.requestAborted : copy.errors.unexpected,
+		cause: error.message || null
+	};
+	return {
+		message: copy.errors.unexpected,
+		cause: extractMessage(error) ?? stringifyUnknown(error)
+	};
+}
+function isBadRequestError(error) {
+	return !!error && typeof error === "object" && "success" in error && error.success === false;
+}
+function isNamedError(error, name) {
+	return !!error && typeof error === "object" && "name" in error && error.name === name;
+}
+function extractBadRequestCause(error) {
+	const directMessage = extractMessage(error.data);
+	if (directMessage) return directMessage;
+	return Array.isArray(error.errors) && error.errors.length > 0 ? stringifyUnknown(error.errors[0]) : null;
+}
+function extractMessage(value) {
+	if (!value) return null;
+	if (typeof value === "string") return value.trim() || null;
+	if (typeof value === "object" && "message" in value) {
+		const message = value.message;
+		return typeof message === "string" && message.trim().length > 0 ? message.trim() : null;
+	}
+	return null;
+}
+function extractRetries(value) {
+	if (!value || typeof value !== "object" || !("retries" in value)) return null;
+	const retries = value.retries;
+	return typeof retries === "number" && Number.isFinite(retries) ? `retries: ${Math.round(retries)}` : null;
+}
+function extractRetryable(value, copy) {
+	if (!value || typeof value !== "object" || !("isRetryable" in value)) return null;
+	const isRetryable = value.isRetryable;
+	return typeof isRetryable === "boolean" ? `${copy.errors.retryableLabel}: ${isRetryable ? "yes" : "no"}` : null;
+}
+function extractStatusCode(value, copy) {
+	if (!value || typeof value !== "object" || !("statusCode" in value)) return null;
+	const statusCode = value.statusCode;
+	return typeof statusCode === "number" && Number.isFinite(statusCode) ? `${copy.errors.statusCodeLabel}: ${Math.round(statusCode)}` : null;
+}
+function joinNonEmptyParts(parts) {
+	const filtered = parts.map((part) => part?.trim()).filter((part) => !!part);
+	return filtered.length > 0 ? filtered.join(" | ") : null;
+}
+function stringifyUnknown(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string") return value.trim() || null;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	try {
+		const text = JSON.stringify(value);
+		return text && text !== "{}" ? text : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/bot/presenters/message.presenter.ts
+var VARIANT_ORDER = [
+	"minimal",
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function presentStatusMessage(input, copy = BOT_COPY) {
+	const layout = getStatusLayoutCopy(copy);
+	const sections = [
+		presentStatusPlainSection(layout.serverTitle, presentStatusPlainServerLines(input, copy, layout)),
+		presentStatusPlainSection(layout.workspaceTitle, presentStatusPlainWorkspaceLines(input, copy, layout)),
+		presentStatusPlainSection(layout.mcpTitle, presentStatusPlainMcpLines(input, copy, layout)),
+		presentStatusPlainSection(layout.lspTitle, presentStatusPlainLspLines(input, copy, layout)),
+		layout.divider,
+		`${layout.lastUpdatedLabel}: ${formatStatusDate(/* @__PURE__ */ new Date())}`
+	];
+	return presentStatusSections(layout.pageTitle, sections);
+}
+function presentStatusMarkdownMessage(input, copy = BOT_COPY) {
+	const layout = getStatusLayoutCopy(copy);
+	const sections = [
+		presentStatusMarkdownSection(layout.serverTitle, presentStatusMarkdownServerLines(input, copy, layout)),
+		presentStatusMarkdownSection(layout.workspaceTitle, presentStatusMarkdownWorkspaceLines(input, copy, layout)),
+		presentStatusMarkdownSection(layout.mcpTitle, presentStatusMarkdownMcpLines(input, copy, layout)),
+		presentStatusMarkdownSection(layout.lspTitle, presentStatusMarkdownLspLines(input, copy, layout)),
+		layout.divider,
+		`_${layout.lastUpdatedLabel}: ${formatStatusDate(/* @__PURE__ */ new Date())}_`
+	];
+	return presentStatusSections(`# ${layout.pageTitle}`, sections);
+}
+function presentStatusSections(title, sections) {
+	return [
+		title,
+		"",
+		...sections.flatMap((section, index) => index === 0 ? [section] : ["", section])
+	].join("\n");
+}
+function presentStatusPlainSection(title, lines) {
+	return [title, ...lines].join("\n");
+}
+function presentStatusMarkdownSection(title, lines) {
+	return [`## ${title}`, ...lines].join("\n");
+}
+function presentStatusPlainServerLines(input, copy, layout) {
+	if (input.health.status === "error") return presentStatusPlainErrorLines(input.health.error, copy, layout);
+	return [presentPlainStatusBullet(layout.statusLabel, formatHealthBadge(input.health.data.healthy, layout)), presentPlainStatusBullet(layout.versionLabel, input.health.data.version)];
+}
+function presentStatusMarkdownServerLines(input, copy, layout) {
+	if (input.health.status === "error") return presentStatusMarkdownErrorLines(input.health.error, copy, layout);
+	return [presentMarkdownStatusBullet(layout.statusLabel, formatHealthBadge(input.health.data.healthy, layout)), presentMarkdownStatusBullet(layout.versionLabel, input.health.data.version)];
+}
+function presentStatusPlainWorkspaceLines(input, copy, layout) {
+	if (input.path.status === "error") return presentStatusPlainErrorLines(input.path.error, copy, layout);
+	return [presentPlainStatusBullet(layout.currentDirectoryLabel, input.path.data.directory)];
+}
+function presentStatusMarkdownWorkspaceLines(input, copy, layout) {
+	if (input.path.status === "error") return presentStatusMarkdownErrorLines(input.path.error, copy, layout);
+	return [presentMarkdownStatusBullet(layout.currentDirectoryLabel, input.path.data.directory, { codeValue: true })];
+}
+function presentStatusPlainLspLines(input, copy, layout) {
+	return buildPlainStatusTable([
+		layout.languageLabel,
+		layout.statusLabel,
+		layout.rootLabel
+	], buildLspStatusRows(input, copy, layout));
+}
+function presentStatusMarkdownLspLines(input, copy, layout) {
+	return buildMarkdownStatusTable([
+		layout.languageLabel,
+		layout.statusLabel,
+		layout.rootLabel
+	], buildLspStatusRows(input, copy, layout));
+}
+function presentStatusPlainMcpLines(input, copy, layout) {
+	return buildPlainStatusTable([
+		layout.serviceLabel,
+		layout.statusLabel,
+		layout.mcpNotesLabel
+	], buildMcpStatusRows(input, copy, layout));
+}
+function presentStatusMarkdownMcpLines(input, copy, layout) {
+	return buildMarkdownStatusTable([
+		layout.serviceLabel,
+		layout.statusLabel,
+		layout.mcpNotesLabel
+	], buildMcpStatusRows(input, copy, layout));
+}
+function buildLspStatusRows(input, copy, layout) {
+	if (input.lsp.status === "error") return [[
+		"-",
+		layout.errorStatus,
+		flattenStatusError(input.lsp.error, copy)
+	]];
+	if (input.lsp.data.statuses.length === 0) return [[
+		"-",
+		layout.noneStatus,
+		copy.lsp.none
+	]];
+	return input.lsp.data.statuses.map((status) => [
+		status.name,
+		formatLspStatusBadge(status, copy),
+		status.root || "-"
+	]);
+}
+function buildMcpStatusRows(input, copy, layout) {
+	if (input.mcp.status === "error") return [[
+		"-",
+		layout.errorStatus,
+		flattenStatusError(input.mcp.error, copy)
+	]];
+	if (input.mcp.data.statuses.length === 0) return [[
+		"-",
+		layout.noneStatus,
+		copy.mcp.none
+	]];
+	return input.mcp.data.statuses.map(({ name, status }) => [
+		name,
+		formatMcpStatusBadge(status, copy, layout),
+		formatMcpStatusNotes(status, layout)
+	]);
+}
+function buildPlainStatusTable(headers, rows) {
+	return [
+		formatPlainTableRow(headers),
+		formatPlainTableSeparator(headers.length),
+		...rows.map((row) => formatPlainTableRow(row))
+	];
+}
+function buildMarkdownStatusTable(headers, rows) {
+	return [
+		`| ${headers.map(sanitizeTableCell).join(" | ")} |`,
+		`| ${headers.map(() => "---").join(" | ")} |`,
+		...rows.map((row) => `| ${row.map(sanitizeTableCell).join(" | ")} |`)
+	];
+}
+function formatPlainTableRow(columns) {
+	return `| ${columns.map(sanitizeTableCell).join(" | ")} |`;
+}
+function formatPlainTableSeparator(columnCount) {
+	return `| ${Array.from({ length: columnCount }, () => "---").join(" | ")} |`;
+}
+function sanitizeTableCell(value) {
+	return value.replace(/\r\n?/g, " / ").replace(/\|/g, "/").trim();
+}
+function presentStatusPlainErrorLines(error, copy, layout) {
+	const detailLines = splitStatusLines(presentError(error, copy));
+	return [presentPlainStatusBullet(layout.statusLabel, layout.errorStatus), ...detailLines.map((line) => presentPlainStatusBullet(layout.detailsLabel, line))];
+}
+function presentStatusMarkdownErrorLines(error, copy, layout) {
+	const detailLines = splitStatusLines(presentError(error, copy));
+	return [presentMarkdownStatusBullet(layout.statusLabel, layout.errorStatus), ...detailLines.map((line) => presentMarkdownStatusBullet(layout.detailsLabel, line))];
+}
+function flattenStatusError(error, copy) {
+	return splitStatusLines(presentError(error, copy)).join(" / ");
+}
+function presentPlainStatusBullet(label, value) {
+	return `- ${label}: ${value}`;
+}
+function presentMarkdownStatusBullet(label, value, options = {}) {
+	return options.codeValue ? `- **${label}:** \`${value}\`` : `- **${label}:** ${value}`;
+}
+function splitStatusLines(text) {
+	return text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function formatHealthBadge(healthy, layout) {
+	return healthy ? layout.healthyStatus : layout.errorStatus;
+}
+function formatLspStatusBadge(status, copy) {
+	switch (status.status) {
+		case "connected": return `🟢 ${copy.lsp.connected}`;
+		case "error": return `🔴 ${copy.lsp.error}`;
+	}
+	return status.status;
+}
+function formatMcpStatusBadge(status, copy, layout) {
+	switch (status.status) {
+		case "connected": return `🟢 ${copy.mcp.connected}`;
+		case "disabled": return `⚪ ${copy.mcp.disabled}`;
+		case "needs_auth": return `🟡 ${copy.mcp.needsAuth}`;
+		case "failed": return layout.mcpFailedStatus;
+		case "needs_client_registration": return layout.mcpRegistrationRequiredStatus;
+	}
+	return status;
+}
+function formatMcpStatusNotes(status, layout) {
+	switch (status.status) {
+		case "connected": return layout.okLabel;
+		case "disabled": return "-";
+		case "needs_auth": return "-";
+		case "failed": return status.error;
+		case "needs_client_registration": return status.error;
+	}
+	return status;
+}
+function formatStatusDate(value) {
+	return value.toISOString().slice(0, 10);
+}
+function getStatusLayoutCopy(copy) {
+	if (copy.systemStatus.title === BOT_COPY.systemStatus.title) return {
+		currentDirectoryLabel: "Current Directory",
+		detailsLabel: "Details",
+		divider: "────────────────",
+		errorStatus: "🔴 Unhealthy",
+		healthyStatus: "🟢 Healthy",
+		languageLabel: "Language",
+		lastUpdatedLabel: "Last updated",
+		lspTitle: "🧠 LSP (Language Server)",
+		mcpNotesLabel: "Notes",
+		mcpRegistrationRequiredStatus: "🟡 Registration Required",
+		mcpTitle: "🔌 MCP (Model Context Protocol)",
+		mcpFailedStatus: "🔴 Failed",
+		noneStatus: "⚪ None",
+		okLabel: "OK",
+		pageTitle: "📊 Service Status",
+		rootLabel: "Root",
+		serverTitle: "🖥️ Server",
+		serviceLabel: "Service",
+		statusLabel: "Status",
+		versionLabel: "Version",
+		workspaceTitle: "📁 Workspace"
+	};
+	return {
+		currentDirectoryLabel: "当前目录",
+		detailsLabel: "详情",
+		divider: "────────────────",
+		errorStatus: "🔴 异常",
+		healthyStatus: "🟢 健康",
+		languageLabel: "语言",
+		lastUpdatedLabel: "最后更新",
+		lspTitle: "🧠 LSP (Language Server)",
+		mcpNotesLabel: "说明",
+		mcpRegistrationRequiredStatus: "🟡 需要注册",
+		mcpTitle: "🔌 MCP (Model Context Protocol)",
+		mcpFailedStatus: "🔴 失败",
+		noneStatus: "⚪ 无",
+		okLabel: "正常",
+		pageTitle: "📊 服务状态",
+		rootLabel: "根目录",
+		serverTitle: "🖥️ 服务端",
+		serviceLabel: "服务",
+		statusLabel: "状态",
+		versionLabel: "版本",
+		workspaceTitle: "📁 工作区"
+	};
+}
+function presentSessionsMessage(input, copy = BOT_COPY) {
+	if (input.sessions.length === 0) return copy.sessions.none;
+	const page = getSessionsPage(input.sessions, input.page);
+	const currentSession = input.currentSessionId ? input.sessions.find((session) => session.id === input.currentSessionId) ?? null : null;
+	return [
+		copy.sessions.title,
+		copy.sessions.currentProject(input.currentDirectory),
+		copy.sessions.currentSession(currentSession ? formatSessionLabel(currentSession) : copy.common.notSelected),
+		copy.common.page(page.page + 1, page.totalPages),
+		"",
+		...page.items.map((session, index) => `${page.startIndex + index + 1}. ${formatSessionLabel(session)}`)
+	].join("\n");
+}
+function presentSessionSwitchMessage(session, copy = BOT_COPY) {
+	return [copy.sessions.switched, copy.sessions.currentSession(formatSessionLabel(session))].join("\n");
+}
+function presentSessionCreatedMessage(session, copy = BOT_COPY) {
+	return [copy.sessions.created, copy.sessions.currentSession(formatSessionLabel(session))].join("\n");
+}
+function presentSessionActionsMessage(input, copy = BOT_COPY) {
+	return [
+		copy.sessions.actionTitle,
+		copy.sessions.currentProject(input.currentDirectory),
+		copy.sessions.selectedSession(formatSessionLabel(input.session)),
+		"",
+		copy.sessions.chooseAction
+	].join("\n");
+}
+function presentSessionRenamePromptMessage(session, copy = BOT_COPY) {
+	return copy.sessions.renamePrompt(formatSessionLabel(session));
+}
+function presentSessionRenamedMessage(session, copy = BOT_COPY) {
+	return [copy.sessions.renamed, copy.sessions.currentSession(formatSessionLabel(session))].join("\n");
+}
+function presentAgentsMessage(input, copy = BOT_COPY) {
+	if (input.agents.length === 0) return copy.agents.none;
+	const page = getAgentsPage(input.agents, input.page);
+	const currentAgent = input.currentAgentName ? input.agents.find((agent) => agent.name === input.currentAgentName) ?? null : null;
+	return [
+		copy.agents.title,
+		copy.agents.current(currentAgent ? formatAgentLabel(currentAgent) : copy.common.openCodeDefault),
+		copy.common.page(page.page + 1, page.totalPages),
+		"",
+		...page.items.map((agent, index) => `${page.startIndex + index + 1}. ${formatAgentLabel(agent)}`)
+	].join("\n");
+}
+function presentAgentSwitchMessage(agent, copy = BOT_COPY) {
+	return [copy.agents.switched, copy.agents.current(formatAgentLabel(agent))].join("\n");
+}
+function presentModelsMessage(input, copy = BOT_COPY) {
+	if (input.models.length === 0) return copy.models.none;
+	const page = getModelsPage(input.models, input.page);
+	const currentModel = input.currentModelId && input.currentModelProviderId ? input.models.find((model) => model.id === input.currentModelId && model.providerID === input.currentModelProviderId) ?? null : null;
+	const currentModelLine = currentModel ? formatModelSelection(currentModel, input.currentModelVariant, copy) : copy.common.openCodeDefault;
+	return [
+		copy.models.title,
+		copy.models.configuredOnly,
+		copy.models.current(currentModelLine),
+		copy.common.page(page.page + 1, page.totalPages),
+		"",
+		...page.items.map((model, index) => formatModelListLine(model, page.startIndex + index + 1))
+	].join("\n");
+}
+function presentModelVariantsMessage(model, modelIndex, copy = BOT_COPY) {
+	const variants = getModelVariants(model);
+	if (variants.length === 0) return [copy.models.noReasoningLevels, copy.models.model(formatModelLabel(model))].join("\n");
+	return [
+		copy.models.reasoningLevelsTitle,
+		copy.models.model(formatModelLabel(model)),
+		copy.models.modelNumber(modelIndex),
+		"",
+		...variants.map((variant, index) => `${index + 1}. ${variant}`)
+	].join("\n");
+}
+function presentModelSwitchMessage(model, variant, copy = BOT_COPY) {
+	return [
+		copy.models.switched,
+		copy.models.current(formatModelLabel(model)),
+		copy.models.currentReasoningLevel(variant ?? copy.models.defaultReasoningLevel)
+	].join("\n");
+}
+function presentLanguageMessage(currentLanguage, copy = BOT_COPY) {
+	return [
+		copy.language.title,
+		copy.language.current(getLanguageLabel(currentLanguage, copy)),
+		"",
+		copy.language.choose
+	].join("\n");
+}
+function presentLanguageSwitchMessage(currentLanguage, copy = BOT_COPY) {
+	return [copy.language.switched, copy.language.current(getLanguageLabel(currentLanguage, copy))].join("\n");
+}
+function getModelVariants(model) {
+	return Object.keys(model.variants).sort((left, right) => compareVariantNames(left, right));
+}
+function compareVariantNames(left, right) {
+	const leftIndex = VARIANT_ORDER.indexOf(left);
+	const rightIndex = VARIANT_ORDER.indexOf(right);
+	if (leftIndex === -1 && rightIndex === -1) return left.localeCompare(right);
+	if (leftIndex === -1) return 1;
+	if (rightIndex === -1) return -1;
+	return leftIndex - rightIndex;
+}
+function formatAgentLabel(agent) {
+	return `${agent.name} [${agent.mode}]`;
+}
+function formatModelListLine(model, displayIndex) {
+	return `${displayIndex}. ${formatModelLabel(model)}`;
+}
+function formatModelSelection(model, variant, copy) {
+	return `${formatModelLabel(model)} | ${copy.models.reasoningLevel(variant ?? copy.models.defaultReasoningLevel)}`;
+}
+function formatModelLabel(model) {
+	return `${model.providerName} / ${model.name}`;
+}
+function formatSessionLabel(session) {
+	const title = session.title.trim() || session.slug || session.id;
+	return title === session.slug ? title : `${title} [${session.slug}]`;
+}
+//#endregion
+//#region src/bot/commands/agents.ts
+async function handleAgentsCommand(ctx, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		const result = await dependencies.listAgentsUseCase.execute({ chatId: ctx.chat.id });
+		if (result.agents.length === 0) {
+			await ctx.reply(copy.agents.none);
+			return;
+		}
+		const { keyboard, page } = buildAgentsKeyboard(result.agents, 0, copy);
+		await ctx.reply(presentAgentsMessage({
+			agents: result.agents,
+			currentAgentName: result.currentAgentName,
+			page: page.page
+		}, copy), { reply_markup: keyboard });
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to list agents");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+function registerAgentsCommand(bot, dependencies) {
+	bot.command(["agents", "agent"], async (ctx) => {
+		await handleAgentsCommand(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/bot/sessions-menu.ts
+async function buildSessionsListView(chatId, requestedPage, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, chatId);
+	const result = await dependencies.listSessionsUseCase.execute({ chatId });
+	if (result.sessions.length === 0) return {
+		copy,
+		currentDirectory: result.currentDirectory,
+		currentSessionId: result.currentSessionId,
+		page: 0,
+		sessions: [],
+		text: copy.sessions.none
+	};
+	const { keyboard, page } = buildSessionsKeyboard(result.sessions, requestedPage, copy);
+	return {
+		copy,
+		currentDirectory: result.currentDirectory,
+		currentSessionId: result.currentSessionId,
+		keyboard,
+		page: page.page,
+		sessions: result.sessions,
+		text: presentSessionsMessage({
+			currentDirectory: result.currentDirectory,
+			currentSessionId: result.currentSessionId,
+			page: page.page,
+			sessions: result.sessions
+		}, copy)
+	};
+}
+async function buildSessionActionView(chatId, requestedPage, sessionId, dependencies) {
+	const listView = await buildSessionsListView(chatId, requestedPage, dependencies);
+	const session = listView.sessions.find((item) => item.id === sessionId);
+	if (!session) return {
+		copy: listView.copy,
+		found: false
+	};
+	return {
+		copy: listView.copy,
+		found: true,
+		keyboard: buildSessionActionKeyboard(session.id, listView.page, listView.copy),
+		page: listView.page,
+		session,
+		text: presentSessionActionsMessage({
+			currentDirectory: listView.currentDirectory,
+			session
+		}, listView.copy)
+	};
+}
+async function restoreSessionsListMessage(api, chatId, messageId, requestedPage, dependencies) {
+	const listView = await buildSessionsListView(chatId, requestedPage, dependencies);
+	if (listView.keyboard) await api.editMessageText(chatId, messageId, listView.text, { reply_markup: listView.keyboard });
+	else await api.editMessageText(chatId, messageId, listView.text);
+	return listView;
+}
+//#endregion
+//#region src/bot/session-rename.ts
+async function getPendingSessionRenameAction(dependencies, chatId) {
+	const action = await dependencies.pendingActionRepo.getByChatId(chatId);
+	return isSessionRenamePendingAction(action) ? action : null;
+}
+async function replyIfSessionRenamePending(ctx, dependencies) {
+	if (!await getPendingSessionRenameAction(dependencies, ctx.chat.id)) return false;
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	await ctx.reply(copy.sessions.renamePendingInput);
+	return true;
+}
+async function handlePendingSessionRenameText(ctx, dependencies) {
+	const pendingAction = await getPendingSessionRenameAction(dependencies, ctx.chat.id);
+	if (!pendingAction) return false;
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	const title = ctx.message.text?.trim() ?? "";
+	if (title.startsWith("/")) {
+		await ctx.reply(copy.sessions.renamePendingInput);
+		return true;
+	}
+	if (!title) {
+		await ctx.reply(copy.sessions.renameEmpty);
+		return true;
+	}
+	try {
+		const result = await dependencies.renameSessionUseCase.execute({
+			chatId: ctx.chat.id,
+			sessionId: pendingAction.sessionId,
+			title
+		});
+		await dependencies.pendingActionRepo.clear(ctx.chat.id);
+		await bestEffortRestoreSessionsList(ctx.api, pendingAction, dependencies);
+		if (!result.found) {
+			await ctx.reply(copy.sessions.renameExpired);
+			return true;
+		}
+		await ctx.reply(presentSessionRenamedMessage(result.session, copy));
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to rename session");
+		await ctx.reply(presentError(error, copy));
+	}
+	return true;
+}
+async function cancelPendingSessionRename(ctx, dependencies) {
+	const pendingAction = await getPendingSessionRenameAction(dependencies, ctx.chat.id);
+	if (!pendingAction) return false;
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	await dependencies.pendingActionRepo.clear(ctx.chat.id);
+	await bestEffortRestoreSessionsList(ctx.api, pendingAction, dependencies);
+	await ctx.reply(copy.sessions.renameCancelled);
+	return true;
+}
+async function bestEffortRestoreSessionsList(api, pendingAction, dependencies) {
+	try {
+		await restoreSessionsListMessage(api, pendingAction.chatId, pendingAction.menuMessageId, pendingAction.returnPage, dependencies);
+	} catch (error) {
+		dependencies.logger.warn?.({ error }, "failed to restore sessions list message");
+	}
+}
+function isSessionRenamePendingAction(action) {
+	return action?.kind === "session_rename";
+}
+//#endregion
+//#region src/bot/commands/cancel.ts
+async function handleCancelCommand(ctx, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		if (await cancelPendingSessionRename(ctx, dependencies)) return;
+		const result = await dependencies.abortPromptUseCase.execute({ chatId: ctx.chat.id });
+		if (result.status === "no_session") {
+			await ctx.reply(copy.abort.noSession);
+			return;
+		}
+		if (result.status === "not_running") {
+			await ctx.reply(copy.abort.notRunning);
+			return;
+		}
+		await ctx.reply(copy.abort.aborted);
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to cancel current action");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+function registerCancelCommand(bot, dependencies) {
+	bot.command("cancel", async (ctx) => {
+		await handleCancelCommand(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/services/telegram/telegram-format.ts
+var MAX_TELEGRAM_MESSAGE_LENGTH = 4096;
+var TRUNCATED_SUFFIX = "...";
+var MARKDOWN_SPECIAL_CHARACTERS = /([_*\[\]()~`>#+\-=|{}.!\\])/g;
+function buildTelegramPromptReply(result, copy = BOT_COPY) {
+	const renderedMarkdown = result.bodyMd ? renderMarkdownToTelegramMarkdownV2(result.bodyMd) : null;
+	const footerPlain = formatPlainMetricsFooter(result.metrics, copy);
+	const fallback = { text: joinBodyAndFooter(truncatePlainBody(normalizePlainBody(result, renderedMarkdown !== null, copy), footerPlain), footerPlain) };
+	if (!renderedMarkdown) return {
+		preferred: fallback,
+		fallback
+	};
+	const markdownText = joinBodyAndFooter(renderedMarkdown, formatMarkdownMetricsFooter(result.metrics, copy));
+	if (markdownText.length > MAX_TELEGRAM_MESSAGE_LENGTH) return {
+		preferred: fallback,
+		fallback
+	};
+	return {
+		preferred: {
+			text: markdownText,
+			options: { parse_mode: "MarkdownV2" }
+		},
+		fallback
+	};
+}
+function buildTelegramStaticReply(markdown) {
+	const renderedMarkdown = renderMarkdownToTelegramMarkdownV2(markdown);
+	const fallback = { text: truncateStaticText(stripMarkdownToPlainText(markdown) || markdown.trim()) };
+	if (!renderedMarkdown || renderedMarkdown.length > MAX_TELEGRAM_MESSAGE_LENGTH) return {
+		preferred: fallback,
+		fallback
+	};
+	return {
+		preferred: {
+			text: renderedMarkdown,
+			options: { parse_mode: "MarkdownV2" }
+		},
+		fallback
+	};
+}
+function renderMarkdownToTelegramMarkdownV2(markdown) {
+	const normalizedMarkdown = preprocessMarkdownForTelegram(markdown).trim();
+	if (!normalizedMarkdown) return null;
+	const lines = normalizedMarkdown.split("\n");
+	const rendered = [];
+	let inCodeBlock = false;
+	let codeBlockLanguage = "";
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		const fenceMatch = line.match(/^```([A-Za-z0-9_-]+)?\s*$/);
+		if (fenceMatch) {
+			if (inCodeBlock) {
+				rendered.push("```");
+				inCodeBlock = false;
+				codeBlockLanguage = "";
+			} else {
+				codeBlockLanguage = fenceMatch[1] ?? "";
+				rendered.push(`\`\`\`${codeBlockLanguage}`);
+				inCodeBlock = true;
+			}
+			continue;
+		}
+		if (inCodeBlock) {
+			rendered.push(escapeCodeContent(line));
+			continue;
+		}
+		if (line.includes("![")) return null;
+		const tableBlock = consumeMarkdownTable(lines, index);
+		if (tableBlock) {
+			rendered.push(renderTableAsTelegramCodeBlock(tableBlock.rows));
+			index = tableBlock.nextIndex - 1;
+			continue;
+		}
+		if (/<[/A-Za-z][^>]*>/.test(line)) return null;
+		if (!line.trim()) {
+			rendered.push("");
+			continue;
+		}
+		const headingMatch = line.match(/^\s{0,3}(#{1,6})\s+(.+)$/);
+		if (headingMatch) {
+			rendered.push(`*${escapeMarkdownText(headingMatch[2].trim())}*`);
+			continue;
+		}
+		const blockquoteMatch = line.match(/^\s*>\s?(.*)$/);
+		if (blockquoteMatch) {
+			const quote = renderInlineMarkdown(blockquoteMatch[1]);
+			if (quote === null) return null;
+			rendered.push(`>${quote ? ` ${quote}` : ""}`);
+			continue;
+		}
+		const unorderedListMatch = line.match(/^(\s*)[-+*]\s+(.+)$/);
+		if (unorderedListMatch) {
+			const item = renderInlineMarkdown(unorderedListMatch[2]);
+			if (item === null) return null;
+			rendered.push(`${unorderedListMatch[1]}\\- ${item}`);
+			continue;
+		}
+		const orderedListMatch = line.match(/^(\s*)(\d+)[.)]\s+(.+)$/);
+		if (orderedListMatch) {
+			const item = renderInlineMarkdown(orderedListMatch[3]);
+			if (item === null) return null;
+			rendered.push(`${orderedListMatch[1]}${orderedListMatch[2]}\\. ${item}`);
+			continue;
+		}
+		const paragraph = renderInlineMarkdown(line);
+		if (paragraph === null) return null;
+		rendered.push(paragraph);
+	}
+	if (inCodeBlock) return null;
+	return rendered.join("\n");
+}
+function stripMarkdownToPlainText(markdown) {
+	const lines = preprocessMarkdownForTelegram(markdown).split("\n");
+	const rendered = [];
+	for (let index = 0; index < lines.length; index += 1) {
+		const tableBlock = consumeMarkdownTable(lines, index);
+		if (tableBlock) {
+			rendered.push(renderTableAsPlainText(tableBlock.rows));
+			index = tableBlock.nextIndex - 1;
+			continue;
+		}
+		rendered.push(lines[index]);
+	}
+	return rendered.join("\n").replace(/```[A-Za-z0-9_-]*\n?/g, "").replace(/```/g, "").replace(/^#{1,6}\s+/gm, "").replace(/^\s*>\s?/gm, "").replace(/^(\s*)[-+*]\s+/gm, "$1- ").replace(/^(\s*)(\d+)[.)]\s+/gm, "$1$2. ").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)").replace(/(\*\*|__)(.*?)\1/g, "$2").replace(/(\*|_)(.*?)\1/g, "$2").replace(/`([^`]+)`/g, "$1").trim();
+}
+function normalizePlainBody(result, preferStructured, copy) {
+	const fromStructured = result.bodyMd ? stripMarkdownToPlainText(result.bodyMd) : "";
+	const fromFallback = result.fallbackText.trim();
+	return (preferStructured ? fromStructured || fromFallback : fromFallback || fromStructured).trim() || result.fallbackText || copy.prompt.emptyResponse;
+}
+function truncatePlainBody(body, footer) {
+	const reservedLength = footer.length + 2;
+	const maxBodyLength = Math.max(0, MAX_TELEGRAM_MESSAGE_LENGTH - reservedLength);
+	if (body.length <= maxBodyLength) return body;
+	return `${body.slice(0, Math.max(0, maxBodyLength - 3))}${TRUNCATED_SUFFIX}`;
+}
+function truncateStaticText(text) {
+	if (text.length <= MAX_TELEGRAM_MESSAGE_LENGTH) return text;
+	return `${text.slice(0, Math.max(0, MAX_TELEGRAM_MESSAGE_LENGTH - 3))}${TRUNCATED_SUFFIX}`;
+}
+function joinBodyAndFooter(body, footer) {
+	return `${body}\n\n${footer}`;
+}
+function preprocessMarkdownForTelegram(markdown) {
+	const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+	const processed = [];
+	let activeFence = null;
+	for (const line of lines) {
+		const fenceMatch = line.match(/^```([A-Za-z0-9_-]+)?\s*$/);
+		if (fenceMatch) {
+			const language = (fenceMatch[1] ?? "").toLowerCase();
+			if (activeFence === "markdown") {
+				activeFence = null;
+				continue;
+			}
+			if (activeFence === "plain") {
+				processed.push(line);
+				activeFence = null;
+				continue;
+			}
+			if (language === "md" || language === "markdown") {
+				activeFence = "markdown";
+				continue;
+			}
+			activeFence = "plain";
+			processed.push(line);
+			continue;
+		}
+		processed.push(line);
+	}
+	return processed.join("\n");
+}
+function formatPlainMetricsFooter(metrics, copy) {
+	return `${copy.replyMetrics.durationLabel}: ${formatDuration(metrics.durationMs, copy)} | ${copy.replyMetrics.tokensLabel}: ${formatMetricValue(metrics.tokens.total, copy)}`;
+}
+function formatMarkdownMetricsFooter(metrics, copy) {
+	return escapeMarkdownText(formatPlainMetricsFooter(metrics, copy));
+}
+function formatDuration(durationMs, copy) {
+	if (durationMs === null || !Number.isFinite(durationMs)) return copy.replyMetrics.notAvailable;
+	if (durationMs < 1e3) return `${Math.round(durationMs)} ms`;
+	return `${(durationMs / 1e3).toFixed(1)} s`;
+}
+function formatMetricValue(value, copy) {
+	if (value === null || !Number.isFinite(value)) return copy.replyMetrics.notAvailable;
+	return `${Math.round(value)}`;
+}
+function consumeMarkdownTable(lines, startIndex) {
+	if (startIndex + 1 >= lines.length) return null;
+	const headerCells = parseMarkdownTableRow(lines[startIndex]);
+	const separatorCells = parseMarkdownTableSeparator(lines[startIndex + 1]);
+	if (!headerCells || !separatorCells || headerCells.length !== separatorCells.length) return null;
+	const rows = [headerCells];
+	let index = startIndex + 2;
+	while (index < lines.length) {
+		const rowCells = parseMarkdownTableRow(lines[index]);
+		if (!rowCells || rowCells.length !== headerCells.length) break;
+		rows.push(rowCells);
+		index += 1;
+	}
+	return {
+		rows,
+		nextIndex: index
+	};
+}
+function parseMarkdownTableRow(line) {
+	const trimmed = line.trim();
+	if (!trimmed.includes("|")) return null;
+	const cells = splitMarkdownTableCells(trimmed).map((cell) => normalizeTableCell(cell));
+	return cells.length >= 2 ? cells : null;
+}
+function parseMarkdownTableSeparator(line) {
+	const cells = splitMarkdownTableCells(line.trim());
+	if (cells.length < 2) return null;
+	return cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim())) ? cells : null;
+}
+function splitMarkdownTableCells(line) {
+	const content = line.replace(/^\|/, "").replace(/\|$/, "");
+	const cells = [];
+	let current = "";
+	let escaped = false;
+	for (const char of content) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			current += char;
+			continue;
+		}
+		if (char === "|") {
+			cells.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	cells.push(current);
+	return cells;
+}
+function normalizeTableCell(cell) {
+	return cell.trim().replace(/\\\|/g, "|").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)").replace(/(\*\*|__)(.*?)\1/g, "$2").replace(/(\*|_)(.*?)\1/g, "$2").replace(/`([^`]+)`/g, "$1");
+}
+function renderTableAsTelegramCodeBlock(rows) {
+	return [
+		"```",
+		...buildAlignedTableLines(rows).map((line) => escapeCodeContent(line)),
+		"```"
+	].join("\n");
+}
+function renderTableAsPlainText(rows) {
+	return buildAlignedTableLines(rows).join("\n");
+}
+function buildAlignedTableLines(rows) {
+	const columnWidths = calculateTableColumnWidths(rows);
+	return [
+		formatTableRow(rows[0], columnWidths),
+		columnWidths.map((width) => "-".repeat(Math.max(3, width))).join("-+-"),
+		...rows.slice(1).map((row) => formatTableRow(row, columnWidths))
+	];
+}
+function calculateTableColumnWidths(rows) {
+	return rows[0].map((_, columnIndex) => rows.reduce((maxWidth, row) => Math.max(maxWidth, getDisplayWidth(row[columnIndex] ?? "")), 0));
+}
+function formatTableRow(row, columnWidths) {
+	return row.map((cell, index) => padDisplayWidth(cell, columnWidths[index] ?? 0)).join(" | ");
+}
+function padDisplayWidth(value, targetWidth) {
+	const padding = Math.max(0, targetWidth - getDisplayWidth(value));
+	return `${value}${" ".repeat(padding)}`;
+}
+function getDisplayWidth(value) {
+	let width = 0;
+	for (const char of value) width += isWideCharacter(char.codePointAt(0) ?? 0) ? 2 : 1;
+	return width;
+}
+function isWideCharacter(codePoint) {
+	return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510);
+}
+function renderInlineMarkdown(input) {
+	let output = "";
+	let cursor = 0;
+	while (cursor < input.length) {
+		if (input.startsWith("![", cursor)) return null;
+		if (input.startsWith("**", cursor) || input.startsWith("__", cursor)) {
+			const delimiter = input.slice(cursor, cursor + 2);
+			const closingIndex = input.indexOf(delimiter, cursor + 2);
+			if (closingIndex > cursor + 2) {
+				output += `*${escapeMarkdownText(input.slice(cursor + 2, closingIndex))}*`;
+				cursor = closingIndex + 2;
+				continue;
+			}
+		}
+		if (input[cursor] === "*" || input[cursor] === "_") {
+			const delimiter = input[cursor];
+			const closingIndex = input.indexOf(delimiter, cursor + 1);
+			if (closingIndex > cursor + 1) {
+				output += `_${escapeMarkdownText(input.slice(cursor + 1, closingIndex))}_`;
+				cursor = closingIndex + 1;
+				continue;
+			}
+		}
+		if (input[cursor] === "`") {
+			const closingIndex = input.indexOf("`", cursor + 1);
+			if (closingIndex === -1) return null;
+			output += `\`${escapeCodeContent(input.slice(cursor + 1, closingIndex))}\``;
+			cursor = closingIndex + 1;
+			continue;
+		}
+		if (input[cursor] === "[") {
+			const linkMatch = input.slice(cursor).match(/^\[([^\]]+)\]\(([^)\s]+)\)/);
+			if (!linkMatch) return null;
+			output += `[${escapeMarkdownText(linkMatch[1])}](${escapeLinkDestination(linkMatch[2])})`;
+			cursor += linkMatch[0].length;
+			continue;
+		}
+		output += escapeMarkdownText(input[cursor]);
+		cursor += 1;
+	}
+	return output;
+}
+function escapeMarkdownText(text) {
+	return text.replace(MARKDOWN_SPECIAL_CHARACTERS, "\\$1");
+}
+function escapeCodeContent(text) {
+	return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+}
+function escapeLinkDestination(url) {
+	return url.replace(/\\/g, "\\\\").replace(/\)/g, "\\)").replace(/\(/g, "\\(");
+}
+//#endregion
+//#region src/bot/presenters/static.presenter.ts
+function presentStartMarkdownMessage(copy = BOT_COPY) {
+	return copy.start.lines.join("\n");
+}
+function presentHelpMarkdownMessage(copy = BOT_COPY) {
+	return copy.help.lines.join("\n");
+}
+//#endregion
+//#region src/bot/commands/help.ts
+async function handleHelpCommand(ctx, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat?.id);
+	const reply = buildTelegramStaticReply(presentHelpMarkdownMessage(copy));
+	try {
+		await ctx.reply(reply.preferred.text, reply.preferred.options);
+	} catch (error) {
+		if (reply.preferred.options) {
+			dependencies.logger.error({ error }, "failed to send help markdown reply, falling back to plain text");
+			await ctx.reply(reply.fallback.text);
+			return;
+		}
+		dependencies.logger.error({ error }, "failed to show help message");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+function registerHelpCommand(bot, dependencies) {
+	bot.command("help", async (ctx) => {
+		await handleHelpCommand(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/bot/commands/language.ts
+async function handleLanguageCommand(ctx, dependencies) {
+	const language = await getChatLanguage(dependencies.sessionRepo, ctx.chat.id);
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		await syncTelegramCommandsForChat(ctx.api, ctx.chat.id, language);
+		await ctx.reply(presentLanguageMessage(language, copy), { reply_markup: buildLanguageKeyboard(language, copy) });
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to show language options");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+async function switchLanguageForChat(api, chatId, language, dependencies) {
+	const currentCopy = await getChatCopy(dependencies.sessionRepo, chatId);
+	if (!isBotLanguage(language)) return {
+		found: false,
+		copy: currentCopy
+	};
+	await setChatLanguage(dependencies.sessionRepo, chatId, language);
+	await syncTelegramCommandsForChat(api, chatId, language);
+	return {
+		found: true,
+		copy: await getChatCopy(dependencies.sessionRepo, chatId),
+		language
+	};
+}
+async function presentLanguageSwitchForChat(chatId, api, language, dependencies) {
+	const result = await switchLanguageForChat(api, chatId, language, dependencies);
+	if (!result.found) return {
+		found: false,
+		copy: result.copy,
+		text: result.copy.language.expired,
+		keyboard: buildLanguageKeyboard(await getChatLanguage(dependencies.sessionRepo, chatId), result.copy)
+	};
+	return {
+		found: true,
+		copy: result.copy,
+		text: presentLanguageSwitchMessage(result.language, result.copy),
+		keyboard: buildLanguageKeyboard(result.language, result.copy)
+	};
+}
+function registerLanguageCommand(bot, dependencies) {
+	bot.command("language", async (ctx) => {
+		await handleLanguageCommand(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/bot/commands/models.ts
+async function handleModelsCommand(ctx, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		const result = await dependencies.listModelsUseCase.execute({ chatId: ctx.chat.id });
+		if (result.models.length === 0) {
+			await ctx.reply(copy.models.none);
+			return;
+		}
+		const { keyboard, page } = buildModelsKeyboard(result.models, 0, copy);
+		await ctx.reply(presentModelsMessage({
+			currentModelId: result.currentModelId,
+			currentModelProviderId: result.currentModelProviderId,
+			currentModelVariant: result.currentModelVariant,
+			models: result.models,
+			page: page.page
+		}, copy), { reply_markup: keyboard });
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to list models");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+function registerModelsCommand(bot, dependencies) {
+	bot.command(["model", "models"], async (ctx) => {
+		await handleModelsCommand(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/bot/commands/new.ts
+async function handleNewCommand(ctx, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		const title = extractSessionTitle(ctx);
+		const result = await dependencies.createSessionUseCase.execute({
+			chatId: ctx.chat.id,
+			title
+		});
+		await ctx.reply(presentSessionCreatedMessage(result.session, copy));
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to create new session");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+function registerNewCommand(bot, dependencies) {
+	bot.command("new", async (ctx) => {
+		await handleNewCommand(ctx, dependencies);
+	});
+}
+function extractSessionTitle(ctx) {
+	if (typeof ctx.match === "string") {
+		const title = ctx.match.trim();
+		return title ? title : null;
+	}
+	const messageText = ctx.message?.text?.trim();
+	if (!messageText) return null;
+	const title = messageText.match(/^\/new(?:@\S+)?(?:\s+([\s\S]*))?$/i)?.[1]?.trim();
+	return title ? title : null;
+}
+//#endregion
+//#region src/bot/commands/status.ts
+async function handleStatusCommand(ctx, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat?.id);
+	try {
+		const result = await dependencies.getStatusUseCase.execute({ chatId: ctx.chat?.id ?? 0 });
+		const renderedMarkdown = renderMarkdownToTelegramMarkdownV2(presentStatusMarkdownMessage(result, copy));
+		if (renderedMarkdown) {
+			await ctx.reply(renderedMarkdown, { parse_mode: "MarkdownV2" });
+			return;
+		}
+		await ctx.reply(presentStatusMessage(result, copy));
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to fetch system status");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+function registerStatusCommand(bot, dependencies) {
+	bot.command("status", async (ctx) => {
+		await handleStatusCommand(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/bot/commands/sessions.ts
+async function handleSessionsCommand(ctx, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		await dependencies.pendingActionRepo.clear(ctx.chat.id);
+		const view = await buildSessionsListView(ctx.chat.id, 0, dependencies);
+		await ctx.reply(view.text, view.keyboard ? { reply_markup: view.keyboard } : void 0);
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to list sessions");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+function registerSessionsCommand(bot, dependencies) {
+	bot.command("sessions", async (ctx) => {
+		await handleSessionsCommand(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/bot/commands/start.ts
+async function handleStartCommand(ctx, dependencies) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat?.id);
+	const reply = buildTelegramStaticReply(presentStartMarkdownMessage(copy));
+	try {
+		await ctx.reply(reply.preferred.text, reply.preferred.options);
+	} catch (error) {
+		if (reply.preferred.options) {
+			dependencies.logger.error({ error }, "failed to send start markdown reply, falling back to plain text");
+			await ctx.reply(reply.fallback.text);
+			return;
+		}
+		dependencies.logger.error({ error }, "failed to show start message");
+		await ctx.reply(presentError(error, copy));
+	}
+}
+function registerStartCommand(bot, dependencies) {
+	bot.command("start", async (ctx) => {
+		await handleStartCommand(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/bot/handlers/callback.handler.ts
+var AGENTS_PAGE_PREFIX = "agents:page:";
+var AGENTS_SELECT_PREFIX = "agents:select:";
+var SESSIONS_PAGE_PREFIX = "sessions:page:";
+var SESSIONS_PICK_PREFIX = "sessions:pick:";
+var SESSIONS_SWITCH_PREFIX = "sessions:switch:";
+var SESSIONS_RENAME_PREFIX = "sessions:rename:";
+var SESSIONS_BACK_PREFIX = "sessions:back:";
+var MODEL_PAGE_PREFIX = "model:page:";
+var MODEL_PICK_PREFIX = "model:pick:";
+var MODEL_VARIANT_PREFIX = "model:variant:";
+var LANGUAGE_SELECT_PREFIX = "language:select:";
+var PERMISSION_PREFIX = "permission:";
+async function handleAgentsCallback(ctx, dependencies) {
+	const data = ctx.callbackQuery.data;
+	if (!data.startsWith("agents:")) return;
+	await ctx.answerCallbackQuery();
+	if (!ctx.chat) return;
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		if (data.startsWith(AGENTS_PAGE_PREFIX)) {
+			const requestedPage = Number(data.slice(12));
+			const result = await dependencies.listAgentsUseCase.execute({ chatId: ctx.chat.id });
+			if (result.agents.length === 0) {
+				await ctx.editMessageText(copy.agents.none);
+				return;
+			}
+			const { keyboard, page } = buildAgentsKeyboard(result.agents, requestedPage, copy);
+			await ctx.editMessageText(presentAgentsMessage({
+				agents: result.agents,
+				currentAgentName: result.currentAgentName,
+				page: page.page
+			}, copy), { reply_markup: keyboard });
+			return;
+		}
+		if (data.startsWith(AGENTS_SELECT_PREFIX)) {
+			const agentIndex = Number(data.slice(14));
+			const agent = (await dependencies.listAgentsUseCase.execute({ chatId: ctx.chat.id })).agents[agentIndex - 1];
+			if (!agent) {
+				await ctx.editMessageText(copy.agents.expired);
+				return;
+			}
+			const switchResult = await dependencies.switchAgentUseCase.execute({
+				chatId: ctx.chat.id,
+				agentName: agent.name
+			});
+			if (!switchResult.found) {
+				await ctx.editMessageText(copy.agents.expired);
+				return;
+			}
+			await ctx.editMessageText(presentAgentSwitchMessage(switchResult.agent, copy));
+		}
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to handle agent callback");
+		await ctx.editMessageText(presentError(error, copy));
+	}
+}
+async function handleModelsCallback(ctx, dependencies) {
+	const data = ctx.callbackQuery.data;
+	if (!data.startsWith("model:")) return;
+	await ctx.answerCallbackQuery();
+	if (!ctx.chat) return;
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		if (data.startsWith(MODEL_PAGE_PREFIX)) {
+			const requestedPage = Number(data.slice(11));
+			const result = await dependencies.listModelsUseCase.execute({ chatId: ctx.chat.id });
+			if (result.models.length === 0) {
+				await ctx.editMessageText(copy.models.none);
+				return;
+			}
+			const { keyboard, page } = buildModelsKeyboard(result.models, requestedPage, copy);
+			await ctx.editMessageText(presentModelsMessage({
+				currentModelId: result.currentModelId,
+				currentModelProviderId: result.currentModelProviderId,
+				currentModelVariant: result.currentModelVariant,
+				models: result.models,
+				page: page.page
+			}, copy), { reply_markup: keyboard });
+			return;
+		}
+		if (data.startsWith(MODEL_PICK_PREFIX)) {
+			const modelIndex = Number(data.slice(11));
+			const model = (await dependencies.listModelsUseCase.execute({ chatId: ctx.chat.id })).models[modelIndex - 1];
+			if (!model) {
+				await ctx.editMessageText(copy.models.expired);
+				return;
+			}
+			const variants = getModelVariants(model);
+			if (variants.length === 0) {
+				const switchResult = await dependencies.switchModelUseCase.execute({
+					chatId: ctx.chat.id,
+					providerId: model.providerID,
+					modelId: model.id
+				});
+				if (!switchResult.found) {
+					await ctx.editMessageText(copy.models.expired);
+					return;
+				}
+				await ctx.editMessageText(presentModelSwitchMessage(switchResult.model, switchResult.variant, copy));
+				return;
+			}
+			await ctx.editMessageText(presentModelVariantsMessage(model, modelIndex, copy), { reply_markup: buildModelVariantsKeyboard(variants, modelIndex) });
+			return;
+		}
+		if (data.startsWith(MODEL_VARIANT_PREFIX)) {
+			const [modelIndexRaw, variantIndexRaw] = data.slice(14).split(":");
+			const modelIndex = Number(modelIndexRaw);
+			const variantIndex = Number(variantIndexRaw);
+			const model = (await dependencies.listModelsUseCase.execute({ chatId: ctx.chat.id })).models[modelIndex - 1];
+			if (!model) {
+				await ctx.editMessageText(copy.models.expired);
+				return;
+			}
+			const variant = getModelVariants(model)[variantIndex - 1];
+			if (!variant) {
+				await ctx.editMessageText(copy.models.reasoningLevelExpired);
+				return;
+			}
+			const switchResult = await dependencies.switchModelUseCase.execute({
+				chatId: ctx.chat.id,
+				providerId: model.providerID,
+				modelId: model.id,
+				variant
+			});
+			if (!switchResult.found) {
+				await ctx.editMessageText(copy.models.expired);
+				return;
+			}
+			await ctx.editMessageText(presentModelSwitchMessage(switchResult.model, switchResult.variant, copy));
+		}
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to handle model callback");
+		await ctx.editMessageText(presentError(error, copy));
+	}
+}
+async function handleSessionsCallback(ctx, dependencies) {
+	const data = ctx.callbackQuery.data;
+	if (!data.startsWith("sessions:")) return;
+	await ctx.answerCallbackQuery();
+	if (!ctx.chat) return;
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		if (data.startsWith(SESSIONS_PAGE_PREFIX)) {
+			const requestedPage = Number(data.slice(14));
+			const view = await buildSessionsListView(ctx.chat.id, requestedPage, dependencies);
+			await ctx.editMessageText(view.text, view.keyboard ? { reply_markup: view.keyboard } : void 0);
+			return;
+		}
+		if (data.startsWith(SESSIONS_BACK_PREFIX)) {
+			const requestedPage = Number(data.slice(14));
+			const view = await buildSessionsListView(ctx.chat.id, requestedPage, dependencies);
+			await ctx.editMessageText(view.text, view.keyboard ? { reply_markup: view.keyboard } : void 0);
+			return;
+		}
+		if (data.startsWith(SESSIONS_PICK_PREFIX)) {
+			const target = parseSessionActionTarget(data, SESSIONS_PICK_PREFIX);
+			if (!target) {
+				await ctx.editMessageText(copy.sessions.expired);
+				return;
+			}
+			const view = await buildSessionActionView(ctx.chat.id, target.page, target.sessionId, dependencies);
+			if (!view.found) {
+				await ctx.editMessageText(copy.sessions.expired);
+				return;
+			}
+			await ctx.editMessageText(view.text, { reply_markup: view.keyboard });
+			return;
+		}
+		if (data.startsWith(SESSIONS_SWITCH_PREFIX)) {
+			const target = parseSessionActionTarget(data, SESSIONS_SWITCH_PREFIX);
+			if (!target) {
+				await ctx.editMessageText(copy.sessions.expired);
+				return;
+			}
+			const result = await dependencies.switchSessionUseCase.execute({
+				chatId: ctx.chat.id,
+				sessionId: target.sessionId
+			});
+			if (!result.found) {
+				await ctx.editMessageText(copy.sessions.expired);
+				return;
+			}
+			await ctx.editMessageText(presentSessionSwitchMessage(result.session, copy));
+			return;
+		}
+		if (data.startsWith(SESSIONS_RENAME_PREFIX)) {
+			const target = parseSessionActionTarget(data, SESSIONS_RENAME_PREFIX);
+			if (!target) {
+				await ctx.editMessageText(copy.sessions.renameExpired);
+				return;
+			}
+			const view = await buildSessionActionView(ctx.chat.id, target.page, target.sessionId, dependencies);
+			if (!view.found) {
+				await ctx.editMessageText(copy.sessions.renameExpired);
+				return;
+			}
+			const menuMessageId = ctx.callbackQuery.message?.message_id;
+			if (typeof menuMessageId !== "number" || !Number.isInteger(menuMessageId)) {
+				await ctx.editMessageText(copy.sessions.renameExpired);
+				return;
+			}
+			await dependencies.pendingActionRepo.set({
+				chatId: ctx.chat.id,
+				kind: "session_rename",
+				sessionId: view.session.id,
+				menuMessageId,
+				returnPage: view.page,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			await ctx.editMessageText(presentSessionRenamePromptMessage(view.session, copy));
+		}
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to handle session callback");
+		await ctx.editMessageText(presentError(error, copy));
+	}
+}
+async function handleLanguageCallback(ctx, dependencies) {
+	const data = ctx.callbackQuery.data;
+	if (!data.startsWith("language:")) return;
+	await ctx.answerCallbackQuery();
+	if (!ctx.chat || !ctx.api) return;
+	const currentCopy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	try {
+		if (!data.startsWith(LANGUAGE_SELECT_PREFIX)) {
+			await ctx.editMessageText(presentLanguageMessage(await getChatLanguage(dependencies.sessionRepo, ctx.chat.id), currentCopy), { reply_markup: buildLanguageKeyboard(await getChatLanguage(dependencies.sessionRepo, ctx.chat.id), currentCopy) });
+			return;
+		}
+		const selectedLanguage = data.slice(16);
+		const result = await presentLanguageSwitchForChat(ctx.chat.id, ctx.api, selectedLanguage, dependencies);
+		await ctx.editMessageText(result.text, { reply_markup: result.keyboard });
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to handle language callback");
+		await ctx.editMessageText(presentError(error, currentCopy));
+	}
+}
+async function handlePermissionApprovalCallback(ctx, dependencies) {
+	const data = ctx.callbackQuery.data;
+	if (!data.startsWith(PERMISSION_PREFIX)) return;
+	await ctx.answerCallbackQuery();
+	if (!ctx.chat) return;
+	const parsed = parsePermissionApprovalCallbackData(data);
+	if (!parsed) return;
+	try {
+		await dependencies.opencodeClient.replyToPermission(parsed.requestId, parsed.reply);
+		const approval = (await dependencies.permissionApprovalRepo.listByRequestId(parsed.requestId)).find((item) => item.chatId === ctx.chat?.id);
+		if (approval) await dependencies.permissionApprovalRepo.set({
+			...approval,
+			status: parsed.reply,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		await ctx.editMessageText(buildPermissionApprovalResolvedMessage(parsed.requestId, parsed.reply));
+	} catch (error) {
+		dependencies.logger.error({
+			error,
+			requestId: parsed.requestId
+		}, "failed to reply to permission request");
+		await ctx.editMessageText("Failed to reply to the permission request.");
+	}
+}
+function registerCallbackHandler(bot, dependencies) {
+	bot.callbackQuery(/^agents:/, async (ctx) => {
+		await handleAgentsCallback(ctx, dependencies);
+	});
+	bot.callbackQuery(/^sessions:/, async (ctx) => {
+		await handleSessionsCallback(ctx, dependencies);
+	});
+	bot.callbackQuery(/^model:/, async (ctx) => {
+		await handleModelsCallback(ctx, dependencies);
+	});
+	bot.callbackQuery(/^language:/, async (ctx) => {
+		await handleLanguageCallback(ctx, dependencies);
+	});
+	bot.callbackQuery(/^permission:/, async (ctx) => {
+		await handlePermissionApprovalCallback(ctx, dependencies);
+	});
+}
+function parseSessionActionTarget(data, prefix) {
+	const suffix = data.slice(prefix.length);
+	const separatorIndex = suffix.indexOf(":");
+	if (separatorIndex === -1) return null;
+	const page = Number(suffix.slice(0, separatorIndex));
+	const sessionId = suffix.slice(separatorIndex + 1).trim();
+	if (!Number.isInteger(page) || page < 0 || !sessionId) return null;
+	return {
+		page,
+		sessionId
+	};
+}
+//#endregion
+//#region src/bot/handlers/prompt.handler.ts
+var activePromptChats = /* @__PURE__ */ new Set();
+async function executePromptRequest(ctx, dependencies, resolvePrompt) {
+	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
+	if (activePromptChats.has(ctx.chat.id)) {
+		await ctx.reply(copy.status.alreadyProcessing);
+		return;
+	}
+	let processingMessage = null;
+	let sentTerminalReply = false;
+	try {
+		activePromptChats.add(ctx.chat.id);
+		processingMessage = await ctx.reply(copy.status.processing);
+		const promptInput = await resolvePrompt();
+		const telegramReply = buildTelegramPromptReply(normalizePromptReplyForDisplay((await dependencies.sendPromptUseCase.execute({
+			chatId: ctx.chat.id,
+			text: promptInput.text,
+			files: promptInput.files
+		})).assistantReply, copy, dependencies), copy);
+		try {
+			await ctx.reply(telegramReply.preferred.text, telegramReply.preferred.options);
+		} catch (replyError) {
+			dependencies.logger.warn?.({ error: replyError }, "failed to send preferred telegram reply, falling back to plain text");
+			await ctx.reply(telegramReply.fallback.text, telegramReply.fallback.options);
+		}
+		sentTerminalReply = true;
+	} catch (error) {
+		dependencies.logger.error({ error }, "failed to handle prompt request");
+		await ctx.reply(presentError(error, copy));
+		sentTerminalReply = true;
+	} finally {
+		activePromptChats.delete(ctx.chat.id);
+		if (processingMessage && sentTerminalReply) try {
+			await ctx.api.deleteMessage(ctx.chat.id, processingMessage.message_id);
+		} catch (error) {
+			dependencies.logger.warn?.({ error }, "failed to delete processing message");
+		}
+	}
+}
+function normalizePromptReplyForDisplay(promptReply, copy, dependencies) {
+	if (!promptReply.assistantError) return promptReply;
+	if (isRecoverableStructuredOutputError(promptReply)) {
+		dependencies.logger.warn?.({ error: promptReply.assistantError }, "structured output validation failed, falling back to assistant text reply");
+		return {
+			...promptReply,
+			assistantError: null
+		};
+	}
+	return {
+		...promptReply,
+		bodyMd: null,
+		fallbackText: presentError(promptReply.assistantError, copy)
+	};
+}
+function isRecoverableStructuredOutputError(promptReply) {
+	if (promptReply.assistantError?.name !== "StructuredOutputError") return false;
+	if (promptReply.bodyMd?.trim()) return true;
+	return promptReply.parts.some((part) => part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0);
+}
+//#endregion
+//#region src/bot/handlers/file.handler.ts
+var TELEGRAM_MAX_DOWNLOAD_BYTES$1 = 20 * 1024 * 1024;
+async function handleImageMessage(ctx, dependencies) {
+	const image = resolveTelegramImage(ctx.message);
+	if (!image) return;
+	if (await replyIfSessionRenamePending(ctx, dependencies)) return;
+	await executePromptRequest(ctx, dependencies, async () => {
+		if (typeof image.fileSize === "number" && image.fileSize > TELEGRAM_MAX_DOWNLOAD_BYTES$1) throw new ImageMessageUnsupportedError(`Image file size ${image.fileSize} exceeds the Telegram download limit of ${TELEGRAM_MAX_DOWNLOAD_BYTES$1} bytes.`);
+		const filePath = (await ctx.getFile()).file_path?.trim();
+		if (!filePath) throw new ImageMessageUnsupportedError("Telegram did not provide a downloadable image file path.");
+		return {
+			files: [await dependencies.uploadFileUseCase.execute({
+				expectedType: "image",
+				filePath,
+				filename: image.filename,
+				mimeType: image.mimeType
+			})],
+			text: ctx.message.caption?.trim() || null
+		};
+	});
+}
+function registerFileHandler(bot, dependencies) {
+	bot.on("message:photo", async (ctx) => {
+		await handleImageMessage(ctx, dependencies);
+	});
+	bot.on("message:document", async (ctx) => {
+		await handleImageMessage(ctx, dependencies);
+	});
+}
+function resolveTelegramImage(message) {
+	const document = message.document;
+	if (document && isImageDocument(document)) return {
+		fileId: document.file_id,
+		fileSize: document.file_size,
+		filename: document.file_name ?? null,
+		mimeType: document.mime_type ?? null
+	};
+	const photo = pickLargestPhoto(message.photo);
+	if (!photo) return null;
+	return {
+		fileId: photo.file_id,
+		fileSize: photo.file_size,
+		filename: null,
+		mimeType: "image/jpeg"
+	};
+}
+function isImageDocument(document) {
+	const mimeType = document.mime_type?.trim().toLowerCase();
+	const filename = document.file_name?.trim().toLowerCase() ?? "";
+	return !!mimeType?.startsWith("image/") || /\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(filename);
+}
+function pickLargestPhoto(photos) {
+	if (!photos || photos.length === 0) return null;
+	return photos.reduce((largest, current) => {
+		return (current.file_size ?? 0) >= (largest.file_size ?? 0) ? current : largest;
+	}, photos[0]);
+}
+//#endregion
+//#region src/bot/handlers/message.handler.ts
+async function handleTextMessage(ctx, dependencies) {
+	const text = ctx.message.text?.trim();
+	if (await handlePendingSessionRenameText(ctx, dependencies)) return;
+	if (!text) return;
+	if (text.startsWith("/")) return;
+	await executePromptRequest(ctx, dependencies, async () => ({ text }));
+}
+function registerMessageHandler(bot, dependencies) {
+	bot.on("message:text", async (ctx) => {
+		await handleTextMessage(ctx, dependencies);
+	});
+}
+//#endregion
+//#region src/bot/handlers/voice.handler.ts
+var DEFAULT_VOICE_FILE_NAME = "telegram-voice.ogg";
+var DEFAULT_VOICE_MIME_TYPE = "audio/ogg";
+var TELEGRAM_MAX_DOWNLOAD_BYTES = 20 * 1024 * 1024;
+async function handleVoiceMessage(ctx, dependencies) {
+	if (!ctx.message.voice) return;
+	if (await replyIfSessionRenamePending(ctx, dependencies)) return;
+	await executePromptRequest(ctx, dependencies, async () => {
+		const voice = ctx.message.voice;
+		if (!voice) throw new VoiceMessageUnsupportedError("Telegram voice payload is missing.");
+		if (typeof voice.file_size === "number" && voice.file_size > TELEGRAM_MAX_DOWNLOAD_BYTES) throw new VoiceMessageUnsupportedError(`Voice file size ${voice.file_size} exceeds the Telegram download limit of ${TELEGRAM_MAX_DOWNLOAD_BYTES} bytes.`);
+		const filePath = (await ctx.getFile()).file_path?.trim();
+		if (!filePath) throw new VoiceMessageUnsupportedError("Telegram did not provide a downloadable voice file path.");
+		const download = await dependencies.telegramFileClient.downloadFile({ filePath });
+		const mimeType = voice.mime_type?.trim() || download.mimeType || DEFAULT_VOICE_MIME_TYPE;
+		const filename = resolveVoiceFilename(filePath);
+		return { text: (await dependencies.voiceTranscriptionService.transcribeVoice({
+			data: download.data,
+			filename,
+			mimeType
+		})).text };
+	});
+}
+function registerVoiceHandler(bot, dependencies) {
+	bot.on("message:voice", async (ctx) => {
+		await handleVoiceMessage(ctx, dependencies);
+	});
+}
+function resolveVoiceFilename(filePath) {
+	const normalizedPath = filePath.trim();
+	if (!normalizedPath) return DEFAULT_VOICE_FILE_NAME;
+	const filename = normalizedPath.split("/").at(-1)?.trim();
+	return filename && filename.length > 0 ? filename : DEFAULT_VOICE_FILE_NAME;
+}
+//#endregion
+//#region src/bot/middlewares/auth.ts
+function createAuthMiddleware(allowedChatIds) {
+	return async (ctx, next) => {
+		if (allowedChatIds.length === 0) return next();
+		const chatId = ctx.chat?.id;
+		if (!chatId || !allowedChatIds.includes(chatId)) {
+			await ctx.reply("Unauthorized chat.");
+			return;
+		}
+		return next();
+	};
+}
+//#endregion
+//#region src/bot/middlewares/logging.ts
+function buildIncomingUpdateLogFields(ctx) {
+	const messageText = ctx.msg && "text" in ctx.msg ? ctx.msg.text : void 0;
+	return {
+		updateId: ctx.update.update_id,
+		chatId: ctx.chat?.id,
+		fromId: ctx.from?.id,
+		hasText: typeof messageText === "string" && messageText.length > 0,
+		textLength: typeof messageText === "string" ? messageText.length : 0,
+		textPreview: typeof messageText === "string" && messageText.length > 0 ? createRedactedPreview(messageText) : void 0
+	};
+}
+function createLoggingMiddleware(logger) {
+	return async (ctx, next) => {
+		logger.info(buildIncomingUpdateLogFields(ctx), "incoming update");
+		return next();
+	};
+}
+//#endregion
+//#region src/bot/index.ts
+function registerBot(bot, container, options) {
+	bot.use(createLoggingMiddleware(container.logger));
+	bot.use(createAuthMiddleware(options.telegramAllowedChatIds));
+	registerStartCommand(bot, container);
+	registerHelpCommand(bot, container);
+	registerStatusCommand(bot, container);
+	registerNewCommand(bot, container);
+	registerAgentsCommand(bot, container);
+	registerSessionsCommand(bot, container);
+	registerCancelCommand(bot, container);
+	registerModelsCommand(bot, container);
+	registerLanguageCommand(bot, container);
+	registerCallbackHandler(bot, container);
+	registerFileHandler(bot, container);
+	registerMessageHandler(bot, container);
+	registerVoiceHandler(bot, container);
+}
+//#endregion
+//#region src/app/runtime.ts
+async function startTelegramBotRuntime(input) {
+	const bot = new Bot(input.config.telegramBotToken, { client: { apiRoot: input.config.telegramApiRoot } });
+	registerBot(bot, input.container, { telegramAllowedChatIds: input.config.telegramAllowedChatIds });
+	bot.catch((error) => {
+		input.container.logger.error({
+			error: error.error,
+			update: error.ctx.update
+		}, "telegram bot update failed");
+	});
+	input.container.logger.info("bot starting...");
+	if (input.syncCommands ?? true) await syncTelegramCommands(bot, input.container.logger);
+	const runner = run(bot);
+	let stopped = false;
+	let disposed = false;
+	const stop = () => {
+		if (stopped) return;
+		stopped = true;
+		runner.stop();
+	};
+	const dispose = async () => {
+		if (disposed) return;
+		disposed = true;
+		stop();
+		await input.container.dispose();
+	};
+	return {
+		bot,
+		container: input.container,
+		stop,
+		dispose
+	};
+}
+//#endregion
+//#region src/plugin.ts
+var runtimeState = null;
+async function ensureTelegramBotPluginRuntime(options) {
+	const cwd = resolvePluginRuntimeCwd(options.context);
+	if (runtimeState && runtimeState.cwd !== cwd) {
+		const activeState = runtimeState;
+		runtimeState = null;
+		await disposeTelegramBotPluginRuntimeState(activeState);
+	}
+	if (!runtimeState) {
+		const runtimePromise = startPluginRuntime(options, cwd).then((runtime) => {
+			if (runtimeState?.runtimePromise === runtimePromise) runtimeState.runtime = runtime;
+			return runtime;
+		}).catch((error) => {
+			if (runtimeState?.runtimePromise === runtimePromise) runtimeState = null;
+			throw error;
+		});
+		runtimeState = {
+			cwd,
+			runtime: null,
+			runtimePromise
+		};
+	}
+	return runtimeState.runtimePromise;
+}
+var TelegramBotPlugin = async (context) => {
+	return createHooks(await ensureTelegramBotPluginRuntime({ context }));
+};
+async function resetTelegramBotPluginRuntimeForTests() {
+	if (!runtimeState) return;
+	const activeState = runtimeState;
+	runtimeState = null;
+	await disposeTelegramBotPluginRuntimeState(activeState);
+}
+async function startPluginRuntime(options, cwd) {
+	const bootstrapApp = options.bootstrapApp ?? bootstrapPluginApp;
+	const prepareConfiguration = options.prepareConfiguration ?? preparePluginConfiguration;
+	const startRuntime = options.startRuntime ?? startTelegramBotRuntime;
+	const preparedConfiguration = await prepareConfiguration({
+		cwd,
+		config: options.config
+	});
+	const { config, container } = bootstrapApp(options.context.client, preparedConfiguration.config, { cwd: preparedConfiguration.cwd });
+	try {
+		const runtime = await startRuntime({
+			config,
+			container
+		});
+		container.logger.info({
+			cwd: preparedConfiguration.cwd,
+			globalConfigFilePath: preparedConfiguration.globalConfigFilePath,
+			projectConfigFilePath: preparedConfiguration.projectConfigFilePath,
+			configFilePath: preparedConfiguration.configFilePath,
+			mode: "plugin"
+		}, "telegram bot plugin runtime started");
+		return runtime;
+	} catch (error) {
+		await container.dispose();
+		throw error;
+	}
+}
+function resolvePluginRuntimeCwd(context) {
+	return context.worktree ?? context.directory ?? process.cwd();
+}
+async function disposeTelegramBotPluginRuntimeState(state) {
+	await (state.runtime ?? await state.runtimePromise.catch(() => null))?.dispose();
+}
+function createHooks(runtime) {
+	return {
+		async event({ event }) {
+			await handleTelegramBotPluginEvent(runtime, event);
+		},
+		async "permission.ask"(input, output) {
+			if ((await runtime.container.sessionRepo.listBySessionId(input.sessionID)).length > 0) output.status = "ask";
+		}
+	};
+}
+//#endregion
+export { TelegramBotPlugin, TelegramBotPlugin as default, ensureTelegramBotPluginRuntime, resetTelegramBotPluginRuntimeForTests };
+
+//# sourceMappingURL=plugin.js.map