teleton 0.8.5 → 0.8.6

package/README.md

@@ -146,6 +146,26 @@ Agent: [Displays uptime, model, tool count, wallet balance]
 
 ---
 
+## User Mode vs Bot Mode
+
+Teleton can run as a **user account** (MTProto) or a **Telegram bot** (Bot API). Set `telegram.mode` in your config:
+
+| | User Mode (default) | Bot Mode |
+|---|---|---|
+| **Auth** | Phone + api_id + api_hash | Bot token from @BotFather |
+| **Protocol** | MTProto (GramJS) | Bot API (Grammy) |
+| **Tools** | 135+ | 67 (11 Telegram + 56 non-Telegram) |
+| **Risk** | Account ban possible | No ban risk |
+| **Dialogs/History** | Full access | Not available |
+| **Media sending** | All types | Photos only (v1) |
+| **Inline keyboards** | Via bot_token | Native |
+| **Stars/Gifts** | Full access | Not available |
+| **Profile editing** | Yes | No |
+| **Scheduled tasks** | Yes | Not available |
+| **Setup** | `telegram.mode: "user"` | `telegram.mode: "bot"` |
+
+---
+
 ## Configuration
 
 The `teleton setup` wizard generates a fully configured `~/.teleton/config.yaml` file. Manual editing is only necessary if you want to adjust settings after the initial setup.
@@ -157,6 +177,10 @@ agent:
   model: "claude-opus-4-6"
   utility_model: "claude-haiku-4-5-20251001"  # for summarization, compaction, vision
   max_agentic_iterations: 5
+  session_reset_policy:
+    daily_reset_enabled: true
+    daily_reset_hour: 4
+    idle_expiry_minutes: 1440  # 24h idle → new session
 
 telegram:
   dm_policy: "admin-only"   # open | allowlist | admin-only | disabled
@@ -171,11 +195,6 @@ telegram:
   bot_token: "123456:ABC-DEF..."
   bot_username: "your_bot"
 
-  session_reset_policy:
-    daily_reset_enabled: true
-    daily_reset_hour: 4
-    idle_expiry_minutes: 1440  # 24h idle → new session
-
 webui:                       # Optional: Web dashboard
   enabled: false             # Enable WebUI server
   port: 7777                 # HTTP server port

package/dist/{bootstrap-SPDT3XBQ.js → bootstrap-PFBH6ALD.js}

@@ -1,20 +1,23 @@
 import {
   AgentLifecycle
-} from "./chunk-NVKBBTI6.js";
+} from "./chunk-K3QSIIMZ.js";
 import {
   configExists,
-  ensureWorkspace,
   getDefaultConfigPath
-} from "./chunk-FSL2MOYK.js";
-import "./chunk-L3LPVF4Z.js";
-import "./chunk-6OOHHJ4N.js";
+} from "./chunk-2UUGRY5B.js";
+import "./chunk-3UFPFWYP.js";
+import {
+  ensureWorkspace
+} from "./chunk-CXTZPOTA.js";
+import "./chunk-J4WDJ7XS.js";
+import "./chunk-TFTNZZDH.js";
 import {
   SHUTDOWN_TIMEOUT_MS
 } from "./chunk-R4YSJ4EY.js";
 import "./chunk-L653KKCR.js";
 import {
   createLogger
-} from "./chunk-NQ6FZKCE.js";
+} from "./chunk-V3S3NXBQ.js";
 import "./chunk-3RG5ZIWI.js";
 
 // src/api/bootstrap.ts
@@ -42,7 +45,7 @@ async function startApiOnly(options) {
     marketplace: null,
     userHookEvaluator: null
   };
-  const { ApiServer } = await import("./server-4J56HS62.js");
+  const { ApiServer } = await import("./server-MFRYOGHR.js");
   const apiConfig = {
     enabled: true,
     port: parseInt(options.apiPort || process.env.TELETON_API_PORT || "7778"),

package/dist/bridge-guards-HZTNH7IB.js

@@ -0,0 +1,9 @@
+import {
+  isBotBridge,
+  isUserBridge
+} from "./chunk-UJ54YT2T.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  isBotBridge,
+  isUserBridge
+};

package/dist/{chunk-FSL2MOYK.js → chunk-2UUGRY5B.js}

