teleton 0.8.1 → 0.8.3

package/dist/chunk-AEHTQI3H.js

@@ -0,0 +1,142 @@
+import {
+  ConfigSchema
+} from "./chunk-AERHOXGC.js";
+import {
+  getProviderMetadata
+} from "./chunk-6OOHHJ4N.js";
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.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" && provider !== "claude-code" && !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.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_API_ENABLED) {
+    if (!config.api) config.api = { enabled: false, port: 7778, key_hash: "", allowed_ips: [] };
+    config.api.enabled = process.env.TELETON_API_ENABLED === "true";
+  }
+  if (process.env.TELETON_API_PORT) {
+    const port = parseInt(process.env.TELETON_API_PORT, 10);
+    if (!isNaN(port) && port >= 1024 && port <= 65535) {
+      if (!config.api) config.api = { enabled: false, port: 7778, key_hash: "", allowed_ips: [] };
+      config.api.port = port;
+    }
+  }
+  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;
+  }
+  if (process.env.TELETON_TONCENTER_API_KEY) {
+    config.toncenter_api_key = process.env.TELETON_TONCENTER_API_KEY;
+  }
+  return config;
+}
+function configExists(configPath = DEFAULT_CONFIG_PATH) {
+  return existsSync(expandPath(configPath));
+}
+function getDefaultConfigPath() {
+  return DEFAULT_CONFIG_PATH;
+}
+
+export {
+  expandPath,
+  loadConfig,
+  configExists,
+  getDefaultConfigPath
+};

package/dist/{chunk-S6PHGKOC.js → chunk-AERHOXGC.js}

