teleton 0.5.2 → 0.7.0

package/dist/chunk-TCD4NZDA.js

@@ -0,0 +1,3226 @@
+import {
+  ConfigSchema,
+  getKeyPair,
+  getTonPrice,
+  getWalletAddress,
+  getWalletBalance,
+  loadWallet
+} from "./chunk-NERLQY2H.js";
+import {
+  getCachedHttpEndpoint
+} from "./chunk-QUAPFI2N.js";
+import {
+  require_BigInteger
+} from "./chunk-TSKJCWQQ.js";
+import {
+  getErrorMessage
+} from "./chunk-XBE4JB7C.js";
+import {
+  getProviderMetadata
+} from "./chunk-LRCPA7SC.js";
+import {
+  createDbWrapper,
+  migrateFromMainDb,
+  openModuleDb
+} from "./chunk-UCN6TI25.js";
+import {
+  tonapiFetch
+} from "./chunk-XBKSS6DM.js";
+import {
+  PAYMENT_TOLERANCE_RATIO
+} from "./chunk-RO62LO6Z.js";
+import {
+  RETRY_BLOCKCHAIN_BASE_DELAY_MS,
+  RETRY_BLOCKCHAIN_MAX_DELAY_MS,
+  RETRY_BLOCKCHAIN_TIMEOUT_MS,
+  RETRY_DEFAULT_BASE_DELAY_MS,
+  RETRY_DEFAULT_MAX_ATTEMPTS,
+  RETRY_DEFAULT_MAX_DELAY_MS,
+  RETRY_DEFAULT_TIMEOUT_MS
+} from "./chunk-4DU3C27M.js";
+import {
+  ALLOWED_EXTENSIONS,
+  TELETON_ROOT,
+  WORKSPACE_PATHS,
+  WORKSPACE_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-QGM4M3NI.js";
+
+// src/config/loader.ts
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { parse, stringify } from "yaml";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var log = createLogger("Config");
+var DEFAULT_CONFIG_PATH = join(TELETON_ROOT, "config.yaml");
+function expandPath(path) {
+  if (path.startsWith("~")) {
+    return join(homedir(), path.slice(1));
+  }
+  return path;
+}
+function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
+  const fullPath = expandPath(configPath);
+  if (!existsSync(fullPath)) {
+    throw new Error(`Config file not found: ${fullPath}
+Run 'teleton setup' to create one.`);
+  }
+  let content;
+  try {
+    content = readFileSync(fullPath, "utf-8");
+  } catch (error) {
+    throw new Error(`Cannot read config file ${fullPath}: ${error.message}`);
+  }
+  let raw;
+  try {
+    raw = parse(content);
+  } catch (error) {
+    throw new Error(`Invalid YAML in ${fullPath}: ${error.message}`);
+  }
+  if (raw && typeof raw === "object" && "market" in raw) {
+    log.warn("config.market is deprecated and ignored. Use market-api plugin instead.");
+    delete raw.market;
+  }
+  const result = ConfigSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(`Invalid config: ${result.error.message}`);
+  }
+  const config = result.data;
+  const provider = config.agent.provider;
+  if (provider !== "anthropic" && !raw.agent?.model) {
+    const meta = getProviderMetadata(provider);
+    config.agent.model = meta.defaultModel;
+  }
+  config.telegram.session_path = expandPath(config.telegram.session_path);
+  config.storage.sessions_file = expandPath(config.storage.sessions_file);
+  config.storage.pairing_file = expandPath(config.storage.pairing_file);
+  config.storage.memory_file = expandPath(config.storage.memory_file);
+  if (process.env.TELETON_API_KEY) {
+    config.agent.api_key = process.env.TELETON_API_KEY;
+  }
+  if (process.env.TELETON_TG_API_ID) {
+    const apiId = parseInt(process.env.TELETON_TG_API_ID, 10);
+    if (isNaN(apiId)) {
+      throw new Error(
+        `Invalid TELETON_TG_API_ID environment variable: "${process.env.TELETON_TG_API_ID}" is not a valid integer`
+      );
+    }
+    config.telegram.api_id = apiId;
+  }
+  if (process.env.TELETON_TG_API_HASH) {
+    config.telegram.api_hash = process.env.TELETON_TG_API_HASH;
+  }
+  if (process.env.TELETON_TG_PHONE) {
+    config.telegram.phone = process.env.TELETON_TG_PHONE;
+  }
+  if (process.env.TELETON_WEBUI_ENABLED) {
+    config.webui.enabled = process.env.TELETON_WEBUI_ENABLED === "true";
+  }
+  if (process.env.TELETON_WEBUI_PORT) {
+    const port = parseInt(process.env.TELETON_WEBUI_PORT, 10);
+    if (!isNaN(port) && port >= 1024 && port <= 65535) {
+      config.webui.port = port;
+    }
+  }
+  if (process.env.TELETON_WEBUI_HOST) {
+    config.webui.host = process.env.TELETON_WEBUI_HOST;
+    if (!["127.0.0.1", "localhost", "::1"].includes(config.webui.host)) {
+      log.warn(
+        { host: config.webui.host },
+        "WebUI bound to non-loopback address \u2014 ensure auth_token is set"
+      );
+    }
+  }
+  if (process.env.TELETON_BASE_URL) {
+    try {
+      new URL(process.env.TELETON_BASE_URL);
+      config.agent.base_url = process.env.TELETON_BASE_URL;
+    } catch {
+      throw new Error(
+        `Invalid TELETON_BASE_URL: "${process.env.TELETON_BASE_URL}" is not a valid URL`
+      );
+    }
+  }
+  if (process.env.TELETON_TAVILY_API_KEY) {
+    config.tavily_api_key = process.env.TELETON_TAVILY_API_KEY;
+  }
+  if (process.env.TELETON_TONAPI_KEY) {
+    config.tonapi_key = process.env.TELETON_TONAPI_KEY;
+  }
+  return config;
+}
+function configExists(configPath = DEFAULT_CONFIG_PATH) {
+  return existsSync(expandPath(configPath));
+}
+function getDefaultConfigPath() {
+  return DEFAULT_CONFIG_PATH;
+}
+
+// src/soul/loader.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+
+// src/memory/daily-logs.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, appendFileSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/workspace/validator.ts
+import { existsSync as existsSync2, lstatSync, readdirSync } from "fs";
+import { resolve, normalize, relative, extname, basename } from "path";
+import { homedir as homedir2 } from "os";
+var WorkspaceSecurityError = class extends Error {
+  constructor(message, attemptedPath) {
+    super(message);
+    this.attemptedPath = attemptedPath;
+    this.name = "WorkspaceSecurityError";
+  }
+};
+function decodeRecursive(str) {
+  let decoded = str;
+  let prev = "";
+  let iterations = 0;
+  const maxIterations = 10;
+  while (decoded !== prev && iterations < maxIterations) {
+    prev = decoded;
+    try {
+      decoded = decodeURIComponent(decoded);
+    } catch {
+      break;
+    }
+    iterations++;
+  }
+  return decoded;
+}
+function validatePath(inputPath, allowCreate = false) {
+  if (!inputPath || inputPath.trim() === "") {
+    throw new WorkspaceSecurityError("Path cannot be empty.", inputPath);
+  }
+  const trimmedPath = inputPath.trim().replace(/\\/g, "/");
+  const decodedPath = decodeRecursive(trimmedPath);
+  let absolutePath;
+  if (decodedPath.startsWith("/")) {
+    absolutePath = resolve(normalize(decodedPath));
+  } else if (decodedPath.startsWith("~/")) {
+    const expanded = decodedPath.replace(/^~(?=$|[\\/])/, homedir2());
+    absolutePath = resolve(expanded);
+  } else {
+    absolutePath = resolve(WORKSPACE_ROOT, normalize(decodedPath));
+  }
+  const relativePath = relative(WORKSPACE_ROOT, absolutePath);
+  if (relativePath.startsWith("..") || relativePath.startsWith("/")) {
+    throw new WorkspaceSecurityError(
+      `Access denied: Path '${inputPath}' is outside the workspace. Only files in ~/.teleton/workspace/ are accessible.`,
+      inputPath
+    );
+  }
+  const exists = existsSync2(absolutePath);
+  if (!exists && !allowCreate) {
+    throw new WorkspaceSecurityError(
+      `File not found: '${inputPath}' does not exist in workspace.`,
+      inputPath
+    );
+  }
+  if (exists) {
+    const stats = lstatSync(absolutePath);
+    if (stats.isSymbolicLink()) {
+      throw new WorkspaceSecurityError(
+        `Access denied: Symbolic links are not allowed for security reasons.`,
+        inputPath
+      );
+    }
+  }
+  return {
+    absolutePath,
+    relativePath,
+    exists,
+    isDirectory: exists ? lstatSync(absolutePath).isDirectory() : false,
+    extension: extname(absolutePath).toLowerCase(),
+    filename: basename(absolutePath)
+  };
+}
+function validateReadPath(inputPath) {
+  const validated = validatePath(inputPath, false);
+  if (validated.isDirectory) {
+    throw new WorkspaceSecurityError(`Cannot read directory as file: '${inputPath}'`, inputPath);
+  }
+  return validated;
+}
+var IMMUTABLE_FILES = ["SOUL.md", "STRATEGY.md", "SECURITY.md"];
+function validateWritePath(inputPath, fileType) {
+  const validated = validatePath(inputPath, true);
+  if (IMMUTABLE_FILES.includes(validated.filename)) {
+    throw new WorkspaceSecurityError(
+      `Cannot write to ${validated.filename}. This file is configured by the owner. Use memory_write instead.`,
+      inputPath
+    );
+  }
+  if (fileType && ALLOWED_EXTENSIONS[fileType]) {
+    const allowedExts = ALLOWED_EXTENSIONS[fileType];
+    if (!allowedExts.includes(validated.extension)) {
+      throw new WorkspaceSecurityError(
+        `Invalid file type: '${validated.extension}' is not allowed for ${fileType}. Allowed: ${allowedExts.join(", ")}`,
+        inputPath
+      );
+    }
+  }
+  return validated;
+}
+function validateDirectory(inputPath) {
+  const validated = validatePath(inputPath, true);
+  if (validated.exists && !validated.isDirectory) {
+    throw new WorkspaceSecurityError(
+      `Path exists but is not a directory: '${inputPath}'`,
+      inputPath
+    );
+  }
+  return validated;
+}
+
+// src/memory/daily-logs.ts
+var log2 = createLogger("Memory");
+var MEMORY_DIR = WORKSPACE_PATHS.MEMORY_DIR;
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function getDailyLogPath(date = /* @__PURE__ */ new Date()) {
+  return join2(MEMORY_DIR, `${formatDate(date)}.md`);
+}
+function ensureMemoryDir() {
+  if (!existsSync3(MEMORY_DIR)) {
+    mkdirSync2(MEMORY_DIR, { recursive: true });
+  }
+}
+function appendToDailyLog(content, date = /* @__PURE__ */ new Date()) {
+  try {
+    ensureMemoryDir();
+    const logPath = getDailyLogPath(date);
+    const timestamp = date.toLocaleTimeString("en-US", { hour12: false });
+    if (!existsSync3(logPath)) {
+      const header = `# Daily Log - ${formatDate(date)}
+
+`;
+      appendFileSync(logPath, header, "utf-8");
+    }
+    const entry = `## ${timestamp}
+
+${content}
+
+---
+
+`;
+    appendFileSync(logPath, entry, "utf-8");
+    log2.info(`Daily log updated: ${logPath}`);
+  } catch (error) {
+    log2.error({ err: error }, "Failed to write daily log");
+  }
+}
+function readDailyLog(date = /* @__PURE__ */ new Date()) {
+  try {
+    const logPath = getDailyLogPath(date);
+    if (!existsSync3(logPath)) return null;
+    return readFileSync2(logPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+var DAILY_LOG_LINE_LIMIT = 100;
+function truncateDailyLog(content) {
+  const lines = content.split("\n");
+  if (lines.length <= DAILY_LOG_LINE_LIMIT) return content;
+  const truncated = lines.slice(-DAILY_LOG_LINE_LIMIT).join("\n");
+  const dropped = lines.length - DAILY_LOG_LINE_LIMIT;
+  return `_[... ${dropped} earlier lines omitted]_
+
+${truncated}`;
+}
+function readRecentMemory() {
+  const today = /* @__PURE__ */ new Date();
+  const yesterday = new Date(today);
+  yesterday.setDate(yesterday.getDate() - 1);
+  const parts = [];
+  const yesterdayLog = readDailyLog(yesterday);
+  if (yesterdayLog) {
+    parts.push(`## Yesterday (${formatDate(yesterday)})
+
+${truncateDailyLog(yesterdayLog)}`);
+  }
+  const todayLog = readDailyLog(today);
+  if (todayLog) {
+    parts.push(`## Today (${formatDate(today)})
+
+${truncateDailyLog(todayLog)}`);
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return `# Recent Memory
+
+${parts.join("\n\n---\n\n")}`;
+}
+function writeSummaryToDailyLog(summary) {
+  appendToDailyLog(`### Memory Flush (Pre-Compaction)
+
+${summary}`);
+}
+
+// src/utils/sanitize.ts
+function sanitizeForPrompt(text) {
+  return text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "").replace(/[\u00AD\u034F\u061C\u180E\u200B-\u200F\u2060-\u2064\uFEFF]/g, "").replace(/[\u202A-\u202E\u2066-\u2069]/g, "").replace(/[\r\n\u2028\u2029]+/g, " ").replace(/#{1,6}\s/g, "").replace(/<\/?[a-zA-Z_][^>]*>/g, "").replace(/`{3,}/g, "`").trim().slice(0, 128);
+}
+function sanitizeForContext(text) {
+  return text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "").replace(/[\u00AD\u034F\u061C\u180E\u200B-\u200F\u2060-\u2064\uFEFF]/g, "").replace(/[\u202A-\u202E\u2066-\u2069]/g, "").replace(/[\u2028\u2029]/g, "\n").replace(/<\/?[a-zA-Z_][^>]*>/g, "").replace(/`{3,}/g, "``").trim();
+}
+
+// src/soul/loader.ts
+var SOUL_PATHS = [WORKSPACE_PATHS.SOUL];
+var STRATEGY_PATHS = [WORKSPACE_PATHS.STRATEGY];
+var SECURITY_PATHS = [WORKSPACE_PATHS.SECURITY];
+var MEMORY_PATH = WORKSPACE_PATHS.MEMORY;
+var DEFAULT_SOUL = `# Teleton AI
+
+You are Teleton, a personal AI assistant that operates through Telegram.
+
+## Personality
+- Helpful and concise
+- Direct and honest
+- Friendly but professional
+
+## Guidelines
+- Keep responses short and actionable
+- Use markdown when appropriate
+- Respect user privacy
+- Be transparent about capabilities and limitations
+`;
+var fileCache = /* @__PURE__ */ new Map();
+var FILE_CACHE_TTL = 6e4;
+function cachedReadFile(path) {
+  const now = Date.now();
+  const cached = fileCache.get(path);
+  if (cached && now < cached.expiry) return cached.content;
+  let content = null;
+  try {
+    if (existsSync4(path)) content = readFileSync3(path, "utf-8");
+  } catch {
+  }
+  fileCache.set(path, { content, expiry: now + FILE_CACHE_TTL });
+  return content;
+}
+function clearPromptCache() {
+  fileCache.clear();
+}
+function loadSoul() {
+  for (const path of SOUL_PATHS) {
+    const content = cachedReadFile(path);
+    if (content) return content;
+  }
+  return DEFAULT_SOUL;
+}
+function loadStrategy() {
+  for (const path of STRATEGY_PATHS) {
+    const content = cachedReadFile(path);
+    if (content) return content;
+  }
+  return null;
+}
+function loadSecurity() {
+  for (const path of SECURITY_PATHS) {
+    const content = cachedReadFile(path);
+    if (content) return content;
+  }
+  return null;
+}
+var MEMORY_HARD_LIMIT = 150;
+function loadPersistentMemory() {
+  const content = cachedReadFile(MEMORY_PATH);
+  if (!content) return null;
+  const lines = content.split("\n");
+  if (lines.length <= MEMORY_HARD_LIMIT) {
+    return content;
+  }
+  const truncated = lines.slice(0, MEMORY_HARD_LIMIT).join("\n");
+  const remaining = lines.length - MEMORY_HARD_LIMIT;
+  return `${truncated}
+
+_[... ${remaining} more lines not loaded. Consider consolidating MEMORY.md to keep it under ${MEMORY_HARD_LIMIT} lines.]_`;
+}
+function loadMemoryContext() {
+  const parts = [];
+  const persistentMemory = loadPersistentMemory();
+  if (persistentMemory) {
+    parts.push(`## Persistent Memory
+
+${sanitizeForContext(persistentMemory)}`);
+  }
+  const recentMemory = readRecentMemory();
+  if (recentMemory) {
+    parts.push(sanitizeForContext(recentMemory));
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return parts.join("\n\n---\n\n");
+}
+function buildSystemPrompt(options) {
+  const soul = options.soul ?? loadSoul();
+  const parts = [soul];
+  const security = loadSecurity();
+  if (security) {
+    parts.push(`
+${security}`);
+  }
+  const includeStrategy = options.includeStrategy ?? true;
+  if (includeStrategy) {
+    const strategy = options.strategy ?? loadStrategy();
+    if (strategy) {
+      parts.push(`
+${strategy}`);
+    }
+  }
+  parts.push(`
+## Your Workspace
+
+You have a personal workspace at \`~/.teleton/workspace/\` where you can store and manage files.
+
+**Structure:**
+- \`SOUL.md\` - Your personality and behavior guidelines
+- \`MEMORY.md\` - Persistent memory (long-term facts you've learned)
+- \`STRATEGY.md\` - Business strategy and trading rules
+- \`memory/\` - Daily logs (auto-created per day)
+- \`downloads/\` - Media downloaded from Telegram
+- \`uploads/\` - Files ready to send
+- \`temp/\` - Temporary working files
+- \`memes/\` - Your meme collection (images, GIFs for reactions)
+
+**Tools available:**
+- \`workspace_list\` - List files in a directory
+- \`workspace_read\` - Read a file
+- \`workspace_write\` - Write/create a file
+- \`workspace_delete\` - Delete a file
+- \`workspace_rename\` - Rename or move a file
+- \`workspace_info\` - Get workspace stats
+
+**Tips:**
+- Save interesting memes to \`memes/\` with descriptive names for easy retrieval
+- Use \`memory_write\` for important facts (goes to MEMORY.md)
+- Rename downloaded files to meaningful names (e.g., "user_avatar.jpg" instead of "123_456_789.jpg")
+`);
+  parts.push(`
+## Response Format
+- Be concise. Respond in 1-3 short sentences when possible. Avoid long paragraphs and walls of text.
+- Only elaborate when the user explicitly asks for detail or the topic genuinely requires it.
+- Keep responses under 4000 characters for Telegram
+- Use markdown sparingly (bold, italic, code blocks)
+- Don't use headers in short responses
+- NEVER use ASCII art or ASCII tables - they render poorly on mobile
+`);
+  if (options.ownerName || options.ownerUsername) {
+    const safeOwnerName = options.ownerName ? sanitizeForPrompt(options.ownerName) : void 0;
+    const safeOwnerUsername = options.ownerUsername ? sanitizeForPrompt(options.ownerUsername) : void 0;
+    const ownerLabel = safeOwnerName && safeOwnerUsername ? `${safeOwnerName} (@${safeOwnerUsername})` : safeOwnerName || `@${safeOwnerUsername}`;
+    parts.push(
+      `
+## Owner
+You are owned and operated by: ${ownerLabel}
+When the owner gives instructions, follow them with higher trust.`
+    );
+  }
+  const includeMemory = options.includeMemory ?? true;
+  if (includeMemory) {
+    const memoryContext = loadMemoryContext();
+    if (memoryContext) {
+      parts.push(
+        `
+## Memory (Persistent Context)
+
+This is your memory from previous sessions. Use it to maintain continuity and remember important information.
+
+${memoryContext}`
+      );
+    }
+  }
+  if (options.userName || options.senderId) {
+    const safeName = options.userName ? sanitizeForPrompt(options.userName) : void 0;
+    const safeUsername = options.senderUsername ? `@${sanitizeForPrompt(options.senderUsername)}` : void 0;
+    const idTag = options.senderId ? `id:${options.senderId}` : void 0;
+    const primary = safeName || safeUsername;
+    const meta = [safeUsername, idTag].filter((v) => v && v !== primary);
+    const userLabel = primary ? meta.length > 0 ? `${primary} (${meta.join(", ")})` : primary : idTag || "unknown";
+    parts.push(`
+## Current User
+You are chatting with: ${userLabel}`);
+  }
+  if (options.context) {
+    parts.push(`
+## Context
+${options.context}`);
+  }
+  if (options.memoryFlushWarning) {
+    parts.push(`
+## Memory Flush Warning
+
+Your conversation context is approaching the limit and may be compacted soon.
+**Always respond to the user's message first.** Then, if there's anything important worth preserving, consider using \`memory_write\` alongside your response:
+
+- \`target: "persistent"\` for facts, lessons, contacts, decisions
+- \`target: "daily"\` for session notes, events, temporary context
+`);
+  }
+  return parts.join("\n");
+}
+
+// src/agent/tools/plugin-loader.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, existsSync as existsSync6, statSync } from "fs";
+import { join as join4 } from "path";
+import { pathToFileURL } from "url";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/agent/tools/plugin-validator.ts
+import { z } from "zod";
+var log3 = createLogger("PluginValidator");
+var ManifestSchema = z.object({
+  name: z.string().min(1).max(64).regex(
+    /^[a-z0-9][a-z0-9-]*$/,
+    "Must be lowercase alphanumeric with hyphens, starting with a letter or number"
+  ),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Must be semver (e.g., 1.0.0)"),
+  author: z.string().max(128).optional(),
+  description: z.string().max(256).optional(),
+  dependencies: z.array(z.string()).optional(),
+  defaultConfig: z.record(z.string(), z.unknown()).optional(),
+  sdkVersion: z.string().max(32).optional(),
+  secrets: z.record(
+    z.string(),
+    z.object({
+      required: z.boolean(),
+      description: z.string().max(256),
+      env: z.string().max(128).optional()
+    })
+  ).optional()
+});
+function validateManifest(raw) {
+  return ManifestSchema.parse(raw);
+}
+function validateToolDefs(defs, pluginName) {
+  const valid = [];
+  for (const def of defs) {
+    if (!def || typeof def !== "object") {
+      log3.warn(`[${pluginName}] tool is not an object, skipping`);
+      continue;
+    }
+    const t = def;
+    if (!t.name || typeof t.name !== "string") {
+      log3.warn(`[${pluginName}] tool missing 'name', skipping`);
+      continue;
+    }
+    if (!t.description || typeof t.description !== "string") {
+      log3.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
+      continue;
+    }
+    if (!t.execute || typeof t.execute !== "function") {
+      log3.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
+      continue;
+    }
+    valid.push(t);
+  }
+  return valid;
+}
+function sanitizeConfigForPlugins(config) {
+  return {
+    agent: {
+      provider: config.agent.provider,
+      model: config.agent.model,
+      max_tokens: config.agent.max_tokens
+    },
+    telegram: {
+      admin_ids: config.telegram.admin_ids
+    },
+    deals: { enabled: config.deals.enabled }
+  };
+}
+
+// packages/sdk/dist/index.js
+var PluginSDKError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+  name = "PluginSDKError";
+};
+var SDK_VERSION = "1.0.0";
+
+// src/ton/transfer.ts
+import { WalletContractV5R1, TonClient, toNano, internal } from "@ton/ton";
+import { Address, SendMode } from "@ton/core";
+var log4 = createLogger("TON");
+async function sendTon(params) {
+  try {
+    const { toAddress, amount, comment = "", bounce = false } = params;
+    if (!Number.isFinite(amount) || amount <= 0) {
+      log4.error({ amount }, "Invalid transfer amount");
+      return null;
+    }
+    let recipientAddress;
+    try {
+      recipientAddress = Address.parse(toAddress);
+    } catch (e) {
+      log4.error({ err: e }, `Invalid recipient address: ${toAddress}`);
+      return null;
+    }
+    const keyPair = await getKeyPair();
+    if (!keyPair) {
+      log4.error("Wallet not initialized");
+      return null;
+    }
+    const wallet = WalletContractV5R1.create({
+      workchain: 0,
+      publicKey: keyPair.publicKey
+    });
+    const endpoint = await getCachedHttpEndpoint();
+    const client = new TonClient({ endpoint });
+    const contract = client.open(wallet);
+    const seqno = await contract.getSeqno();
+    await contract.sendTransfer({
+      seqno,
+      secretKey: keyPair.secretKey,
+      sendMode: SendMode.PAY_GAS_SEPARATELY,
+      messages: [
+        internal({
+          to: recipientAddress,
+          value: toNano(amount),
+          body: comment,
+          bounce
+        })
+      ]
+    });
+    const pseudoHash = `${seqno}_${Date.now()}_${amount.toFixed(2)}`;
+    log4.info(`Sent ${amount} TON to ${toAddress.slice(0, 8)}... - seqno: ${seqno}`);
+    return pseudoHash;
+  } catch (error) {
+    log4.error({ err: error }, "Error sending TON");
+    return null;
+  }
+}
+
+// src/utils/retry.ts
+var log5 = createLogger("Utils");
+var DEFAULT_OPTIONS = {
+  maxAttempts: RETRY_DEFAULT_MAX_ATTEMPTS,
+  baseDelayMs: RETRY_DEFAULT_BASE_DELAY_MS,
+  maxDelayMs: RETRY_DEFAULT_MAX_DELAY_MS,
+  timeout: RETRY_DEFAULT_TIMEOUT_MS
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function withRetry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let lastError;
+  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+    try {
+      const result = await Promise.race([
+        fn(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Operation timeout")), opts.timeout)
+        )
+      ]);
+      return result;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      log5.warn(`Retry attempt ${attempt}/${opts.maxAttempts} failed: ${lastError.message}`);
+      if (attempt < opts.maxAttempts) {
+        const delay = Math.min(opts.baseDelayMs * Math.pow(2, attempt - 1), opts.maxDelayMs);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError || new Error("All retry attempts failed");
+}
+async function withBlockchainRetry(fn, operation = "blockchain operation") {
+  try {
+    return await withRetry(fn, {
+      maxAttempts: RETRY_DEFAULT_MAX_ATTEMPTS,
+      baseDelayMs: RETRY_BLOCKCHAIN_BASE_DELAY_MS,
+      maxDelayMs: RETRY_BLOCKCHAIN_MAX_DELAY_MS,
+      timeout: RETRY_BLOCKCHAIN_TIMEOUT_MS
+    });
+  } catch (error) {
+    const message = getErrorMessage(error);
+    throw new Error(`${operation} failed after retries: ${message}`);
+  }
+}
+
+// src/sdk/ton.ts
+var DEFAULT_MAX_AGE_MINUTES = 10;
+var DEFAULT_TX_RETENTION_DAYS = 30;
+var CLEANUP_PROBABILITY = 0.1;
+function cleanupOldTransactions(db, retentionDays, log7) {
+  if (Math.random() > CLEANUP_PROBABILITY) return;
+  try {
+    const cutoff = Math.floor(Date.now() / 1e3) - retentionDays * 24 * 60 * 60;
+    const result = db.prepare("DELETE FROM used_transactions WHERE used_at < ?").run(cutoff);
+    if (result.changes > 0) {
+      log7.debug(`Cleaned up ${result.changes} old transaction records (>${retentionDays}d)`);
+    }
+  } catch (err) {
+    log7.error("Transaction cleanup failed:", err);
+  }
+}
+function createTonSDK(log7, db) {
+  return {
+    getAddress() {
+      try {
+        return getWalletAddress();
+      } catch (err) {
+        log7.error("ton.getAddress() failed:", err);
+        return null;
+      }
+    },
+    async getBalance(address) {
+      try {
+        const addr = address ?? getWalletAddress();
+        if (!addr) return null;
+        return await getWalletBalance(addr);
+      } catch (err) {
+        log7.error("ton.getBalance() failed:", err);
+        return null;
+      }
+    },
+    async getPrice() {
+      try {
+        return await getTonPrice();
+      } catch (err) {
+        log7.error("ton.getPrice() failed:", err);
+        return null;
+      }
+    },
+    async sendTON(to, amount, comment) {
+      const walletAddr = getWalletAddress();
+      if (!walletAddr) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      if (!Number.isFinite(amount) || amount <= 0) {
+        throw new PluginSDKError("Amount must be a positive number", "OPERATION_FAILED");
+      }
+      try {
+        const { Address: Address2 } = await import("@ton/core");
+        Address2.parse(to);
+      } catch {
+        throw new PluginSDKError("Invalid TON address format", "INVALID_ADDRESS");
+      }
+      try {
+        const txRef = await sendTon({
+          toAddress: to,
+          amount,
+          comment,
+          bounce: false
+        });
+        if (!txRef) {
+          throw new PluginSDKError(
+            "Transaction failed \u2014 no reference returned",
+            "OPERATION_FAILED"
+          );
+        }
+        return { txRef, amount };
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send TON: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async getTransactions(address, limit) {
+      try {
+        const { TonClient: TonClient2 } = await import("@ton/ton");
+        const { Address: Address2 } = await import("@ton/core");
+        const { getCachedHttpEndpoint: getCachedHttpEndpoint2 } = await import("./endpoint-FLYNEZ2F.js");
+        const { formatTransactions } = await import("./format-transactions-FD74HI5N.js");
+        const addressObj = Address2.parse(address);
+        const endpoint = await getCachedHttpEndpoint2();
+        const client = new TonClient2({ endpoint });
+        const transactions = await withBlockchainRetry(
+          () => client.getTransactions(addressObj, {
+            limit: Math.min(limit ?? 10, 50)
+          }),
+          "sdk.ton.getTransactions"
+        );
+        return formatTransactions(transactions);
+      } catch (err) {
+        log7.error("ton.getTransactions() failed:", err);
+        return [];
+      }
+    },
+    async verifyPayment(params) {
+      if (!db) {
+        throw new PluginSDKError(
+          "No database available \u2014 verifyPayment requires migrate() with used_transactions table",
+          "OPERATION_FAILED"
+        );
+      }
+      const address = getWalletAddress();
+      if (!address) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      const maxAgeMinutes = params.maxAgeMinutes ?? DEFAULT_MAX_AGE_MINUTES;
+      cleanupOldTransactions(db, DEFAULT_TX_RETENTION_DAYS, log7);
+      try {
+        const txs = await this.getTransactions(address, 20);
+        for (const tx of txs) {
+          if (tx.type !== "ton_received") continue;
+          if (!tx.amount || !tx.from) continue;
+          const tonAmount = parseFloat(tx.amount.replace(/ TON$/, ""));
+          if (isNaN(tonAmount)) continue;
+          if (tonAmount < params.amount * PAYMENT_TOLERANCE_RATIO) continue;
+          if (tx.secondsAgo > maxAgeMinutes * 60) continue;
+          const memo = (tx.comment ?? "").trim().toLowerCase().replace(/^@/, "");
+          const expected = params.memo.toLowerCase().replace(/^@/, "");
+          if (memo !== expected) continue;
+          const txHash = tx.hash;
+          const result = db.prepare(
+            `INSERT OR IGNORE INTO used_transactions (tx_hash, user_id, amount, game_type, used_at)
+               VALUES (?, ?, ?, ?, unixepoch())`
+          ).run(txHash, params.memo, tonAmount, params.gameType);
+          if (result.changes === 0) continue;
+          return {
+            verified: true,
+            txHash,
+            amount: tonAmount,
+            playerWallet: tx.from,
+            date: tx.date,
+            secondsAgo: tx.secondsAgo
+          };
+        }
+        return {
+          verified: false,
+          error: `Payment not found. Send ${params.amount} TON to ${address} with memo: ${params.memo}`
+        };
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        log7.error("ton.verifyPayment() failed:", err);
+        return {
+          verified: false,
+          error: `Verification failed: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    },
+    // ─── Jettons ─────────────────────────────────────────────────
+    async getJettonBalances(ownerAddress) {
+      try {
+        const addr = ownerAddress ?? getWalletAddress();
+        if (!addr) return [];
+        const response = await tonapiFetch(`/accounts/${addr}/jettons`);
+        if (!response.ok) {
+          log7.error(`ton.getJettonBalances() TonAPI error: ${response.status}`);
+          return [];
+        }
+        const data = await response.json();
+        const balances = [];
+        for (const item of data.balances || []) {
+          const { balance, wallet_address, jetton } = item;
+          if (jetton.verification === "blacklist") continue;
+          const decimals = jetton.decimals || 9;
+          const rawBalance = BigInt(balance);
+          const divisor = BigInt(10 ** decimals);
+          const wholePart = rawBalance / divisor;
+          const fractionalPart = rawBalance % divisor;
+          const balanceFormatted = fractionalPart === BigInt(0) ? wholePart.toString() : `${wholePart}.${fractionalPart.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+          balances.push({
+            jettonAddress: jetton.address,
+            walletAddress: wallet_address.address,
+            balance,
+            balanceFormatted,
+            symbol: jetton.symbol || "UNKNOWN",
+            name: jetton.name || "Unknown Token",
+            decimals,
+            verified: jetton.verification === "whitelist",
+            usdPrice: item.price?.prices?.USD ? Number(item.price.prices.USD) : void 0
+          });
+        }
+        return balances;
+      } catch (err) {
+        log7.error("ton.getJettonBalances() failed:", err);
+        return [];
+      }
+    },
+    async getJettonInfo(jettonAddress) {
+      try {
+        const response = await tonapiFetch(`/jettons/${jettonAddress}`);
+        if (response.status === 404) return null;
+        if (!response.ok) {
+          log7.error(`ton.getJettonInfo() TonAPI error: ${response.status}`);
+          return null;
+        }
+        const data = await response.json();
+        const metadata = data.metadata || {};
+        const decimals = parseInt(metadata.decimals || "9");
+        return {
+          address: metadata.address || jettonAddress,
+          name: metadata.name || "Unknown",
+          symbol: metadata.symbol || "UNKNOWN",
+          decimals,
+          totalSupply: data.total_supply || "0",
+          holdersCount: data.holders_count || 0,
+          verified: data.verification === "whitelist",
+          description: metadata.description || void 0,
+          image: data.preview || metadata.image || void 0
+        };
+      } catch (err) {
+        log7.error("ton.getJettonInfo() failed:", err);
+        return null;
+      }
+    },
+    async sendJetton(jettonAddress, to, amount, opts) {
+      const { Address: Address2, beginCell, SendMode: SendMode2 } = await import("@ton/core");
+      const { WalletContractV5R1: WalletContractV5R12, TonClient: TonClient2, toNano: toNano2, internal: internal2 } = await import("@ton/ton");
+      const { getCachedHttpEndpoint: getCachedHttpEndpoint2 } = await import("./endpoint-FLYNEZ2F.js");
+      const walletData = loadWallet();
+      if (!walletData) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      if (!Number.isFinite(amount) || amount <= 0) {
+        throw new PluginSDKError("Amount must be a positive number", "OPERATION_FAILED");
+      }
+      try {
+        Address2.parse(to);
+      } catch {
+        throw new PluginSDKError("Invalid recipient address", "INVALID_ADDRESS");
+      }
+      const jettonsResponse = await tonapiFetch(`/accounts/${walletData.address}/jettons`);
+      if (!jettonsResponse.ok) {
+        throw new PluginSDKError(
+          `Failed to fetch jetton balances: ${jettonsResponse.status}`,
+          "OPERATION_FAILED"
+        );
+      }
+      const jettonsData = await jettonsResponse.json();
+      const jettonBalance = jettonsData.balances?.find(
+        (b) => b.jetton.address.toLowerCase() === jettonAddress.toLowerCase() || Address2.parse(b.jetton.address).toString() === Address2.parse(jettonAddress).toString()
+      );
+      if (!jettonBalance) {
+        throw new PluginSDKError(
+          `You don't own any of this jetton: ${jettonAddress}`,
+          "OPERATION_FAILED"
+        );
+      }
+      const senderJettonWallet = jettonBalance.wallet_address.address;
+      const decimals = jettonBalance.jetton.decimals || 9;
+      const currentBalance = BigInt(jettonBalance.balance);
+      const amountStr = amount.toFixed(decimals);
+      const [whole, frac = ""] = amountStr.split(".");
+      const amountInUnits = BigInt(whole + (frac + "0".repeat(decimals)).slice(0, decimals));
+      if (amountInUnits > currentBalance) {
+        throw new PluginSDKError(
+          `Insufficient balance. Have ${Number(currentBalance) / 10 ** decimals}, need ${amount}`,
+          "OPERATION_FAILED"
+        );
+      }
+      const comment = opts?.comment;
+      let forwardPayload = beginCell().endCell();
+      if (comment) {
+        forwardPayload = beginCell().storeUint(0, 32).storeStringTail(comment).endCell();
+      }
+      const JETTON_TRANSFER_OP = 260734629;
+      const messageBody = beginCell().storeUint(JETTON_TRANSFER_OP, 32).storeUint(0, 64).storeCoins(amountInUnits).storeAddress(Address2.parse(to)).storeAddress(Address2.parse(walletData.address)).storeBit(false).storeCoins(comment ? toNano2("0.01") : BigInt(1)).storeBit(comment ? true : false).storeMaybeRef(comment ? forwardPayload : null).endCell();
+      const keyPair = await getKeyPair();
+      if (!keyPair) {
+        throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
+      }
+      const wallet = WalletContractV5R12.create({
+        workchain: 0,
+        publicKey: keyPair.publicKey
+      });
+      const endpoint = await getCachedHttpEndpoint2();
+      const client = new TonClient2({ endpoint });
+      const walletContract = client.open(wallet);
+      const seqno = await walletContract.getSeqno();
+      await walletContract.sendTransfer({
+        seqno,
+        secretKey: keyPair.secretKey,
+        sendMode: SendMode2.PAY_GAS_SEPARATELY + SendMode2.IGNORE_ERRORS,
+        messages: [
+          internal2({
+            to: Address2.parse(senderJettonWallet),
+            value: toNano2("0.05"),
+            body: messageBody,
+            bounce: true
+          })
+        ]
+      });
+      return { success: true, seqno };
+    },
+    async getJettonWalletAddress(ownerAddress, jettonAddress) {
+      try {
+        const response = await tonapiFetch(`/accounts/${ownerAddress}/jettons`);
+        if (!response.ok) {
+          log7.error(`ton.getJettonWalletAddress() TonAPI error: ${response.status}`);
+          return null;
+        }
+        const { Address: Address2 } = await import("@ton/core");
+        const data = await response.json();
+        const match = (data.balances || []).find(
+          (b) => b.jetton.address.toLowerCase() === jettonAddress.toLowerCase() || Address2.parse(b.jetton.address).toString() === Address2.parse(jettonAddress).toString()
+        );
+        return match ? match.wallet_address.address : null;
+      } catch (err) {
+        log7.error("ton.getJettonWalletAddress() failed:", err);
+        return null;
+      }
+    },
+    // ─── NFT ─────────────────────────────────────────────────────
+    async getNftItems(ownerAddress) {
+      try {
+        const addr = ownerAddress ?? getWalletAddress();
+        if (!addr) return [];
+        const response = await tonapiFetch(
+          `/accounts/${encodeURIComponent(addr)}/nfts?limit=100&indirect_ownership=true`
+        );
+        if (!response.ok) {
+          log7.error(`ton.getNftItems() TonAPI error: ${response.status}`);
+          return [];
+        }
+        const data = await response.json();
+        if (!Array.isArray(data.nft_items)) return [];
+        return data.nft_items.filter((item) => item.trust !== "blacklist").map((item) => mapNftItem(item));
+      } catch (err) {
+        log7.error("ton.getNftItems() failed:", err);
+        return [];
+      }
+    },
+    async getNftInfo(nftAddress) {
+      try {
+        const response = await tonapiFetch(`/nfts/${nftAddress}`);
+        if (response.status === 404) return null;
+        if (!response.ok) {
+          log7.error(`ton.getNftInfo() TonAPI error: ${response.status}`);
+          return null;
+        }
+        const item = await response.json();
+        return mapNftItem(item);
+      } catch (err) {
+        log7.error("ton.getNftInfo() failed:", err);
+        return null;
+      }
+    },
+    // ─── Utilities ───────────────────────────────────────────────
+    toNano(amount) {
+      try {
+        const { toNano: convert } = __require("@ton/ton");
+        return convert(String(amount));
+      } catch (err) {
+        throw new PluginSDKError(
+          `toNano conversion failed: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    fromNano(nano) {
+      const { fromNano: convert } = __require("@ton/ton");
+      return convert(nano);
+    },
+    validateAddress(address) {
+      try {
+        const { Address: Address2 } = __require("@ton/core");
+        Address2.parse(address);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+function mapNftItem(item) {
+  const meta = item.metadata || {};
+  const coll = item.collection || {};
+  const previews = item.previews || [];
+  const preview = previews.length > 1 && previews[1].url || previews.length > 0 && previews[0].url || void 0;
+  return {
+    address: item.address,
+    index: item.index ?? 0,
+    ownerAddress: item.owner?.address || void 0,
+    collectionAddress: coll.address || void 0,
+    collectionName: coll.name || void 0,
+    name: meta.name || void 0,
+    description: meta.description ? meta.description.slice(0, 200) : void 0,
+    image: preview || meta.image || void 0,
+    verified: item.trust === "whitelist"
+  };
+}
+
+// src/utils/gramjs-bigint.ts
+var import_big_integer = __toESM(require_BigInteger(), 1);
+import { randomBytes } from "crypto";
+function toLong(value) {
+  return (0, import_big_integer.default)(String(value));
+}
+function randomLong() {
+  return toLong(randomBytes(8).readBigUInt64BE());
+}
+
+// src/sdk/telegram-messages.ts
+function createTelegramMessagesSDK(bridge, log7) {
+  function requireBridge() {
+    if (!bridge.isAvailable()) {
+      throw new PluginSDKError(
+        "Telegram bridge not connected. SDK telegram methods can only be called at runtime (inside tool executors or start()), not during plugin loading.",
+        "BRIDGE_NOT_CONNECTED"
+      );
+    }
+  }
+  function getClient() {
+    return bridge.getClient().getClient();
+  }
+  function toSimpleMessage(msg) {
+    return {
+      id: msg.id,
+      text: msg.message ?? "",
+      senderId: Number(msg.fromId?.userId ?? msg.fromId?.channelId ?? 0),
+      timestamp: new Date(msg.date * 1e3)
+    };
+  }
+  return {
+    // ─── Messages ──────────────────────────────────────────────
+    async deleteMessage(chatId, messageId, revoke = true) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        const isChannel = chatId.startsWith("-100");
+        if (isChannel) {
+          const channel = await gramJsClient.getEntity(chatId);
+          await gramJsClient.invoke(
+            new Api.channels.DeleteMessages({
+              channel,
+              id: [messageId]
+            })
+          );
+        } else {
+          await gramJsClient.invoke(
+            new Api.messages.DeleteMessages({
+              id: [messageId],
+              revoke
+            })
+          );
+        }
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to delete message: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async forwardMessage(fromChatId, toChatId, messageId) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        const result = await gramJsClient.invoke(
+          new Api.messages.ForwardMessages({
+            fromPeer: fromChatId,
+            toPeer: toChatId,
+            id: [messageId],
+            randomId: [randomLong()]
+          })
+        );
+        if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+          for (const update of result.updates) {
+            if (update.className === "UpdateNewMessage" || update.className === "UpdateNewChannelMessage") {
+              return update.message.id;
+            }
+          }
+        }
+        return 0;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to forward message: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async pinMessage(chatId, messageId, opts) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        await gramJsClient.invoke(
+          new Api.messages.UpdatePinnedMessage({
+            peer: chatId,
+            id: messageId,
+            silent: opts?.silent,
+            unpin: opts?.unpin
+          })
+        );
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to ${opts?.unpin ? "unpin" : "pin"} message: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async searchMessages(chatId, query, limit = 20) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        const entity = await gramJsClient.getEntity(chatId);
+        const result = await gramJsClient.invoke(
+          new Api.messages.Search({
+            peer: entity,
+            q: query,
+            filter: new Api.InputMessagesFilterEmpty(),
+            limit
+          })
+        );
+        const resultData = result;
+        return (resultData.messages ?? []).map(toSimpleMessage);
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        log7.error("telegram.searchMessages() failed:", err);
+        return [];
+      }
+    },
+    async scheduleMessage(chatId, text, scheduleDate) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const result = await gramJsClient.sendMessage(chatId, {
+          message: text,
+          schedule: scheduleDate
+        });
+        return result.id ?? 0;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to schedule message: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async getReplies(chatId, messageId, limit = 50) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        const bigInt2 = (await import("./BigInteger-DQ33LTTE.js")).default;
+        const peer = await gramJsClient.getInputEntity(chatId);
+        const result = await gramJsClient.invoke(
+          new Api.messages.GetReplies({
+            peer,
+            msgId: messageId,
+            offsetId: 0,
+            offsetDate: 0,
+            addOffset: 0,
+            limit,
+            maxId: 0,
+            minId: 0,
+            hash: bigInt2(0)
+          })
+        );
+        const messages = [];
+        if ("messages" in result) {
+          for (const msg of result.messages) {
+            if (msg.className === "Message") {
+              messages.push(toSimpleMessage(msg));
+            }
+          }
+        }
+        messages.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        return messages;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to get replies: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    // ─── Media ─────────────────────────────────────────────────
+    async sendPhoto(chatId, photo, opts) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const result = await gramJsClient.sendFile(chatId, {
+          file: photo,
+          caption: opts?.caption,
+          replyTo: opts?.replyToId
+        });
+        return result.id;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send photo: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendVideo(chatId, video, opts) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        const result = await gramJsClient.sendFile(chatId, {
+          file: video,
+          caption: opts?.caption,
+          replyTo: opts?.replyToId,
+          forceDocument: false,
+          attributes: [
+            new Api.DocumentAttributeVideo({
+              roundMessage: false,
+              supportsStreaming: true,
+              duration: 0,
+              w: 0,
+              h: 0
+            })
+          ]
+        });
+        return result.id;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send video: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendVoice(chatId, voice, opts) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        const result = await gramJsClient.sendFile(chatId, {
+          file: voice,
+          caption: opts?.caption,
+          replyTo: opts?.replyToId,
+          attributes: [new Api.DocumentAttributeAudio({ voice: true, duration: 0 })]
+        });
+        return result.id;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send voice: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendFile(chatId, file, opts) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        const attributes = [];
+        if (opts?.fileName) {
+          attributes.push(new Api.DocumentAttributeFilename({ fileName: opts.fileName }));
+        }
+        const result = await gramJsClient.sendFile(chatId, {
+          file,
+          caption: opts?.caption,
+          replyTo: opts?.replyToId,
+          forceDocument: true,
+          attributes: attributes.length > 0 ? attributes : void 0
+        });
+        return result.id;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send file: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendGif(chatId, gif, opts) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const { Api } = await import("telegram");
+        const result = await gramJsClient.sendFile(chatId, {
+          file: gif,
+          caption: opts?.caption,
+          replyTo: opts?.replyToId,
+          attributes: [new Api.DocumentAttributeAnimated()]
+        });
+        return result.id;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send GIF: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendSticker(chatId, sticker) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const result = await gramJsClient.sendFile(chatId, {
+          file: sticker
+        });
+        return result.id;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send sticker: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async downloadMedia(chatId, messageId) {
+      requireBridge();
+      try {
+        const gramJsClient = getClient();
+        const messages = await gramJsClient.getMessages(chatId, {
+          ids: [messageId]
+        });
+        if (!messages || messages.length === 0 || !messages[0].media) {
+          return null;
+        }
+        const buffer = await gramJsClient.downloadMedia(messages[0], {});
+        return buffer ? Buffer.from(buffer) : null;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to download media: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    // ─── Advanced ──────────────────────────────────────────────
+    async setTyping(chatId) {
+      requireBridge();
+      try {
+        await bridge.setTyping(chatId);
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to set typing: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    }
+  };
+}
+
+// src/sdk/telegram-social.ts
+function createTelegramSocialSDK(bridge, log7) {
+  function requireBridge() {
+    if (!bridge.isAvailable()) {
+      throw new PluginSDKError(
+        "Telegram bridge not connected. SDK telegram methods can only be called at runtime (inside tool executors or start()), not during plugin loading.",
+        "BRIDGE_NOT_CONNECTED"
+      );
+    }
+  }
+  function getClient() {
+    return bridge.getClient().getClient();
+  }
+  return {
+    // ─── Chat & Users ─────────────────────────────────────────
+    async getChatInfo(chatId) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        let entity;
+        try {
+          entity = await client.getEntity(chatId);
+        } catch {
+          return null;
+        }
+        const isChannel = entity.className === "Channel" || entity.className === "ChannelForbidden";
+        const isChat = entity.className === "Chat" || entity.className === "ChatForbidden";
+        const isUser = entity.className === "User";
+        if (isUser) {
+          const user = entity;
+          return {
+            id: user.id?.toString() || chatId,
+            title: [user.firstName, user.lastName].filter(Boolean).join(" ") || "Unknown",
+            type: "private",
+            username: user.username || void 0
+          };
+        }
+        if (isChannel) {
+          const channel = entity;
+          let description;
+          let membersCount;
+          try {
+            const fullChannel = await client.invoke(new Api.channels.GetFullChannel({ channel }));
+            const fullChat = fullChannel.fullChat;
+            description = fullChat.about || void 0;
+            membersCount = fullChat.participantsCount || void 0;
+          } catch {
+          }
+          const type = channel.megagroup ? "supergroup" : channel.broadcast ? "channel" : "group";
+          return {
+            id: channel.id?.toString() || chatId,
+            title: channel.title || "Unknown",
+            type,
+            username: channel.username || void 0,
+            description,
+            membersCount
+          };
+        }
+        if (isChat) {
+          const chat = entity;
+          let description;
+          try {
+            const fullChatResult = await client.invoke(
+              new Api.messages.GetFullChat({ chatId: chat.id })
+            );
+            const fullChat = fullChatResult.fullChat;
+            description = fullChat.about || void 0;
+          } catch {
+          }
+          return {
+            id: chat.id?.toString() || chatId,
+            title: chat.title || "Unknown",
+            type: "group",
+            description,
+            membersCount: chat.participantsCount || void 0
+          };
+        }
+        return null;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        log7.error("telegram.getChatInfo() failed:", err);
+        return null;
+      }
+    },
+    async getUserInfo(userId) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        let entity;
+        try {
+          const id = typeof userId === "string" ? userId.replace("@", "") : userId.toString();
+          entity = await client.getEntity(id);
+        } catch {
+          return null;
+        }
+        if (entity.className !== "User") return null;
+        const user = entity;
+        return {
+          id: Number(user.id),
+          firstName: user.firstName || "",
+          lastName: user.lastName || void 0,
+          username: user.username || void 0,
+          isBot: user.bot || false
+        };
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to get user info: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async resolveUsername(username) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        const cleanUsername = username.replace("@", "").toLowerCase();
+        if (!cleanUsername) return null;
+        let result;
+        try {
+          result = await client.invoke(
+            new Api.contacts.ResolveUsername({ username: cleanUsername })
+          );
+        } catch (err) {
+          if (err.message?.includes("USERNAME_NOT_OCCUPIED") || err.errorMessage === "USERNAME_NOT_OCCUPIED") {
+            return null;
+          }
+          throw err;
+        }
+        if (result.users && result.users.length > 0) {
+          const user = result.users[0];
+          if (user instanceof Api.User) {
+            return {
+              id: Number(user.id),
+              type: "user",
+              username: user.username || void 0,
+              title: user.firstName || void 0
+            };
+          }
+        }
+        if (result.chats && result.chats.length > 0) {
+          const chat = result.chats[0];
+          const type = chat.className === "Channel" ? "channel" : "chat";
+          return {
+            id: Number(chat.id),
+            type,
+            username: chat instanceof Api.Channel ? chat.username || void 0 : void 0,
+            title: chat instanceof Api.Channel || chat instanceof Api.Chat ? chat.title || void 0 : void 0
+          };
+        }
+        return null;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to resolve username: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async getParticipants(chatId, limit) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        const entity = await client.getEntity(chatId);
+        const result = await client.invoke(
+          new Api.channels.GetParticipants({
+            channel: entity,
+            filter: new Api.ChannelParticipantsRecent(),
+            offset: 0,
+            limit: limit ?? 100,
+            hash: toLong(0)
+          })
+        );
+        const resultData = result;
+        return (resultData.users || []).map((user) => {
+          const u = user;
+          return {
+            id: Number(u.id),
+            firstName: u.firstName || "",
+            lastName: u.lastName || void 0,
+            username: u.username || void 0,
+            isBot: u.bot || false
+          };
+        });
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        log7.error("telegram.getParticipants() failed:", err);
+        return [];
+      }
+    },
+    // ─── Interactive ──────────────────────────────────────────
+    async createPoll(chatId, question, answers, opts) {
+      requireBridge();
+      if (!answers || answers.length < 2) {
+        throw new PluginSDKError("Poll must have at least 2 answers", "OPERATION_FAILED");
+      }
+      if (answers.length > 10) {
+        throw new PluginSDKError("Poll cannot have more than 10 answers", "OPERATION_FAILED");
+      }
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        const anonymous = opts?.isAnonymous ?? true;
+        const multipleChoice = opts?.multipleChoice ?? false;
+        const poll = new Api.Poll({
+          id: randomLong(),
+          question: new Api.TextWithEntities({ text: question, entities: [] }),
+          answers: answers.map(
+            (opt, idx) => new Api.PollAnswer({
+              text: new Api.TextWithEntities({ text: opt, entities: [] }),
+              option: Buffer.from([idx])
+            })
+          ),
+          publicVoters: !anonymous,
+          multipleChoice
+        });
+        const result = await client.invoke(
+          new Api.messages.SendMedia({
+            peer: chatId,
+            media: new Api.InputMediaPoll({ poll }),
+            message: "",
+            randomId: randomLong()
+          })
+        );
+        if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+          for (const update of result.updates) {
+            if (update.className === "UpdateNewMessage" || update.className === "UpdateNewChannelMessage") {
+              return update.message?.id ?? 0;
+            }
+          }
+        }
+        return 0;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to create poll: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async createQuiz(chatId, question, answers, correctIndex, explanation) {
+      requireBridge();
+      if (!answers || answers.length < 2) {
+        throw new PluginSDKError("Quiz must have at least 2 answers", "OPERATION_FAILED");
+      }
+      if (answers.length > 10) {
+        throw new PluginSDKError("Quiz cannot have more than 10 answers", "OPERATION_FAILED");
+      }
+      if (correctIndex < 0 || correctIndex >= answers.length) {
+        throw new PluginSDKError(
+          `correctIndex ${correctIndex} is out of bounds (0-${answers.length - 1})`,
+          "OPERATION_FAILED"
+        );
+      }
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        const poll = new Api.Poll({
+          id: randomLong(),
+          question: new Api.TextWithEntities({ text: question, entities: [] }),
+          answers: answers.map(
+            (opt, idx) => new Api.PollAnswer({
+              text: new Api.TextWithEntities({ text: opt, entities: [] }),
+              option: Buffer.from([idx])
+            })
+          ),
+          quiz: true,
+          publicVoters: false,
+          multipleChoice: false
+        });
+        const result = await client.invoke(
+          new Api.messages.SendMedia({
+            peer: chatId,
+            media: new Api.InputMediaPoll({
+              poll,
+              correctAnswers: [Buffer.from([correctIndex])],
+              solution: explanation,
+              solutionEntities: []
+            }),
+            message: "",
+            randomId: randomLong()
+          })
+        );
+        if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+          for (const update of result.updates) {
+            if (update.className === "UpdateNewMessage" || update.className === "UpdateNewChannelMessage") {
+              return update.message?.id ?? 0;
+            }
+          }
+        }
+        return 0;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to create quiz: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    // ─── Moderation ───────────────────────────────────────────
+    async banUser(chatId, userId) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        await client.invoke(
+          new Api.channels.EditBanned({
+            channel: chatId,
+            participant: userId.toString(),
+            bannedRights: new Api.ChatBannedRights({
+              untilDate: 0,
+              viewMessages: true,
+              sendMessages: true,
+              sendMedia: true,
+              sendStickers: true,
+              sendGifs: true,
+              sendGames: true,
+              sendInline: true,
+              embedLinks: true
+            })
+          })
+        );
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to ban user: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async unbanUser(chatId, userId) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        await client.invoke(
+          new Api.channels.EditBanned({
+            channel: chatId,
+            participant: userId.toString(),
+            bannedRights: new Api.ChatBannedRights({
+              untilDate: 0
+            })
+          })
+        );
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to unban user: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async muteUser(chatId, userId, untilDate) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        await client.invoke(
+          new Api.channels.EditBanned({
+            channel: chatId,
+            participant: userId.toString(),
+            bannedRights: new Api.ChatBannedRights({
+              untilDate: untilDate ?? 0,
+              sendMessages: true
+            })
+          })
+        );
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to mute user: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    // ─── Stars & Gifts ────────────────────────────────────────
+    async getStarsBalance() {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        const result = await client.invoke(
+          new Api.payments.GetStarsStatus({
+            peer: new Api.InputPeerSelf()
+          })
+        );
+        return Number(result.balance?.amount?.toString() || "0");
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to get stars balance: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendGift(userId, giftId, opts) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        const user = await client.getEntity(userId.toString());
+        const invoiceData = {
+          peer: user,
+          giftId: BigInt(giftId),
+          hideName: opts?.anonymous ?? false,
+          message: opts?.message ? new Api.TextWithEntities({ text: opts.message, entities: [] }) : void 0
+        };
+        const form = await client.invoke(
+          new Api.payments.GetPaymentForm({
+            invoice: new Api.InputInvoiceStarGift(invoiceData)
+          })
+        );
+        await client.invoke(
+          new Api.payments.SendStarsForm({
+            formId: form.formId,
+            invoice: new Api.InputInvoiceStarGift(invoiceData)
+          })
+        );
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send gift: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async getAvailableGifts() {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        const result = await client.invoke(new Api.payments.GetStarGifts({ hash: 0 }));
+        if (result.className === "payments.StarGiftsNotModified") {
+          return [];
+        }
+        return (result.gifts || []).filter((gift) => !gift.soldOut).map((gift) => ({
+          id: gift.id?.toString(),
+          starsAmount: Number(gift.stars?.toString() || "0"),
+          availableAmount: gift.limited ? Number(gift.availabilityRemains?.toString() || "0") : void 0,
+          totalAmount: gift.limited ? Number(gift.availabilityTotal?.toString() || "0") : void 0
+        }));
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to get available gifts: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async getMyGifts(limit) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        const result = await client.invoke(
+          new Api.payments.GetSavedStarGifts({
+            peer: new Api.InputPeerSelf(),
+            offset: "",
+            limit: limit ?? 50
+          })
+        );
+        return (result.gifts || []).map((savedGift) => {
+          const gift = savedGift.gift;
+          return {
+            id: gift?.id?.toString() || "",
+            fromId: savedGift.fromId ? Number(savedGift.fromId) : void 0,
+            date: savedGift.date || 0,
+            starsAmount: Number(gift?.stars?.toString() || "0"),
+            saved: savedGift.unsaved !== true,
+            messageId: savedGift.msgId || void 0
+          };
+        });
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to get my gifts: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async getResaleGifts(limit) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        if (!Api.payments.GetResaleStarGifts) {
+          throw new PluginSDKError(
+            "Resale gift marketplace is not supported in the current Telegram API layer.",
+            "OPERATION_FAILED"
+          );
+        }
+        const result = await client.invoke(
+          new Api.payments.GetResaleStarGifts({
+            offset: "",
+            limit: limit ?? 50
+          })
+        );
+        return (result.gifts || []).map((listing) => ({
+          id: listing.odayId?.toString() || "",
+          starsAmount: Number(listing.resellStars?.toString() || "0")
+        }));
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to get resale gifts: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async buyResaleGift(giftId) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api } = await import("telegram");
+        if (!Api.InputInvoiceStarGiftResale) {
+          throw new PluginSDKError(
+            "Resale gift purchasing is not supported in the current Telegram API layer.",
+            "OPERATION_FAILED"
+          );
+        }
+        const stargiftInput = new Api.InputSavedStarGiftUser({
+          odayId: BigInt(giftId)
+        });
+        const invoiceData = { stargift: stargiftInput };
+        const form = await client.invoke(
+          new Api.payments.GetPaymentForm({
+            invoice: new Api.InputInvoiceStarGiftResale(invoiceData)
+          })
+        );
+        await client.invoke(
+          new Api.payments.SendStarsForm({
+            formId: form.formId,
+            invoice: new Api.InputInvoiceStarGiftResale(invoiceData)
+          })
+        );
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to buy resale gift: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendStory(mediaPath, opts) {
+      requireBridge();
+      try {
+        const client = getClient();
+        const { Api, helpers } = await import("telegram");
+        const { CustomFile } = await import("telegram/client/uploads.js");
+        const { readFileSync: readFileSync7, statSync: statSync2 } = await import("fs");
+        const { basename: basename2 } = await import("path");
+        const { resolve: resolve2, normalize: normalize2 } = await import("path");
+        const { homedir: homedir3 } = await import("os");
+        const { realpathSync } = await import("fs");
+        const filePath = realpathSync(resolve2(normalize2(mediaPath)));
+        const home = homedir3();
+        const teletonWorkspace = `${home}/.teleton/workspace/`;
+        const allowedPrefixes = [
+          "/tmp/",
+          `${home}/Downloads/`,
+          `${home}/Pictures/`,
+          `${home}/Videos/`,
+          `${teletonWorkspace}uploads/`,
+          `${teletonWorkspace}downloads/`,
+          `${teletonWorkspace}memes/`
+        ];
+        if (!allowedPrefixes.some((p) => filePath.startsWith(p))) {
+          throw new PluginSDKError(
+            "sendStory: media path must be within /tmp, Downloads, Pictures, or Videos",
+            "OPERATION_FAILED"
+          );
+        }
+        const fileName = basename2(filePath);
+        const fileSize = statSync2(filePath).size;
+        const fileBuffer = readFileSync7(filePath);
+        const isVideo = filePath.toLowerCase().match(/\.(mp4|mov|avi)$/);
+        const customFile = new CustomFile(fileName, fileSize, filePath, fileBuffer);
+        const uploadedFile = await client.uploadFile({
+          file: customFile,
+          workers: 1
+        });
+        let inputMedia;
+        if (isVideo) {
+          inputMedia = new Api.InputMediaUploadedDocument({
+            file: uploadedFile,
+            mimeType: "video/mp4",
+            attributes: [
+              new Api.DocumentAttributeVideo({
+                duration: 0,
+                w: 720,
+                h: 1280,
+                supportsStreaming: true
+              }),
+              new Api.DocumentAttributeFilename({ fileName })
+            ]
+          });
+        } else {
+          inputMedia = new Api.InputMediaUploadedPhoto({
+            file: uploadedFile
+          });
+        }
+        const privacyRules = [new Api.InputPrivacyValueAllowAll()];
+        const result = await client.invoke(
+          new Api.stories.SendStory({
+            peer: "me",
+            media: inputMedia,
+            caption: opts?.caption || "",
+            privacyRules,
+            randomId: helpers.generateRandomBigInt()
+          })
+        );
+        const storyUpdate = result instanceof Api.Updates ? result.updates.find((u) => u.className === "UpdateStory") : void 0;
+        return storyUpdate?.story?.id ?? 0;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send story: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    }
+  };
+}
+
+// src/sdk/telegram.ts
+function createTelegramSDK(bridge, log7) {
+  function requireBridge() {
+    if (!bridge.isAvailable()) {
+      throw new PluginSDKError(
+        "Telegram bridge not connected. SDK telegram methods can only be called at runtime (inside tool executors or start()), not during plugin loading.",
+        "BRIDGE_NOT_CONNECTED"
+      );
+    }
+  }
+  return {
+    async sendMessage(chatId, text, opts) {
+      requireBridge();
+      try {
+        const msg = await bridge.sendMessage({
+          chatId,
+          text,
+          replyToId: opts?.replyToId,
+          inlineKeyboard: opts?.inlineKeyboard
+        });
+        return msg.id;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send message: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async editMessage(chatId, messageId, text, opts) {
+      requireBridge();
+      try {
+        const msg = await bridge.editMessage({
+          chatId,
+          messageId,
+          text,
+          inlineKeyboard: opts?.inlineKeyboard
+        });
+        return typeof msg?.id === "number" ? msg.id : messageId;
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to edit message: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendDice(chatId, emoticon, replyToId) {
+      requireBridge();
+      try {
+        const gramJsClient = bridge.getClient().getClient();
+        const { Api } = await import("telegram");
+        const result = await gramJsClient.invoke(
+          new Api.messages.SendMedia({
+            peer: chatId,
+            media: new Api.InputMediaDice({ emoticon }),
+            message: "",
+            randomId: randomLong(),
+            replyTo: replyToId ? new Api.InputReplyToMessage({ replyToMsgId: replyToId }) : void 0
+          })
+        );
+        let value;
+        let messageId;
+        if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+          for (const update of result.updates) {
+            if (update.className === "UpdateNewMessage" || update.className === "UpdateNewChannelMessage") {
+              const msg = update.message;
+              if (msg instanceof Api.Message && msg.media?.className === "MessageMediaDice") {
+                value = msg.media.value;
+                messageId = msg.id;
+                break;
+              }
+            }
+          }
+        }
+        if (value === void 0 || messageId === void 0) {
+          throw new Error("Could not extract dice value from Telegram response");
+        }
+        return { value, messageId };
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send dice: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendReaction(chatId, messageId, emoji) {
+      requireBridge();
+      try {
+        await bridge.sendReaction(chatId, messageId, emoji);
+      } catch (err) {
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send reaction: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async getMessages(chatId, limit) {
+      requireBridge();
+      try {
+        const messages = await bridge.getMessages(chatId, limit ?? 50);
+        return messages.map((m) => ({
+          id: m.id,
+          text: m.text,
+          senderId: m.senderId,
+          senderUsername: m.senderUsername,
+          timestamp: m.timestamp
+        }));
+      } catch (err) {
+        log7.error("telegram.getMessages() failed:", err);
+        return [];
+      }
+    },
+    getMe() {
+      try {
+        const me = bridge.getClient()?.getMe?.();
+        if (!me) return null;
+        return {
+          id: Number(me.id),
+          username: me.username,
+          firstName: me.firstName,
+          isBot: me.isBot
+        };
+      } catch {
+        return null;
+      }
+    },
+    isAvailable() {
+      return bridge.isAvailable();
+    },
+    getRawClient() {
+      log7.warn("getRawClient() called \u2014 this bypasses SDK sandbox guarantees");
+      if (!bridge.isAvailable()) return null;
+      try {
+        return bridge.getClient().getClient();
+      } catch {
+        return null;
+      }
+    },
+    // Spread extended methods from sub-modules
+    ...createTelegramMessagesSDK(bridge, log7),
+    ...createTelegramSocialSDK(bridge, log7)
+  };
+}
+
+// src/sdk/secrets.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
+import { join as join3 } from "path";
+var SECRETS_DIR = join3(TELETON_ROOT, "plugins", "data");
+function getSecretsPath(pluginName) {
+  return join3(SECRETS_DIR, `${pluginName}.secrets.json`);
+}
+function readSecretsFile(pluginName) {
+  const filePath = getSecretsPath(pluginName);
+  try {
+    if (!existsSync5(filePath)) return {};
+    const raw = readFileSync4(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function writePluginSecret(pluginName, key, value) {
+  mkdirSync3(SECRETS_DIR, { recursive: true, mode: 448 });
+  const filePath = getSecretsPath(pluginName);
+  const existing = readSecretsFile(pluginName);
+  existing[key] = value;
+  writeFileSync2(filePath, JSON.stringify(existing, null, 2), { mode: 384 });
+}
+function deletePluginSecret(pluginName, key) {
+  const existing = readSecretsFile(pluginName);
+  if (!(key in existing)) return false;
+  delete existing[key];
+  const filePath = getSecretsPath(pluginName);
+  writeFileSync2(filePath, JSON.stringify(existing, null, 2), { mode: 384 });
+  return true;
+}
+function listPluginSecretKeys(pluginName) {
+  return Object.keys(readSecretsFile(pluginName));
+}
+function createSecretsSDK(pluginName, pluginConfig, log7) {
+  const envPrefix = pluginName.replace(/-/g, "_").toUpperCase();
+  function get(key) {
+    const envKey = `${envPrefix}_${key.toUpperCase()}`;
+    const envValue = process.env[envKey];
+    if (envValue) {
+      log7.debug(`Secret "${key}" resolved from env var ${envKey}`);
+      return envValue;
+    }
+    const stored = readSecretsFile(pluginName);
+    if (key in stored && stored[key]) {
+      log7.debug(`Secret "${key}" resolved from secrets store`);
+      return stored[key];
+    }
+    const configValue = pluginConfig[key];
+    if (configValue !== void 0 && configValue !== null) {
+      log7.debug(`Secret "${key}" resolved from pluginConfig`);
+      return String(configValue);
+    }
+    return void 0;
+  }
+  return {
+    get,
+    require(key) {
+      const value = get(key);
+      if (!value) {
+        throw new PluginSDKError(
+          `Missing required secret "${key}". Set it via: /plugin set ${pluginName} ${key} <value>`,
+          "SECRET_NOT_FOUND"
+        );
+      }
+      return value;
+    },
+    has(key) {
+      return get(key) !== void 0;
+    }
+  };
+}
+
+// src/sdk/storage.ts
+var KV_TABLE = "_kv";
+var CLEANUP_PROBABILITY2 = 0.05;
+function ensureTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ${KV_TABLE} (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      expires_at INTEGER
+    )
+  `);
+}
+function createStorageSDK(db) {
+  ensureTable(db);
+  const stmtGet = db.prepare(`SELECT value, expires_at FROM ${KV_TABLE} WHERE key = ?`);
+  const stmtSet = db.prepare(
+    `INSERT OR REPLACE INTO ${KV_TABLE} (key, value, expires_at) VALUES (?, ?, ?)`
+  );
+  const stmtDel = db.prepare(`DELETE FROM ${KV_TABLE} WHERE key = ?`);
+  const stmtHas = db.prepare(`SELECT 1 FROM ${KV_TABLE} WHERE key = ?`);
+  const stmtClear = db.prepare(`DELETE FROM ${KV_TABLE}`);
+  const stmtCleanup = db.prepare(
+    `DELETE FROM ${KV_TABLE} WHERE expires_at IS NOT NULL AND expires_at < ?`
+  );
+  function maybeCleanup() {
+    if (Math.random() < CLEANUP_PROBABILITY2) {
+      stmtCleanup.run(Date.now());
+    }
+  }
+  return {
+    get(key) {
+      maybeCleanup();
+      const row = stmtGet.get(key);
+      if (!row) return void 0;
+      if (row.expires_at !== null && row.expires_at < Date.now()) {
+        stmtDel.run(key);
+        return void 0;
+      }
+      try {
+        return JSON.parse(row.value);
+      } catch {
+        return row.value;
+      }
+    },
+    set(key, value, opts) {
+      const serialized = JSON.stringify(value);
+      const expiresAt = opts?.ttl ? Date.now() + opts.ttl : null;
+      stmtSet.run(key, serialized, expiresAt);
+    },
+    delete(key) {
+      const result = stmtDel.run(key);
+      return result.changes > 0;
+    },
+    has(key) {
+      const row = stmtGet.get(key);
+      if (!row) return false;
+      if (row.expires_at !== null && row.expires_at < Date.now()) {
+        stmtDel.run(key);
+        return false;
+      }
+      return true;
+    },
+    clear() {
+      stmtClear.run();
+    }
+  };
+}
+
+// src/sdk/index.ts
+var sdkLog = createLogger("SDK");
+var BLOCKED_SQL_RE = /\b(ATTACH|DETACH)\s+DATABASE\b/i;
+function createSafeDb(db) {
+  return new Proxy(db, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "exec") {
+        return (sql) => {
+          if (BLOCKED_SQL_RE.test(sql)) {
+            throw new Error("ATTACH/DETACH DATABASE is not allowed in plugin context");
+          }
+          return target.exec(sql);
+        };
+      }
+      if (prop === "prepare") {
+        return (sql) => {
+          if (BLOCKED_SQL_RE.test(sql)) {
+            throw new Error("ATTACH/DETACH DATABASE is not allowed in plugin context");
+          }
+          return target.prepare(sql);
+        };
+      }
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function createPluginSDK(deps, opts) {
+  const log7 = createLogger2(opts.pluginName);
+  const safeDb = opts.db ? createSafeDb(opts.db) : null;
+  const ton = Object.freeze(createTonSDK(log7, safeDb));
+  const telegram = Object.freeze(createTelegramSDK(deps.bridge, log7));
+  const secrets = Object.freeze(createSecretsSDK(opts.pluginName, opts.pluginConfig, log7));
+  const storage = safeDb ? Object.freeze(createStorageSDK(safeDb)) : null;
+  const frozenLog = Object.freeze(log7);
+  const frozenConfig = Object.freeze(opts.sanitizedConfig);
+  const frozenPluginConfig = Object.freeze(JSON.parse(JSON.stringify(opts.pluginConfig ?? {})));
+  return Object.freeze({
+    version: SDK_VERSION,
+    ton,
+    telegram,
+    secrets,
+    storage,
+    db: safeDb,
+    config: frozenConfig,
+    pluginConfig: frozenPluginConfig,
+    log: frozenLog
+  });
+}
+function createLogger2(pluginName) {
+  const pinoChild = createLogger(`plugin:${pluginName}`);
+  return {
+    info: (...args) => pinoChild.info(args.map(String).join(" ")),
+    warn: (...args) => pinoChild.warn(args.map(String).join(" ")),
+    error: (...args) => pinoChild.error(args.map(String).join(" ")),
+    debug: (...args) => pinoChild.debug(args.map(String).join(" "))
+  };
+}
+function parseSemver(v) {
+  const match = v.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1]),
+    minor: parseInt(match[2]),
+    patch: parseInt(match[3])
+  };
+}
+function semverGte(a, b) {
+  if (a.major !== b.major) return a.major > b.major;
+  if (a.minor !== b.minor) return a.minor > b.minor;
+  return a.patch >= b.patch;
+}
+function semverSatisfies(current, range) {
+  const cur = parseSemver(current);
+  if (!cur) {
+    sdkLog.warn(`[SDK] Could not parse current version "${current}", rejecting`);
+    return false;
+  }
+  if (range.startsWith(">=")) {
+    const req2 = parseSemver(range.slice(2));
+    if (!req2) {
+      sdkLog.warn(`[SDK] Malformed sdkVersion range "${range}", rejecting`);
+      return false;
+    }
+    return semverGte(cur, req2);
+  }
+  if (range.startsWith("^")) {
+    const req2 = parseSemver(range.slice(1));
+    if (!req2) {
+      sdkLog.warn(`[SDK] Malformed sdkVersion range "${range}", rejecting`);
+      return false;
+    }
+    if (req2.major === 0) {
+      return cur.major === 0 && cur.minor === req2.minor && semverGte(cur, req2);
+    }
+    return cur.major === req2.major && semverGte(cur, req2);
+  }
+  const req = parseSemver(range);
+  if (!req) {
+    sdkLog.warn(`[SDK] Malformed sdkVersion "${range}", rejecting`);
+    return false;
+  }
+  return cur.major === req.major && cur.minor === req.minor && cur.patch === req.patch;
+}
+
+// src/agent/tools/plugin-loader.ts
+var execFileAsync = promisify(execFile);
+var log6 = createLogger("PluginLoader");
+var PLUGIN_DATA_DIR = join4(TELETON_ROOT, "plugins", "data");
+function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
+  let manifest = null;
+  if (raw.manifest) {
+    try {
+      manifest = validateManifest(raw.manifest);
+    } catch (err) {
+      log6.warn(
+        `[${entryName}] invalid manifest, ignoring: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+  if (!manifest) {
+    const manifestPath = join4(WORKSPACE_PATHS.PLUGINS_DIR, entryName, "manifest.json");
+    try {
+      if (existsSync6(manifestPath)) {
+        const diskManifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
+        if (diskManifest && typeof diskManifest.version === "string") {
+          manifest = {
+            name: entryName,
+            version: diskManifest.version,
+            description: typeof diskManifest.description === "string" ? diskManifest.description : void 0,
+            author: typeof diskManifest.author === "string" ? diskManifest.author : diskManifest.author?.name ?? void 0
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  const pluginName = manifest?.name ?? entryName.replace(/\.js$/, "");
+  const pluginVersion = manifest?.version ?? "0.0.0";
+  if (manifest?.dependencies) {
+    for (const dep of manifest.dependencies) {
+      if (!loadedModuleNames.includes(dep)) {
+        throw new Error(`Plugin "${pluginName}" requires module "${dep}" which is not loaded`);
+      }
+    }
+  }
+  if (manifest?.sdkVersion) {
+    if (!semverSatisfies(SDK_VERSION, manifest.sdkVersion)) {
+      throw new Error(
+        `Plugin "${pluginName}" requires SDK ${manifest.sdkVersion} but current SDK is ${SDK_VERSION}`
+      );
+    }
+  }
+  const pluginConfigKey = pluginName.replace(/-/g, "_");
+  const rawPluginConfig = config.plugins?.[pluginConfigKey] ?? {};
+  const pluginConfig = { ...manifest?.defaultConfig, ...rawPluginConfig };
+  const pluginLog = createLogger(`Plugin:${pluginName}`);
+  const logFn = (...args) => pluginLog.info(args.map(String).join(" "));
+  if (manifest?.secrets) {
+    const dummyLogger = {
+      info: (...a) => pluginLog.info(a.map(String).join(" ")),
+      warn: (...a) => pluginLog.warn(a.map(String).join(" ")),
+      error: (...a) => pluginLog.error(a.map(String).join(" ")),
+      debug: () => {
+      }
+    };
+    const secretsCheck = createSecretsSDK(pluginName, pluginConfig, dummyLogger);
+    const missing = [];
+    for (const [key, decl] of Object.entries(
+      manifest.secrets
+    )) {
+      if (decl.required && !secretsCheck.has(key)) {
+        missing.push(`${key} \u2014 ${decl.description}`);
+      }
+    }
+    if (missing.length > 0) {
+      pluginLog.warn(
+        `Missing required secrets:
+` + missing.map((m) => `   \u2022 ${m}`).join("\n") + `
+   Set via: /plugin set ${pluginName} <key> <value>`
+      );
+    }
+  }
+  const hasMigrate = typeof raw.migrate === "function";
+  let pluginDb = null;
+  const getDb = () => pluginDb;
+  const withPluginDb = createDbWrapper(getDb, pluginName);
+  const sanitizedConfig = sanitizeConfigForPlugins(config);
+  const module = {
+    name: pluginName,
+    version: pluginVersion,
+    // Store event hooks from plugin exports
+    onMessage: typeof raw.onMessage === "function" ? raw.onMessage : void 0,
+    onCallbackQuery: typeof raw.onCallbackQuery === "function" ? raw.onCallbackQuery : void 0,
+    configure() {
+    },
+    migrate() {
+      try {
+        const dbPath = join4(PLUGIN_DATA_DIR, `${pluginName}.db`);
+        pluginDb = openModuleDb(dbPath);
+        if (hasMigrate) {
+          raw.migrate(pluginDb);
+          const pluginTables = pluginDb.prepare(
+            `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`
+          ).all().map((t) => t.name).filter((n) => n !== "_kv");
+          if (pluginTables.length > 0) {
+            migrateFromMainDb(pluginDb, pluginTables);
+          }
+        }
+      } catch (err) {
+        pluginLog.error(`migrate() failed: ${err instanceof Error ? err.message : err}`);
+        if (pluginDb) {
+          try {
+            pluginDb.close();
+          } catch {
+          }
+          pluginDb = null;
+        }
+      }
+    },
+    tools() {
+      try {
+        let toolDefs;
+        if (typeof raw.tools === "function") {
+          const sdk = createPluginSDK(sdkDeps, {
+            pluginName,
+            db: pluginDb,
+            sanitizedConfig,
+            pluginConfig
+          });
+          toolDefs = raw.tools(sdk);
+        } else if (Array.isArray(raw.tools)) {
+          toolDefs = raw.tools;
+        } else {
+          return [];
+        }
+        const validDefs = validateToolDefs(toolDefs, pluginName);
+        return validDefs.map((def) => {
+          const rawExecutor = def.execute;
+          const sandboxedExecutor = (params, context) => {
+            const sanitizedContext = {
+              ...context,
+              config: context.config ? sanitizeConfigForPlugins(context.config) : void 0
+            };
+            return rawExecutor(params, sanitizedContext);
+          };
+          return {
+            tool: {
+              name: def.name,
+              description: def.description,
+              parameters: def.parameters || {
+                type: "object",
+                properties: {}
+              },
+              ...def.category ? { category: def.category } : {}
+            },
+            executor: pluginDb ? withPluginDb(sandboxedExecutor) : sandboxedExecutor,
+            scope: def.scope
+          };
+        });
+      } catch (err) {
+        pluginLog.error(`tools() failed: ${err instanceof Error ? err.message : err}`);
+        return [];
+      }
+    },
+    async start(context) {
+      if (!raw.start) return;
+      try {
+        const enhancedContext = {
+          bridge: context.bridge,
+          db: pluginDb ?? null,
+          config: sanitizedConfig,
+          pluginConfig,
+          log: logFn
+        };
+        await raw.start(enhancedContext);
+      } catch (err) {
+        pluginLog.error(`start() failed: ${err instanceof Error ? err.message : err}`);
+      }
+    },
+    async stop() {
+      try {
+        await raw.stop?.();
+      } catch (err) {
+        pluginLog.error(`stop() failed: ${err instanceof Error ? err.message : err}`);
+      } finally {
+        if (pluginDb) {
+          try {
+            pluginDb.close();
+          } catch {
+          }
+          pluginDb = null;
+        }
+      }
+    }
+  };
+  return module;
+}
+async function ensurePluginDeps(pluginDir, pluginEntry) {
+  const pkgJson = join4(pluginDir, "package.json");
+  const lockfile = join4(pluginDir, "package-lock.json");
+  const nodeModules = join4(pluginDir, "node_modules");
+  if (!existsSync6(pkgJson)) return;
+  if (!existsSync6(lockfile)) {
+    log6.warn(
+      `[${pluginEntry}] package.json without package-lock.json \u2014 skipping (lockfile required)`
+    );
+    return;
+  }
+  if (existsSync6(nodeModules)) {
+    const marker = join4(nodeModules, ".package-lock.json");
+    if (existsSync6(marker) && statSync(marker).mtimeMs >= statSync(lockfile).mtimeMs) return;
+  }
+  log6.info(`[${pluginEntry}] Installing dependencies...`);
+  try {
+    await execFileAsync("npm", ["ci", "--ignore-scripts", "--no-audit", "--no-fund"], {
+      cwd: pluginDir,
+      timeout: 6e4,
+      env: { ...process.env, NODE_ENV: "production" }
+    });
+    log6.info(`[${pluginEntry}] Dependencies installed`);
+  } catch (err) {
+    log6.error(`[${pluginEntry}] Failed to install deps: ${String(err).slice(0, 300)}`);
+  }
+}
+async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
+  const pluginsDir = WORKSPACE_PATHS.PLUGINS_DIR;
+  if (!existsSync6(pluginsDir)) {
+    return [];
+  }
+  const entries = readdirSync2(pluginsDir);
+  const modules = [];
+  const loadedNames = /* @__PURE__ */ new Set();
+  const pluginPaths = [];
+  for (const entry of entries) {
+    if (entry === "data") continue;
+    const entryPath = join4(pluginsDir, entry);
+    let modulePath = null;
+    try {
+      const stat = statSync(entryPath);
+      if (stat.isFile() && entry.endsWith(".js")) {
+        modulePath = entryPath;
+      } else if (stat.isDirectory()) {
+        const indexPath = join4(entryPath, "index.js");
+        if (existsSync6(indexPath)) {
+          modulePath = indexPath;
+        }
+      }
+    } catch {
+      continue;
+    }
+    if (modulePath) {
+      pluginPaths.push({ entry, path: modulePath });
+    }
+  }
+  await Promise.allSettled(
+    pluginPaths.filter(({ path }) => path.endsWith("index.js")).map(({ entry }) => ensurePluginDeps(join4(pluginsDir, entry), entry))
+  );
+  const loadResults = await Promise.allSettled(
+    pluginPaths.map(async ({ entry, path }) => {
+      const moduleUrl = pathToFileURL(path).href;
+      const mod = await import(moduleUrl);
+      return { entry, mod };
+    })
+  );
+  for (const result of loadResults) {
+    if (result.status === "rejected") {
+      log6.error(
+        `Plugin failed to load: ${result.reason instanceof Error ? result.reason.message : result.reason}`
+      );
+      continue;
+    }
+    const { entry, mod } = result.value;
+    try {
+      if (!mod.tools || typeof mod.tools !== "function" && !Array.isArray(mod.tools)) {
+        log6.warn(`Plugin "${entry}": no 'tools' array or function exported, skipping`);
+        continue;
+      }
+      const adapted = adaptPlugin(mod, entry, config, loadedModuleNames, sdkDeps);
+      if (loadedNames.has(adapted.name)) {
+        log6.warn(`Plugin "${adapted.name}" already loaded, skipping duplicate from "${entry}"`);
+        continue;
+      }
+      loadedNames.add(adapted.name);
+      modules.push(adapted);
+    } catch (err) {
+      log6.error(`Plugin "${entry}" failed to adapt: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  return modules;
+}
+
+// src/config/configurable-keys.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync7 } from "fs";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+var noValidation = () => void 0;
+var identity = (v) => v;
+var nonEmpty = (v) => v.length > 0 ? void 0 : "Must not be empty";
+function numberInRange(min, max) {
+  return (v) => {
+    const n = Number(v);
+    if (isNaN(n)) return "Must be a number";
+    if (n < min || n > max) return `Must be between ${min} and ${max}`;
+    return void 0;
+  };
+}
+function enumValidator(options) {
+  return (v) => options.includes(v) ? void 0 : `Must be one of: ${options.join(", ")}`;
+}
+var CONFIGURABLE_KEYS = {
+  // ─── API Keys ──────────────────────────────────────────────────────
+  "agent.api_key": {
+    type: "string",
+    category: "API Keys",
+    description: "LLM provider API key",
+    sensitive: true,
+    validate: (v) => v.length >= 10 ? void 0 : "Must be at least 10 characters",
+    mask: (v) => v.slice(0, 8) + "****",
+    parse: identity
+  },
+  tavily_api_key: {
+    type: "string",
+    category: "API Keys",
+    description: "Tavily API key for web search",
+    sensitive: true,
+    validate: (v) => v.startsWith("tvly-") ? void 0 : "Must start with 'tvly-'",
+    mask: (v) => v.slice(0, 9) + "****",
+    parse: identity
+  },
+  tonapi_key: {
+    type: "string",
+    category: "API Keys",
+    description: "TonAPI key for higher rate limits",
+    sensitive: true,
+    validate: (v) => v.length >= 10 ? void 0 : "Must be at least 10 characters",
+    mask: (v) => v.slice(0, 10) + "****",
+    parse: identity
+  },
+  "telegram.bot_token": {
+    type: "string",
+    category: "API Keys",
+    description: "Bot token from @BotFather",
+    sensitive: true,
+    validate: (v) => v.includes(":") ? void 0 : "Must contain ':' (e.g., 123456:ABC...)",
+    mask: (v) => v.split(":")[0] + ":****",
+    parse: identity
+  },
+  // ─── Agent ─────────────────────────────────────────────────────────
+  "agent.provider": {
+    type: "enum",
+    category: "Agent",
+    description: "LLM provider",
+    sensitive: false,
+    options: [
+      "anthropic",
+      "openai",
+      "google",
+      "xai",
+      "groq",
+      "openrouter",
+      "moonshot",
+      "mistral",
+      "cocoon",
+      "local"
+    ],
+    validate: enumValidator([
+      "anthropic",
+      "openai",
+      "google",
+      "xai",
+      "groq",
+      "openrouter",
+      "moonshot",
+      "mistral",
+      "cocoon",
+      "local"
+    ]),
+    mask: identity,
+    parse: identity
+  },
+  "agent.model": {
+    type: "string",
+    category: "Agent",
+    description: "Main LLM model ID",
+    sensitive: false,
+    validate: nonEmpty,
+    mask: identity,
+    parse: identity
+  },
+  "agent.utility_model": {
+    type: "string",
+    category: "Agent",
+    description: "Cheap model for summarization (auto-detected if empty)",
+    sensitive: false,
+    validate: noValidation,
+    mask: identity,
+    parse: identity
+  },
+  "agent.temperature": {
+    type: "number",
+    category: "Agent",
+    description: "Response creativity (0.0 = deterministic, 2.0 = max)",
+    sensitive: false,
+    validate: numberInRange(0, 2),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "agent.max_tokens": {
+    type: "number",
+    category: "Agent",
+    description: "Maximum response length in tokens",
+    sensitive: false,
+    validate: numberInRange(256, 128e3),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "agent.max_agentic_iterations": {
+    type: "number",
+    category: "Agent",
+    description: "Max tool-call loop iterations per message",
+    sensitive: false,
+    validate: numberInRange(1, 20),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  // ─── Session ───────────────────────────────────────────────────
+  "agent.session_reset_policy.daily_reset_enabled": {
+    type: "boolean",
+    category: "Session",
+    description: "Enable daily session reset at specified hour",
+    sensitive: false,
+    validate: enumValidator(["true", "false"]),
+    mask: identity,
+    parse: (v) => v === "true"
+  },
+  "agent.session_reset_policy.daily_reset_hour": {
+    type: "number",
+    category: "Session",
+    description: "Hour (0-23 UTC) for daily session reset",
+    sensitive: false,
+    validate: numberInRange(0, 23),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "agent.session_reset_policy.idle_expiry_enabled": {
+    type: "boolean",
+    category: "Session",
+    description: "Enable automatic session expiry after idle period",
+    sensitive: false,
+    validate: enumValidator(["true", "false"]),
+    mask: identity,
+    parse: (v) => v === "true"
+  },
+  "agent.session_reset_policy.idle_expiry_minutes": {
+    type: "number",
+    category: "Session",
+    description: "Idle minutes before session expires (minimum 1)",
+    sensitive: false,
+    validate: numberInRange(1, Number.MAX_SAFE_INTEGER),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  // ─── Telegram ──────────────────────────────────────────────────────
+  "telegram.bot_username": {
+    type: "string",
+    category: "Telegram",
+    description: "Bot username without @",
+    sensitive: false,
+    validate: (v) => v.length >= 3 ? void 0 : "Must be at least 3 characters",
+    mask: identity,
+    parse: identity
+  },
+  "telegram.dm_policy": {
+    type: "enum",
+    category: "Telegram",
+    description: "DM access policy",
+    sensitive: false,
+    options: ["pairing", "allowlist", "open", "disabled"],
+    validate: enumValidator(["pairing", "allowlist", "open", "disabled"]),
+    mask: identity,
+    parse: identity
+  },
+  "telegram.group_policy": {
+    type: "enum",
+    category: "Telegram",
+    description: "Group access policy",
+    sensitive: false,
+    options: ["open", "allowlist", "disabled"],
+    validate: enumValidator(["open", "allowlist", "disabled"]),
+    mask: identity,
+    parse: identity
+  },
+  "telegram.require_mention": {
+    type: "boolean",
+    category: "Telegram",
+    description: "Require @mention in groups to respond",
+    sensitive: false,
+    validate: enumValidator(["true", "false"]),
+    mask: identity,
+    parse: (v) => v === "true"
+  },
+  "telegram.owner_name": {
+    type: "string",
+    category: "Telegram",
+    description: "Owner's first name (used in system prompt)",
+    sensitive: false,
+    validate: noValidation,
+    mask: identity,
+    parse: identity
+  },
+  "telegram.owner_username": {
+    type: "string",
+    category: "Telegram",
+    description: "Owner's Telegram username (without @)",
+    sensitive: false,
+    validate: noValidation,
+    mask: identity,
+    parse: identity
+  },
+  "telegram.debounce_ms": {
+    type: "number",
+    category: "Telegram",
+    description: "Group message debounce delay in ms (0 = disabled)",
+    sensitive: false,
+    validate: numberInRange(0, 1e4),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "telegram.agent_channel": {
+    type: "string",
+    category: "Telegram",
+    description: "Channel username for auto-publishing",
+    sensitive: false,
+    validate: noValidation,
+    mask: identity,
+    parse: identity
+  },
+  "telegram.typing_simulation": {
+    type: "boolean",
+    category: "Telegram",
+    description: "Simulate typing indicator before sending replies",
+    sensitive: false,
+    validate: enumValidator(["true", "false"]),
+    mask: identity,
+    parse: (v) => v === "true"
+  },
+  // ─── Embedding ─────────────────────────────────────────────────────
+  "embedding.provider": {
+    type: "enum",
+    category: "Embedding",
+    description: "Embedding provider for RAG",
+    sensitive: false,
+    options: ["local", "anthropic", "none"],
+    validate: enumValidator(["local", "anthropic", "none"]),
+    mask: identity,
+    parse: identity
+  },
+  // ─── WebUI ─────────────────────────────────────────────────────────
+  "webui.port": {
+    type: "number",
+    category: "WebUI",
+    description: "HTTP server port (requires restart)",
+    sensitive: false,
+    validate: numberInRange(1024, 65535),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "webui.log_requests": {
+    type: "boolean",
+    category: "WebUI",
+    description: "Log all HTTP requests to console",
+    sensitive: false,
+    validate: enumValidator(["true", "false"]),
+    mask: identity,
+    parse: (v) => v === "true"
+  },
+  // ─── Deals ─────────────────────────────────────────────────────────
+  "deals.enabled": {
+    type: "boolean",
+    category: "Deals",
+    description: "Enable the deals/escrow module",
+    sensitive: false,
+    validate: enumValidator(["true", "false"]),
+    mask: identity,
+    parse: (v) => v === "true"
+  },
+  // ─── Developer ─────────────────────────────────────────────────────
+  "dev.hot_reload": {
+    type: "boolean",
+    category: "Developer",
+    description: "Watch ~/.teleton/plugins/ for live changes",
+    sensitive: false,
+    validate: enumValidator(["true", "false"]),
+    mask: identity,
+    parse: (v) => v === "true"
+  }
+};
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assertSafePath(parts) {
+  if (parts.some((p) => FORBIDDEN_SEGMENTS.has(p))) {
+    throw new Error("Invalid config path: forbidden segment");
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  assertSafePath(parts);
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  assertSafePath(parts);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] == null || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function deleteNestedValue(obj, path) {
+  const parts = path.split(".");
+  assertSafePath(parts);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current == null || typeof current !== "object") return;
+    current = current[parts[i]];
+  }
+  if (current != null && typeof current === "object") {
+    delete current[parts[parts.length - 1]];
+  }
+}
+function readRawConfig(configPath) {
+  const fullPath = expandPath(configPath);
+  if (!existsSync7(fullPath)) {
+    throw new Error(`Config file not found: ${fullPath}
+Run 'teleton setup' to create one.`);
+  }
+  const raw = parse2(readFileSync6(fullPath, "utf-8"));
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`Invalid config file: ${fullPath}`);
+  }
+  return raw;
+}
+function writeRawConfig(raw, configPath) {
+  const clone = { ...raw };
+  delete clone.market;
+  const result = ConfigSchema.safeParse(clone);
+  if (!result.success) {
+    throw new Error(`Refusing to save invalid config: ${result.error.message}`);
+  }
+  raw.meta = raw.meta ?? {};
+  raw.meta.last_modified_at = (/* @__PURE__ */ new Date()).toISOString();
+  const fullPath = expandPath(configPath);
+  writeFileSync3(fullPath, stringify2(raw), { encoding: "utf-8", mode: 384 });
+}
+
+export {
+  loadConfig,
+  configExists,
+  getDefaultConfigPath,
+  WorkspaceSecurityError,
+  validatePath,
+  validateReadPath,
+  validateWritePath,
+  validateDirectory,
+  appendToDailyLog,
+  writeSummaryToDailyLog,
+  sanitizeForPrompt,
+  sanitizeForContext,
+  clearPromptCache,
+  loadSoul,
+  buildSystemPrompt,
+  writePluginSecret,
+  deletePluginSecret,
+  listPluginSecretKeys,
+  toLong,
+  randomLong,
+  withBlockchainRetry,
+  sendTon,
+  adaptPlugin,
+  ensurePluginDeps,
+  loadEnhancedPlugins,
+  CONFIGURABLE_KEYS,
+  getNestedValue,
+  setNestedValue,
+  deleteNestedValue,
+  readRawConfig,
+  writeRawConfig
+};