@@ -1,17 +1,15 @@
 import {
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-L3LPVF4Z.js";
+} from "./chunk-J4WDJ7XS.js";
 import {
   getProviderMetadata
-} from "./chunk-6OOHHJ4N.js";
+} from "./chunk-TFTNZZDH.js";
 import {
-  TELETON_ROOT,
-  WORKSPACE_PATHS,
-  WORKSPACE_ROOT
+  TELETON_ROOT
 } from "./chunk-L653KKCR.js";
 import {
   createLogger
-} from "./chunk-NQ6FZKCE.js";
+} from "./chunk-V3S3NXBQ.js";
 
 // src/config/loader.ts
 import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
@@ -55,12 +53,14 @@ var AgentConfigSchema = z.object({
   temperature: z.number().default(0.7),
   system_prompt: z.string().nullable().default(null),
   max_agentic_iterations: z.number().default(5).describe("Maximum number of agentic loop iterations (tool call \u2192 result \u2192 tool call cycles)"),
+  toolset: z.string().default("full").describe("Active toolset profile: minimal, standard, trading, full"),
   session_reset_policy: SessionResetPolicySchema.default(SessionResetPolicySchema.parse({}))
 });
 var TelegramConfigSchema = z.object({
-  api_id: z.number(),
-  api_hash: z.string(),
-  phone: z.string(),
+  mode: z.enum(["user", "bot"]).default("user"),
+  api_id: z.number().optional(),
+  api_hash: z.string().optional(),
+  phone: z.string().optional(),
   session_name: z.string().default("teleton_session"),
   session_path: z.string().default("~/.teleton"),
   dm_policy: DMPolicy.default("allowlist"),
@@ -79,7 +79,45 @@ var TelegramConfigSchema = z.object({
   owner_id: z.number().optional().describe("Owner's Telegram user ID"),
   debounce_ms: z.number().default(1500).describe("Debounce delay in milliseconds for group messages (0 = disabled)"),
   bot_token: z.string().optional().describe("Telegram Bot token from @BotFather for inline deal buttons"),
-  bot_username: z.string().optional().describe("Bot username without @ (e.g., 'teleton_deals_bot')")
+  bot_username: z.string().optional().describe("Bot username without @ (e.g., 'teleton_deals_bot')"),
+  stream_mode: z.enum(["all", "replace", "off"]).default("replace").describe(
+    "Bot streaming mode: replace=each iteration replaces draft (default), all=concatenate all iterations, off=no streaming"
+  )
+}).superRefine((data, ctx) => {
+  if (data.mode === "user") {
+    if (!data.api_id)
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "api_id is required in user mode",
+        path: ["api_id"]
+      });
+    if (!data.api_hash)
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "api_hash is required in user mode",
+        path: ["api_hash"]
+      });
+    if (!data.phone)
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "phone is required in user mode",
+        path: ["phone"]
+      });
+  }
+  if (data.mode === "bot") {
+    if (!data.bot_token)
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "bot_token is required in bot mode",
+        path: ["bot_token"]
+      });
+    if (!data.owner_id)
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "owner_id is required in bot mode",
+        path: ["owner_id"]
+      });
+  }
 });
 var StorageConfigSchema = z.object({
   sessions_file: z.string().default("~/.teleton/sessions.json"),
@@ -143,7 +181,7 @@ var McpServerSchema = z.object({
   args: z.array(z.string()).optional().describe("Explicit args array (overrides command splitting)"),
   env: z.record(z.string(), z.string()).optional().describe("Environment variables for stdio server"),
   url: z.string().url().optional().describe("SSE/HTTP endpoint URL (alternative to command)"),
-  scope: z.enum(["always", "dm-only", "group-only", "admin-only"]).default("always").describe("Tool scope"),
+  scope: z.enum(["always", "dm-only", "group-only", "admin-only", "open", "allowlist", "disabled"]).default("always").describe("Tool scope"),
   enabled: z.boolean().default(true).describe("Enable/disable this server")
 }).refine((s) => s.command || s.url, {
   message: "Each MCP server needs either 'command' (stdio) or 'url' (SSE/HTTP)"
@@ -154,15 +192,13 @@ var _McpObject = z.object({
 var McpConfigSchema = _McpObject.default(_McpObject.parse({}));
 var _ToolRagObject = z.object({
   enabled: z.boolean().default(true).describe("Enable semantic tool retrieval (Tool RAG)"),
-  top_k: z.number().default(25).describe("Max tools to retrieve per LLM call"),
+  top_k: z.number().default(35).describe("Max tools to retrieve per LLM call"),
   always_include: z.array(z.string()).default([
     "telegram_send_message",
-    "telegram_reply_message",
+    "telegram_quote_reply",
     "telegram_send_photo",
-    "telegram_send_document",
     "journal_*",
-    "workspace_*",
-    "web_*"
+    "workspace_*"
   ]).describe("Tool name patterns always included (prefix glob with *)"),
   skip_unlimited_providers: z.boolean().default(false).describe("Skip Tool RAG for providers with no tool limit (e.g. Anthropic)")
 });
@@ -187,10 +223,8 @@ var _CapabilitiesObject = z.object({
 var CapabilitiesConfigSchema = _CapabilitiesObject.default(_CapabilitiesObject.parse({}));
 var _HeartbeatObject = z.object({
   enabled: z.boolean().default(true).describe("Enable periodic heartbeat timer"),
-  interval_ms: z.number().min(6e4).default(18e5).describe("Heartbeat interval in milliseconds (min 60s, default 30min)"),
-  prompt: z.string().default(
-    "Read HEARTBEAT.md if it exists. Follow it strictly. If nothing needs attention, reply NO_ACTION."
-  ).describe("Prompt sent to agent on each heartbeat tick"),
+  interval_ms: z.number().min(6e4).default(36e5).describe("Heartbeat interval in milliseconds (min 60s, default 60min)"),
+  prompt: z.string().default("Execute your HEARTBEAT.md checklist now. Work through each item using tool calls.").describe("Prompt sent to agent on each heartbeat tick"),
   self_configurable: z.boolean().default(false).describe("Allow agent to modify heartbeat config via config_set")
 });
 var HeartbeatConfigSchema = _HeartbeatObject.default(_HeartbeatObject.parse({}));
@@ -219,8 +253,64 @@ var ConfigSchema = z.object({
   tavily_api_key: z.string().optional().describe("Tavily API key for web search & extract (free at https://tavily.com)")
 });
 
+// src/config/env.ts
+import { z as z2 } from "zod";
+var log = createLogger("Env");
+var optionalString = z2.string().optional();
+var optionalInt = z2.coerce.number().int().optional();
+var optionalPort = z2.coerce.number().int().min(1).max(65535).optional();
+var optionalBoolean = z2.string().optional().transform(
+  (v) => v === "true" || v === "1" || v === "yes" ? true : v === "false" || v === "0" || v === "no" ? false : void 0
+);
+var envSchema = z2.object({
+  // Core
+  TELETON_HOME: optionalString,
+  TELETON_API_KEY: optionalString,
+  TELETON_BASE_URL: optionalString,
+  // Telegram
+  TELETON_TG_API_ID: optionalInt,
+  TELETON_TG_API_HASH: optionalString,
+  TELETON_TG_PHONE: optionalString,
+  // WebUI
+  TELETON_WEBUI_ENABLED: optionalBoolean,
+  TELETON_WEBUI_PORT: optionalPort,
+  TELETON_WEBUI_HOST: optionalString,
+  // Management API
+  TELETON_API_ENABLED: optionalBoolean,
+  TELETON_API_PORT: optionalPort,
+  TELETON_JSON_CREDENTIALS: optionalBoolean,
+  // Logging
+  TELETON_LOG_LEVEL: optionalString,
+  TELETON_LOG: optionalString,
+  TELETON_LOG_PRETTY: optionalString,
+  // External API keys
+  TELETON_TAVILY_API_KEY: optionalString,
+  TELETON_TONAPI_KEY: optionalString,
+  TELETON_TONCENTER_API_KEY: optionalString
+});
+function validateEnv() {
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      const path = issue.path.join(".");
+      if (path === "TELETON_TG_API_ID" && process.env.TELETON_TG_API_ID) {
+        throw new Error(
+          `Invalid TELETON_TG_API_ID environment variable: "${process.env.TELETON_TG_API_ID}" is not a valid integer`
+        );
+      }
+      log.warn({ path, message: issue.message }, "Invalid env var");
+    }
+    const invalidKeys = new Set(result.error.issues.map((i) => String(i.path[0])));
+    const cleaned = { ...process.env };
+    for (const key of invalidKeys) delete cleaned[key];
+    const retry = envSchema.safeParse(cleaned);
+    return retry.success ? retry.data : {};
+  }
+  return result.data;
+}
+
 // src/config/loader.ts
-var log = createLogger("Config");
+var log2 = createLogger("Config");
 var DEFAULT_CONFIG_PATH = join(TELETON_ROOT, "config.yaml");
 function expandPath(path) {
   if (path.startsWith("~")) {
@@ -229,6 +319,7 @@ function expandPath(path) {
   return path;
 }
 function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
+  const env = validateEnv();
   const fullPath = expandPath(configPath);
   if (!existsSync(fullPath)) {
     throw new Error(`Config file not found: ${fullPath}
@@ -247,7 +338,7 @@ Run 'teleton setup' to create one.`);
     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.");
+    log2.warn("config.market is deprecated and ignored. Use market-api plugin instead.");
     delete raw.market;
   }
   const result = ConfigSchema.safeParse(raw);
@@ -263,71 +354,57 @@ Run 'teleton setup' to create one.`);
   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 (env.TELETON_API_KEY) {
+    config.agent.api_key = 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 (env.TELETON_TG_API_ID != null) {
+    config.telegram.api_id = env.TELETON_TG_API_ID;
   }
-  if (process.env.TELETON_TG_API_HASH) {
-    config.telegram.api_hash = process.env.TELETON_TG_API_HASH;
+  if (env.TELETON_TG_API_HASH) {
+    config.telegram.api_hash = env.TELETON_TG_API_HASH;
   }
-  if (process.env.TELETON_TG_PHONE) {
-    config.telegram.phone = process.env.TELETON_TG_PHONE;
+  if (env.TELETON_TG_PHONE) {
+    config.telegram.phone = env.TELETON_TG_PHONE;
   }
-  if (process.env.TELETON_WEBUI_ENABLED) {
-    config.webui.enabled = process.env.TELETON_WEBUI_ENABLED === "true";
+  if (env.TELETON_WEBUI_ENABLED != null) {
+    config.webui.enabled = env.TELETON_WEBUI_ENABLED;
   }
-  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 (env.TELETON_WEBUI_PORT != null && env.TELETON_WEBUI_PORT >= 1024) {
+    config.webui.port = env.TELETON_WEBUI_PORT;
   }
-  if (process.env.TELETON_WEBUI_HOST) {
-    config.webui.host = process.env.TELETON_WEBUI_HOST;
+  if (env.TELETON_WEBUI_HOST) {
+    config.webui.host = env.TELETON_WEBUI_HOST;
     if (!["127.0.0.1", "localhost", "::1"].includes(config.webui.host)) {
-      log.warn(
+      log2.warn(
         { host: config.webui.host },
         "WebUI bound to non-loopback address \u2014 ensure auth_token is set"
       );
     }
   }
-  if (process.env.TELETON_API_ENABLED) {
+  if (env.TELETON_API_ENABLED != null) {
     if (!config.api) config.api = { enabled: false, port: 7778, key_hash: "", allowed_ips: [] };
-    config.api.enabled = process.env.TELETON_API_ENABLED === "true";
+    config.api.enabled = env.TELETON_API_ENABLED;
   }
-  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 (env.TELETON_API_PORT != null && env.TELETON_API_PORT >= 1024) {
+    if (!config.api) config.api = { enabled: false, port: 7778, key_hash: "", allowed_ips: [] };
+    config.api.port = env.TELETON_API_PORT;
   }
-  if (process.env.TELETON_BASE_URL) {
+  if (env.TELETON_BASE_URL) {
     try {
-      new URL(process.env.TELETON_BASE_URL);
-      config.agent.base_url = process.env.TELETON_BASE_URL;
+      new URL(env.TELETON_BASE_URL);
+      config.agent.base_url = env.TELETON_BASE_URL;
     } catch {
-      throw new Error(
-        `Invalid TELETON_BASE_URL: "${process.env.TELETON_BASE_URL}" is not a valid URL`
-      );
+      throw new Error(`Invalid TELETON_BASE_URL: "${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 (env.TELETON_TAVILY_API_KEY) {
+    config.tavily_api_key = env.TELETON_TAVILY_API_KEY;
   }
-  if (process.env.TELETON_TONAPI_KEY) {
-    config.tonapi_key = process.env.TELETON_TONAPI_KEY;
+  if (env.TELETON_TONAPI_KEY) {
+    config.tonapi_key = env.TELETON_TONAPI_KEY;
   }
-  if (process.env.TELETON_TONCENTER_API_KEY) {
-    config.toncenter_api_key = process.env.TELETON_TONCENTER_API_KEY;
+  if (env.TELETON_TONCENTER_API_KEY) {
+    config.toncenter_api_key = env.TELETON_TONCENTER_API_KEY;
   }
   return config;
 }
@@ -338,107 +415,11 @@ function getDefaultConfigPath() {
   return DEFAULT_CONFIG_PATH;
 }
 
-// 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 },
-    { name: "HEARTBEAT.md", path: WORKSPACE_PATHS.HEARTBEAT }
-  ];
-  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,
   expandPath,
   loadConfig,
   configExists,
-  getDefaultConfigPath,
-  ensureWorkspace,
-  isNewWorkspace,
-  loadTemplate
+  getDefaultConfigPath
 };