@@ -1,13 +1,6 @@
-import {
-  COINGECKO_API_URL,
-  tonapiFetch
-} from "./chunk-VFA7QMCZ.js";
 import {
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-UP55PXFH.js";
-import {
-  fetchWithTimeout
-} from "./chunk-XQUHC3JZ.js";
+} from "./chunk-C4NKJT2Z.js";
 import {
   TELETON_ROOT,
   WORKSPACE_PATHS,
@@ -15,228 +8,98 @@ import {
 } from "./chunk-EYWNOHMJ.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 
-// src/ton/endpoint.ts
-var ENDPOINT_CACHE_TTL_MS = 6e4;
-var ORBS_HOST = "ton.access.orbs.network";
-var ORBS_TOPOLOGY_URL = `https://${ORBS_HOST}/mngr/nodes?npm_version=2.3.3`;
-var TONCENTER_URL = `https://toncenter.com/api/v2/jsonRPC`;
-var _cache = null;
-var _toncenterApiKey;
-function setToncenterApiKey(key) {
-  _toncenterApiKey = key;
-}
-function getToncenterApiKey() {
-  return _toncenterApiKey;
-}
-async function discoverOrbsEndpoint() {
-  const res = await fetch(ORBS_TOPOLOGY_URL, { signal: AbortSignal.timeout(5e3) });
-  const nodes = await res.json();
-  const healthy = nodes.filter(
-    (n) => n.Healthy === "1" && n.Weight > 0 && n.Mngr?.health?.["v2-mainnet"]
-  );
-  if (healthy.length === 0) throw new Error("no healthy orbs nodes");
-  const totalWeight = healthy.reduce((sum, n) => sum + n.Weight, 0);
-  let r = Math.floor(Math.random() * totalWeight);
-  let chosen = healthy[0];
-  for (const node of healthy) {
-    r -= node.Weight;
-    if (r < 0) {
-      chosen = node;
-      break;
-    }
-  }
-  return `https://${ORBS_HOST}/${chosen.NodeId}/1/mainnet/toncenter-api-v2/jsonRPC`;
-}
-async function getCachedHttpEndpoint() {
-  if (_cache && Date.now() - _cache.ts < ENDPOINT_CACHE_TTL_MS) {
-    return _cache.url;
-  }
-  let url;
-  if (_toncenterApiKey) {
-    try {
-      const testUrl = `https://toncenter.com/api/v2/getAddressInformation?address=EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c`;
-      const res = await fetch(testUrl, {
-        headers: { "X-API-Key": _toncenterApiKey },
-        signal: AbortSignal.timeout(5e3)
-      });
-      if (!res.ok) throw new Error(`TonCenter ${res.status}`);
-      url = TONCENTER_URL;
-    } catch {
-      try {
-        url = await discoverOrbsEndpoint();
-      } catch {
-        url = TONCENTER_URL;
-      }
-    }
-  } else {
-    try {
-      url = await discoverOrbsEndpoint();
-    } catch {
-      url = TONCENTER_URL;
-    }
-  }
-  _cache = { url, ts: Date.now() };
-  return url;
-}
-function invalidateEndpointCache() {
-  _cache = null;
-}
-
-// src/ton/wallet-service.ts
-import { mnemonicNew, mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto";
-import { WalletContractV5R1, TonClient, fromNano } from "@ton/ton";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+// src/workspace/manager.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from "fs";
 import { join, dirname } from "path";
-var log = createLogger("TON");
-var WALLET_FILE = join(TELETON_ROOT, "wallet.json");
-var _walletCache;
-var _keyPairCache = null;
-var _tonClientCache = null;
-async function generateWallet() {
-  const mnemonic = await mnemonicNew(24);
-  const keyPair = await mnemonicToPrivateKey(mnemonic);
-  const wallet = WalletContractV5R1.create({
-    workchain: 0,
-    publicKey: keyPair.publicKey
-  });
-  const address = wallet.address.toString({ bounceable: true, testOnly: false });
-  return {
-    version: "w5r1",
-    address,
-    publicKey: keyPair.publicKey.toString("hex"),
-    mnemonic,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function saveWallet(wallet) {
-  const dir = dirname(WALLET_FILE);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+import { fileURLToPath } from "url";
+var log = createLogger("Workspace");
+function findPackageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    dir = dirname(dir);
   }
-  writeFileSync(WALLET_FILE, JSON.stringify(wallet, null, 2), { encoding: "utf-8", mode: 384 });
-  _walletCache = void 0;
-  _keyPairCache = null;
+  return process.cwd();
 }
-function loadWallet() {
-  if (_walletCache !== void 0) return _walletCache;
-  if (!existsSync(WALLET_FILE)) {
-    _walletCache = null;
-    return null;
+var TEMPLATES_DIR = join(findPackageRoot(), "src", "templates");
+async function ensureWorkspace(config) {
+  const silent = config?.silent ?? false;
+  if (!existsSync(TELETON_ROOT)) {
+    mkdirSync(TELETON_ROOT, { recursive: true });
+    if (!silent) log.info(`Created Teleton root at ${TELETON_ROOT}`);
   }
-  try {
-    const content = readFileSync(WALLET_FILE, "utf-8");
-    const parsed = JSON.parse(content);
-    if (!parsed.mnemonic || !Array.isArray(parsed.mnemonic) || parsed.mnemonic.length !== 24) {
-      throw new Error("Invalid wallet.json: mnemonic must be a 24-word array");
-    }
-    _walletCache = parsed;
-    return _walletCache;
-  } catch (error) {
-    log.error({ err: error }, "Failed to load wallet");
-    _walletCache = null;
-    return null;
+  if (!existsSync(WORKSPACE_ROOT)) {
+    mkdirSync(WORKSPACE_ROOT, { recursive: true });
+    if (!silent) log.info(`Created workspace at ${WORKSPACE_ROOT}`);
   }
-}
-function walletExists() {
-  return existsSync(WALLET_FILE);
-}
-async function importWallet(mnemonic) {
-  const valid = await mnemonicValidate(mnemonic);
-  if (!valid) {
-    throw new Error("Invalid mnemonic: words do not form a valid TON seed phrase");
+  const directories = [
+    WORKSPACE_PATHS.MEMORY_DIR,
+    WORKSPACE_PATHS.DOWNLOADS_DIR,
+    WORKSPACE_PATHS.UPLOADS_DIR,
+    WORKSPACE_PATHS.TEMP_DIR,
+    WORKSPACE_PATHS.MEMES_DIR
+  ];
+  for (const dir of directories) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
   }
-  const keyPair = await mnemonicToPrivateKey(mnemonic);
-  const wallet = WalletContractV5R1.create({
-    workchain: 0,
-    publicKey: keyPair.publicKey
-  });
-  const address = wallet.address.toString({ bounceable: true, testOnly: false });
-  return {
-    version: "w5r1",
-    address,
-    publicKey: keyPair.publicKey.toString("hex"),
-    mnemonic,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  const workspace = {
+    root: TELETON_ROOT,
+    workspace: WORKSPACE_ROOT,
+    // Workspace files
+    soulPath: WORKSPACE_PATHS.SOUL,
+    memoryPath: WORKSPACE_PATHS.MEMORY,
+    identityPath: WORKSPACE_PATHS.IDENTITY,
+    userPath: WORKSPACE_PATHS.USER,
+    strategyPath: WORKSPACE_PATHS.STRATEGY,
+    securityPath: WORKSPACE_PATHS.SECURITY,
+    // Workspace directories
+    memoryDir: WORKSPACE_PATHS.MEMORY_DIR,
+    downloadsDir: WORKSPACE_PATHS.DOWNLOADS_DIR,
+    uploadsDir: WORKSPACE_PATHS.UPLOADS_DIR,
+    tempDir: WORKSPACE_PATHS.TEMP_DIR,
+    memesDir: WORKSPACE_PATHS.MEMES_DIR,
+    // Protected files (outside workspace)
+    sessionPath: join(TELETON_ROOT, "telegram_session.txt"),
+    configPath: join(TELETON_ROOT, "config.yaml"),
+    walletPath: join(TELETON_ROOT, "wallet.json")
   };
-}
-function getWalletAddress() {
-  const wallet = loadWallet();
-  return wallet?.address || null;
-}
-async function getCachedTonClient() {
-  const endpoint = await getCachedHttpEndpoint();
-  if (_tonClientCache && _tonClientCache.endpoint === endpoint) {
-    return _tonClientCache.client;
-  }
-  const apiKey = getToncenterApiKey();
-  const client = new TonClient({ endpoint, ...apiKey && { apiKey } });
-  _tonClientCache = { client, endpoint };
-  return client;
-}
-function invalidateTonClientCache() {
-  _tonClientCache = null;
-  invalidateEndpointCache();
-}
-async function getKeyPair() {
-  if (_keyPairCache) return _keyPairCache;
-  const wallet = loadWallet();
-  if (!wallet) return null;
-  _keyPairCache = await mnemonicToPrivateKey(wallet.mnemonic);
-  return _keyPairCache;
-}
-async function getWalletBalance(address) {
-  try {
-    const client = await getCachedTonClient();
-    const { Address } = await import("@ton/core");
-    const addressObj = Address.parse(address);
-    const balance = await client.getBalance(addressObj);
-    const balanceFormatted = fromNano(balance);
-    return {
-      balance: balanceFormatted,
-      balanceNano: balance.toString()
-    };
-  } catch (error) {
-    log.error({ err: error }, "Failed to get balance");
-    return null;
+  if (config?.ensureTemplates) {
+    await bootstrapTemplates(workspace, silent);
   }
+  return workspace;
 }
-var TON_PRICE_CACHE_TTL_MS = 3e4;
-var _tonPriceCache = null;
-async function getTonPrice() {
-  if (_tonPriceCache && Date.now() - _tonPriceCache.timestamp < TON_PRICE_CACHE_TTL_MS) {
-    return { ..._tonPriceCache };
-  }
-  try {
-    const response = await tonapiFetch(`/rates?tokens=ton&currencies=usd`);
-    if (response.ok) {
-      const data = await response.json();
-      const price = data?.rates?.TON?.prices?.USD;
-      if (typeof price === "number" && price > 0) {
-        _tonPriceCache = { usd: price, source: "TonAPI", timestamp: Date.now() };
-        return _tonPriceCache;
+async function bootstrapTemplates(workspace, silent = false) {
+  const templates = [
+    { name: "SOUL.md", path: workspace.soulPath },
+    { name: "MEMORY.md", path: workspace.memoryPath },
+    { name: "IDENTITY.md", path: workspace.identityPath },
+    { name: "USER.md", path: workspace.userPath },
+    { name: "SECURITY.md", path: workspace.securityPath },
+    { name: "STRATEGY.md", path: workspace.strategyPath }
+  ];
+  for (const template of templates) {
+    if (!existsSync(template.path)) {
+      const templateSource = join(TEMPLATES_DIR, template.name);
+      if (existsSync(templateSource)) {
+        copyFileSync(templateSource, template.path);
+        if (!silent) log.info(`Created ${template.name}`);
       }
     }
-  } catch {
   }
-  try {
-    const response = await fetchWithTimeout(
-      `${COINGECKO_API_URL}/simple/price?ids=the-open-network&vs_currencies=usd`
-    );
-    if (!response.ok) {
-      throw new Error(`CoinGecko API error: ${response.status}`);
-    }
-    const data = await response.json();
-    const price = data["the-open-network"]?.usd;
-    if (typeof price === "number" && price > 0) {
-      _tonPriceCache = { usd: price, source: "CoinGecko", timestamp: Date.now() };
-      return _tonPriceCache;
-    }
-  } catch (error) {
-    log.error({ err: error }, "Failed to get TON price");
+}
+function isNewWorkspace(workspace) {
+  return !existsSync(workspace.configPath);
+}
+function loadTemplate(name) {
+  const templatePath = join(TEMPLATES_DIR, name);
+  if (!existsSync(templatePath)) {
+    throw new Error(`Template ${name} not found at ${templatePath}`);
   }
-  return null;
+  return readFileSync(templatePath, "utf-8");
 }
 
 // src/config/schema.ts
@@ -351,6 +214,13 @@ var _DevObject = z.object({
   hot_reload: z.boolean().default(false).describe("Enable plugin hot-reload (watches ~/.teleton/plugins/ for changes)")
 });
 var DevConfigSchema = _DevObject.default(_DevObject.parse({}));
+var _ApiObject = z.object({
+  enabled: z.boolean().default(false).describe("Enable HTTPS Management API server"),
+  port: z.number().min(1).max(65535).default(7778).describe("HTTPS server port"),
+  key_hash: z.string().default("").describe("SHA-256 hash of the API key (auto-generated if empty)"),
+  allowed_ips: z.array(z.string()).default([]).describe("IP whitelist (empty = allow all authenticated requests)")
+});
+var ApiConfigSchema = _ApiObject.default(_ApiObject.parse({}));
 var McpServerSchema = z.object({
   command: z.string().optional().describe("Stdio command (e.g. 'npx @modelcontextprotocol/server-filesystem /tmp')"),
   args: z.array(z.string()).optional().describe("Explicit args array (overrides command splitting)"),
@@ -410,6 +280,7 @@ var ConfigSchema = z.object({
   dev: DevConfigSchema,
   tool_rag: ToolRagConfigSchema,
   capabilities: CapabilitiesConfigSchema,
+  api: ApiConfigSchema.optional(),
   ton_proxy: TonProxyConfigSchema,
   mcp: McpConfigSchema,
   plugins: z.record(z.string(), z.unknown()).default({}).describe("Per-plugin config (key = plugin name with underscores)"),
@@ -421,115 +292,10 @@ var ConfigSchema = z.object({
   tavily_api_key: z.string().optional().describe("Tavily API key for web search & extract (free at https://tavily.com)")
 });
 
-// src/workspace/manager.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, copyFileSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
-var log2 = createLogger("Workspace");
-function findPackageRoot() {
-  let dir = dirname2(fileURLToPath(import.meta.url));
-  for (let i = 0; i < 10; i++) {
-    if (existsSync2(join2(dir, "package.json"))) return dir;
-    dir = dirname2(dir);
-  }
-  return process.cwd();
-}
-var TEMPLATES_DIR = join2(findPackageRoot(), "src", "templates");
-async function ensureWorkspace(config) {
-  const silent = config?.silent ?? false;
-  if (!existsSync2(TELETON_ROOT)) {
-    mkdirSync2(TELETON_ROOT, { recursive: true });
-    if (!silent) log2.info(`Created Teleton root at ${TELETON_ROOT}`);
-  }
-  if (!existsSync2(WORKSPACE_ROOT)) {
-    mkdirSync2(WORKSPACE_ROOT, { recursive: true });
-    if (!silent) log2.info(`Created workspace at ${WORKSPACE_ROOT}`);
-  }
-  const directories = [
-    WORKSPACE_PATHS.MEMORY_DIR,
-    WORKSPACE_PATHS.DOWNLOADS_DIR,
-    WORKSPACE_PATHS.UPLOADS_DIR,
-    WORKSPACE_PATHS.TEMP_DIR,
-    WORKSPACE_PATHS.MEMES_DIR
-  ];
-  for (const dir of directories) {
-    if (!existsSync2(dir)) {
-      mkdirSync2(dir, { recursive: true });
-    }
-  }
-  const workspace = {
-    root: TELETON_ROOT,
-    workspace: WORKSPACE_ROOT,
-    // Workspace files
-    soulPath: WORKSPACE_PATHS.SOUL,
-    memoryPath: WORKSPACE_PATHS.MEMORY,
-    identityPath: WORKSPACE_PATHS.IDENTITY,
-    userPath: WORKSPACE_PATHS.USER,
-    strategyPath: WORKSPACE_PATHS.STRATEGY,
-    securityPath: WORKSPACE_PATHS.SECURITY,
-    // Workspace directories
-    memoryDir: WORKSPACE_PATHS.MEMORY_DIR,
-    downloadsDir: WORKSPACE_PATHS.DOWNLOADS_DIR,
-    uploadsDir: WORKSPACE_PATHS.UPLOADS_DIR,
-    tempDir: WORKSPACE_PATHS.TEMP_DIR,
-    memesDir: WORKSPACE_PATHS.MEMES_DIR,
-    // Protected files (outside workspace)
-    sessionPath: join2(TELETON_ROOT, "telegram_session.txt"),
-    configPath: join2(TELETON_ROOT, "config.yaml"),
-    walletPath: join2(TELETON_ROOT, "wallet.json")
-  };
-  if (config?.ensureTemplates) {
-    await bootstrapTemplates(workspace, silent);
-  }
-  return workspace;
-}
-async function bootstrapTemplates(workspace, silent = false) {
-  const templates = [
-    { name: "SOUL.md", path: workspace.soulPath },
-    { name: "MEMORY.md", path: workspace.memoryPath },
-    { name: "IDENTITY.md", path: workspace.identityPath },
-    { name: "USER.md", path: workspace.userPath },
-    { name: "SECURITY.md", path: workspace.securityPath },
-    { name: "STRATEGY.md", path: workspace.strategyPath }
-  ];
-  for (const template of templates) {
-    if (!existsSync2(template.path)) {
-      const templateSource = join2(TEMPLATES_DIR, template.name);
-      if (existsSync2(templateSource)) {
-        copyFileSync(templateSource, template.path);
-        if (!silent) log2.info(`Created ${template.name}`);
-      }
-    }
-  }
-}
-function isNewWorkspace(workspace) {
-  return !existsSync2(workspace.configPath);
-}
-function loadTemplate(name) {
-  const templatePath = join2(TEMPLATES_DIR, name);
-  if (!existsSync2(templatePath)) {
-    throw new Error(`Template ${name} not found at ${templatePath}`);
-  }
-  return readFileSync2(templatePath, "utf-8");
-}
-
 export {
   DealsConfigSchema,
   ConfigSchema,
   ensureWorkspace,
   isNewWorkspace,
-  loadTemplate,
-  setToncenterApiKey,
-  invalidateEndpointCache,
-  generateWallet,
-  saveWallet,
-  loadWallet,
-  walletExists,
-  importWallet,
-  getWalletAddress,
-  getCachedTonClient,
-  invalidateTonClientCache,
-  getKeyPair,
-  getWalletBalance,
-  getTonPrice
+  loadTemplate
 };