release: 1.0.0 beta 22

Implemented full tgapi method coverage from Telegram docs, aligned numeric ID/file_size types, and fixed method signatures/JSON tags.; Standardized GoDoc across exported APIs with Telegram links and refreshed README sections for MsgContext plus API/Uploader usage.

README.md

@@ -124,15 +124,30 @@ func myHandler(ctx *laniakea.MsgContext, db *MyDB) {
 
 Provides access to the incoming message and useful reply methods:
 
-- `Answer(text string)`: Sends a plain text message, automatically escaping MarkdownV2.
+- `Answer(text string) *AnswerMessage`: Sends a message with parse_mode none.
-- `AnswerMarkdown(text string)`: Sends a message formatted with MarkdownV2 (you handle escaping).
+- `AnswerMarkdown(text string) *AnswerMessage`: Sends a message formatted with MarkdownV2 (you handle escaping).
-- `AnswerText(text string)`: Sends a message with no parse_mode.
+- `Keyboard(text string, keyboard *InlineKeyboard) *AnswerMessage`: Sends a message with parse_mode none and inline keyboard.
-- `SendChatAction(action string)`: Sends a "typing", "uploading photo", etc., action.
+- `KeyboardMarkdown(text string, keyboard *InlineKeyboard) *AnswerMessage`: Sends a message formatted with MarkdownV2 (you handle escaping) and inline keyboard.
-- Fields: `Text`, `Args`, `From`, `Chat`, `Msg`, etc.
+- `AnswerPhoto(photoId, text string) *AnswerMessage`: Sends a message with photo with parse_mode none.
+- `AnswerPhotoMarkdown(photoId, text string) *AnswerMessage`: Sends a photo with MarkdownV2 caption (you handle escaping).
+- `EditCallback(text string)`: Edits message with parse_mode none after clicking inline button.
+- `EditCallbackMarkdown(text string)`: Edits a message formatted with MarkdownV2 (you handle escaping) after clicking inline button.
+- `SendAction(action tgapi.ChatActionType)`: Sends a “typing”, “uploading photo”, etc., action.
+- Fields: `Text`, `Args`, `From`, `FromID`, `Msg`, `InlineMsgId`, `CallbackQueryId`, etc.
+- And more methods and fields!
+
+### tgapi: API and Uploader
+
+`tgapi` provides two clients:
+
+- `API` for JSON requests (e.g., `SendMessage`, `EditMessageText`, methods using file_id/URL).
+- `Uploader` for multipart uploads (e.g., `SendPhoto`, `SendDocument`, `SendVideo` with binary files).
+
+This split keeps method intent explicit: JSON-only calls go through `API`, file uploads go through `Uploader`.
 
 ### Database Context
 
-The `T` in `NewBot[T]` is a powerful feature. You can pass any type (like a database connection pool) and it will be available in every command and middleware handler.
+The `T` in `NewBot[T]` is a powerful feature. You can pass any type (like a database connection pool), and it will be available in every command and middleware handler.
 
 ```go
 type MyDB struct { /* ... */ }
@@ -185,16 +200,15 @@ func adminOnlyMiddleware(ctx *laniakea.MsgContext, db *MyDB) bool {
 
 ### Important Notes
 - Middleware can modify the MsgContext (e.g., add custom fields) before the command runs.
-- If you need to run code after a command, you can call it from within the command itself or use a defer statement inside the middleware that wraps the next call (more advanced).
 
 ## ⚙️ Advanced Configuration
-- **Inline Keyboards**: Build keyboards using laniakea.NewKeyboard() and AddRow().
+- **Inline Keyboards**: Build keyboards using `laniakea.NewInlineKeyboardJson`, `laniakea.NewInlineKeyboardBase64`, or `laniakea.NewInlineKeyboard`.
 - **Rate Limiting**: Pass a configured utils.RateLimiter via BotOpts to handle Telegram's rate limits gracefully.
 - **Custom HTTP Client**: Provide your own http.Client in BotOpts for fine-tuned control.
 
 ## 📝 License
 
-This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the GNU General Public License v3.0 — see the [LICENSE](LICENSE) file for details.
 
 ## 📚 Learn More
 [GoDoc](https://pkg.go.dev/git.nix13.pw/scuroneko/laniakea)

README_RU.md

@@ -124,11 +124,17 @@ func myHandler(ctx *laniakea.MsgContext, db *MyDB) {
 ### Контекст сообщения (MsgContext)
 Предоставляет доступ к входящему сообщению и полезные методы для ответа:
 
-- `Answer(text string)`: Отправляет обычный текст, автоматически экранируя MarkdownV2.
+- `Answer(text string)`: Отправляет сообщение с parse_mode none.
 - `AnswerMarkdown(text string)`: Отправляет сообщение, отформатированное MarkdownV2 (экранирование на вашей стороне).
-- `AnswerText(text string)`: Отправляет сообщение без parse_mode.
+- `Keyboard(text string, keyboard *InlineKeyboard) *AnswerMessage`: Отправляет сообщение с parse_mode none и Inline клавиатурой.
+- `KeyboardMarkdown(text string, keyboard *InlineKeyboard) *AnswerMessage`: Отправляет сообщение, отформатированное MarkdownV2 (экранирование на вашей стороне), и Inline клавиатурой.
+- `AnswerPhoto(photoId, text string) *AnswerMessage`: Отправляет фотографию с подписью и parse_mode none.
+- `AnswerPhotoMarkdown(photoId, text string) *AnswerMessage`: Отправляет фотографию с подписью, отформатированной MarkdownV2 (экранирование на вашей стороне).
+- `EditCallback(text string)`: Редактирует сообщение, форматируя его в MarkdownV2 (экранирование на вашей стороне), после нажатия Inline кнопки.
+- `EditCallbackMarkdown(text string)`: Редактирует сообщение с parse_mode none после нажатия Inline кнопки.
 - `SendChatAction(action string)`: Отправляет действие "печатает", "загружает фото" и т.д.
 - Поля: `Text`, `Args`, `From`, `Chat`, `Msg` и другие.
+- И много других методов и полей!
 
 ### Контекст базы данных (Database Context)
 Параметр типа `T` в `NewBot[T]` — мощная функция. Вы можете передать любой тип (например, пул соединений с БД), и он будет доступен в каждом обработчике команды и中间件.
@@ -184,10 +190,9 @@ func adminOnlyMiddleware(ctx *laniakea.MsgContext, db *MyDB) bool {
 
 ### Важные замечания
 - Middleware может изменять MsgContext (например, добавлять пользовательские поля) перед запуском команды.
-- Если нужно выполнить код после команды, это можно сделать внутри самой команды или использовать отложенный вызов (defer) в middleware, который оборачивает следующий вызов (более продвинутый подход).
 
 ## ⚙️ Расширенная настройка
-**Инлайн-клавиатуры**: Создавайте клавиатуры с помощью laniakea.NewKeyboard() и AddRow().
+**Инлайн-клавиатуры**: Создавайте клавиатуры с помощью laniakea.NewKeyboard().
 **Ограничение запросов**: Передайте настроенный utils.RateLimiter через BotOpts для корректной обработки лимитов Telegram.
 **Пользовательский HTTP-клиент**: Предоставьте свой http.Client в BotOpts для точного контроля.
 

bot.go

@@ -1,41 +1,9 @@
-// Package laniakea provides a modular, extensible framework for building scalable
-// Telegram bots with support for plugins, middleware, localization, draft messages,
-// rate limiting, structured logging, and dependency injection.
-//
-// The framework is designed around a fluent API for configuration and separation of concerns:
-//
-//   - Plugins: Handle specific commands or events (e.g., /start, /help)
-//   - Middleware: Intercept and modify updates before plugins run (auth, logging, validation)
-//   - Runners: Background goroutines for cleanup, cron jobs, or monitoring
-//   - DraftProvider: Safely build and resume multi-step messages
-//   - L10n: Multi-language support via key-based translation
-//   - RateLimiter: Enforces Telegram API limits to avoid bans
-//   - Structured Logging: JSON stdout + optional file output with request-level tracing
-//   - Dependency Injection: Inject custom database contexts (e.g., *gorm.DB, *sql.DB)
-//
-// Example usage:
-//
-//	bot := laniakea.NewBot[mydb.DBContext](laniakea.LoadOptsFromEnv()).
-//		DatabaseContext(&myDB).
-//		AddUpdateType(tgapi.UpdateTypeMessage).
-//		AddPrefixes("/", "!").
-//		AddPlugins(&startPlugin, &helpPlugin).
-//		AddMiddleware(&authMiddleware, &logMiddleware).
-//		AddRunner(&cleanupRunner).
-//		AddL10n(l10n.New())
-//
-//	go bot.Run()
-//
-// All methods are thread-safe except direct field access. Use provided accessors
-// (e.g., GetDBContext, SetUpdateOffset) for safe concurrent access.
 package laniakea
 
 import (
 	"context"
 	"fmt"
-	"os"
 	"sort"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -47,113 +15,6 @@ import (
 	"github.com/alitto/pond/v2"
 )
 
-// BotOpts holds configuration options for initializing a Bot.
-//
-// Values are loaded from environment variables via LoadOptsFromEnv().
-// Use NewOpts() to create a zero-value struct and set fields manually.
-type BotOpts struct {
-	// Token is the Telegram bot token (required).
-	Token string
-
-	// UpdateTypes is a semicolon-separated list of update types to listen for.
-	// Example: "message;edited_message;callback_query"
-	// Defaults to empty (Telegram will return all types).
-	UpdateTypes []string
-
-	// Debug enables debug-level logging.
-	Debug bool
-
-	// ErrorTemplate is the format string used to wrap error messages sent to users.
-	// Use "%s" to insert the actual error. Example: "❌ Error: %s"
-	ErrorTemplate string
-
-	// Prefixes is a list of command prefixes (e.g., ["/", "!"]).
-	// Defaults to ["/"] if not set via environment.
-	Prefixes []string
-
-	// LoggerBasePath is the directory where log files are written.
-	// Defaults to "./".
-	LoggerBasePath string
-
-	// UseRequestLogger enables detailed logging of all Telegram API requests.
-	UseRequestLogger bool
-
-	// WriteToFile enables writing logs to files (main.log and requests.log).
-	WriteToFile bool
-
-	// UseTestServer uses Telegram's test server (https://api.test.telegram.org).
-	UseTestServer bool
-
-	// APIUrl overrides the default Telegram API endpoint (useful for proxies or self-hosted).
-	APIUrl string
-
-	// RateLimit is the maximum number of API requests per second.
-	// Telegram allows up to 30 req/s for most bots. Defaults to 30.
-	RateLimit int
-
-	// DropRLOverflow drops incoming updates when rate limit is exceeded instead of queuing.
-	// Use this to prioritize responsiveness over reliability.
-	DropRLOverflow bool
-}
-
-// NewOpts returns a new BotOpts with zero values.
-func NewOpts() *BotOpts { return new(BotOpts) }
-
-// LoadOptsFromEnv loads BotOpts from environment variables.
-//
-// Environment variables:
-//   - TG_TOKEN: Bot token (required)
-//   - UPDATE_TYPES: semicolon-separated update types (e.g., "message;callback_query")
-//   - DEBUG: "true" to enable debug logging
-//   - ERROR_TEMPLATE: format string for error messages (e.g., "❌ %s")
-//   - PREFIXES: semicolon-separated prefixes (e.g., "/;!bot")
-//   - LOGGER_BASE_PATH: directory for log files (default: "./")
-//   - USE_REQ_LOG: "true" to enable request logging
-//   - WRITE_TO_FILE: "true" to write logs to files
-//   - USE_TEST_SERVER: "true" to use Telegram test server
-//   - API_URL: custom API endpoint
-//   - RATE_LIMIT: max requests per second (default: 30)
-//   - DROP_RL_OVERFLOW: "true" to drop updates on rate limit overflow
-//
-// Returns a populated BotOpts. If TG_TOKEN is missing, behavior is undefined.
-func LoadOptsFromEnv() *BotOpts {
-	rateLimit := 30
-	if rl := os.Getenv("RATE_LIMIT"); rl != "" {
-		if n, err := strconv.Atoi(rl); err == nil {
-			rateLimit = n
-		}
-	}
-
-	return &BotOpts{
-		Token:       os.Getenv("TG_TOKEN"),
-		UpdateTypes: strings.Split(os.Getenv("UPDATE_TYPES"), ";"),
-
-		Debug:         os.Getenv("DEBUG") == "true",
-		ErrorTemplate: os.Getenv("ERROR_TEMPLATE"),
-		Prefixes:      LoadPrefixesFromEnv(),
-
-		LoggerBasePath:   os.Getenv("LOGGER_BASE_PATH"),
-		UseRequestLogger: os.Getenv("USE_REQ_LOG") == "true",
-		WriteToFile:      os.Getenv("WRITE_TO_FILE") == "true",
-
-		UseTestServer: os.Getenv("USE_TEST_SERVER") == "true",
-		APIUrl:        os.Getenv("API_URL"),
-
-		RateLimit:      rateLimit,
-		DropRLOverflow: os.Getenv("DROP_RL_OVERFLOW") == "true",
-	}
-}
-
-// LoadPrefixesFromEnv returns the PREFIXES environment variable split by semicolon.
-// Defaults to ["/"] if not set.
-func LoadPrefixesFromEnv() []string {
-	prefixesS, exists := os.LookupEnv("PREFIXES")
-	if !exists {
-		return []string{"/"}
-	}
-	return strings.Split(prefixesS, ";")
-}
-
 // DbContext is an interface representing the application's database context.
 // It is injected into plugins and middleware via Bot.DatabaseContext().
 //
@@ -163,12 +24,16 @@ func LoadPrefixesFromEnv() []string {
 //	bot := NewBot[MyDB](opts).DatabaseContext(&myDB)
 //
 // Use NoDB if no database is needed.
-type DbContext interface{}
+type DbContext any
 
 // NoDB is a placeholder type for bots that do not use a database.
 // Use Bot[NoDB] to indicate no dependency injection is required.
 type NoDB struct{ DbContext }
 
+// DbLogger is a function type that returns a slog.LoggerWriter for database logging.
+// Used to inject database-specific log output (e.g., SQL queries, ORM events).
+type DbLogger[T DbContext] func(db *T) slog.LoggerWriter
+
 // BotPayloadType defines the serialization format for callback data payloads.
 type BotPayloadType string
 
@@ -195,6 +60,7 @@ type Bot[T DbContext] struct {
 	errorTemplate string
 	username      string
 	payloadType   BotPayloadType
+	maxWorkers    int
 
 	logger        *slog.Logger                // Main bot logger (JSON stdout + optional file)
 	RequestLogger *slog.Logger                // Optional request-level API logging
@@ -215,6 +81,8 @@ type Bot[T DbContext] struct {
 	updateOffset   int                // Last processed update ID
 	updateTypes    []tgapi.UpdateType // Types of updates to fetch
 	updateQueue    chan *tgapi.Update // Internal queue for processing updates
+	runnerOnceWG   sync.WaitGroup     // Tracks one-time async runners
+	runnerBgWG     sync.WaitGroup     // Tracks background async runners
 }
 
 // NewBot creates and initializes a new Bot instance using the provided BotOpts.
@@ -241,11 +109,13 @@ func NewBot[T any](opts *BotOpts) *Bot[T] {
 	//	limiter = utils.NewRateLimiter()
 	//}
 	limiter := utils.NewRateLimiter()
+	limiter.SetGlobalRate(opts.RateLimit)
 
 	apiOpts := tgapi.NewAPIOpts(opts.Token).
 		SetAPIUrl(opts.APIUrl).
 		UseTestServer(opts.UseTestServer).
-		SetLimiter(limiter)
+		SetLimiter(limiter).
+		SetLimiterDrop(opts.DropRLOverflow)
 	api := tgapi.NewAPI(apiOpts)
 	uploader := tgapi.NewUploader(api)
 
@@ -254,10 +124,16 @@ func NewBot[T any](opts *BotOpts) *Bot[T] {
 		prefixes = []string{"/"}
 	}
 
+	workers := 32
+	if opts.MaxWorkers > 0 {
+		workers = opts.MaxWorkers
+	}
+
 	bot := &Bot[T]{
 		updateOffset:  0,
 		errorTemplate: "%s",
 		payloadType:   BotPayloadBase64,
+		maxWorkers:    workers,
 		updateQueue:   updateQueue,
 		api:           api,
 		uploader:      uploader,
@@ -265,7 +141,7 @@ func NewBot[T any](opts *BotOpts) *Bot[T] {
 		prefixes:      prefixes,
 		token:         opts.Token,
 		plugins:       make([]Plugin[T], 0),
-		updateTypes:   make([]tgapi.UpdateType, 0),
+		updateTypes:   append([]tgapi.UpdateType{}, opts.UpdateTypes...),
 		runners:       make([]Runner[T], 0),
 		extraLoggers:  make([]*slog.Logger, 0),
 		l10n:          &L10n{},
@@ -398,34 +274,6 @@ func (bot *Bot[T]) SetDraftProvider(p *DraftProvider) *Bot[T] {
 	return bot
 }
 
-// DbLogger is a function type that returns a slog.LoggerWriter for database logging.
-// Used to inject database-specific log output (e.g., SQL queries, ORM events).
-type DbLogger[T DbContext] func(db *T) slog.LoggerWriter
-
-// AddDatabaseLoggerWriter adds a database logger writer to all loggers.
-//
-// The writer will receive logs from:
-//   - Main bot logger
-//   - Request logger (if enabled)
-//   - API and Uploader loggers
-//
-// Example:
-//
-//	bot.AddDatabaseLoggerWriter(func(db *MyDB) slog.LoggerWriter {
-//	    return db.QueryLogger()
-//	})
-func (bot *Bot[T]) AddDatabaseLoggerWriter(writer DbLogger[T]) *Bot[T] {
-	w := writer(bot.dbContext)
-	bot.logger.AddWriter(w)
-	if bot.RequestLogger != nil {
-		bot.RequestLogger.AddWriter(w)
-	}
-	for _, l := range bot.extraLoggers {
-		l.AddWriter(w)
-	}
-	return bot
-}
-
 // DatabaseContext injects a database context into the bot.
 // This context is accessible to plugins and middleware via GetDBContext().
 func (bot *Bot[T]) DatabaseContext(ctx *T) *Bot[T] {
@@ -441,9 +289,9 @@ func (bot *Bot[T]) UpdateTypes(t ...tgapi.UpdateType) *Bot[T] {
 	return bot
 }
 
-// SetPayloadType sets the type, that bot will use for payload
+// SetPayloadType sets the payload encoding type used for callback data.
-// json - string `{"cmd": "command", "args": [...]}
+// JSON stores payload as a string: `{"cmd":"command","args":[...]}`.
-// base64 - same json, but encoded in base64 string
+// Base64 stores the same JSON encoded as a Base64URL string.
 func (bot *Bot[T]) SetPayloadType(t BotPayloadType) *Bot[T] {
 	bot.payloadType = t
 	return bot
@@ -465,7 +313,7 @@ func (bot *Bot[T]) AddPrefixes(prefixes ...string) *Bot[T] {
 
 // ErrorTemplate sets the format string for error messages sent to users.
 // Use "%s" to insert the error message.
-// Example: "❌ Error: %s" → "❌ Error: Command not found"
+// Example: "❌ Error: %s" → "❌ Error: Command not found".
 func (bot *Bot[T]) ErrorTemplate(s string) *Bot[T] {
 	bot.errorTemplate = s
 	return bot
@@ -564,18 +412,43 @@ func (bot *Bot[T]) AddRunner(runner Runner[T]) *Bot[T] {
 func (bot *Bot[T]) AddL10n(l *L10n) *Bot[T] {
 	if l == nil {
 		bot.logger.Warn("AddL10n called with nil L10n; localization will be disabled")
+		return bot
 	}
 	bot.l10n = l
 	return bot
 }
 
+// AddDatabaseLoggerWriter adds a database logger writer to all loggers.
+//
+// The writer will receive logs from:
+//   - Main bot logger
+//   - Request logger (if enabled)
+//   - API and Uploader loggers
+//
+// Example:
+//
+//	bot.AddDatabaseLoggerWriter(func(db *MyDB) slog.LoggerWriter {
+//	    return db.QueryLogger()
+//	})
+func (bot *Bot[T]) AddDatabaseLoggerWriter(writer DbLogger[T]) *Bot[T] {
+	w := writer(bot.dbContext)
+	bot.logger.AddWriter(w)
+	if bot.RequestLogger != nil {
+		bot.RequestLogger.AddWriter(w)
+	}
+	for _, l := range bot.extraLoggers {
+		l.AddWriter(w)
+	}
+	return bot
+}
+
 // RunWithContext starts the bot with a given context for graceful shutdown.
 //
 // This is the main entry point for bot execution. It:
 //   - Validates required configuration (prefixes, plugins)
 //   - Starts all registered runners as background goroutines
 //   - Begins polling for updates via Telegram's GetUpdates API
-//   - Processes updates concurrently using a worker pool (16 goroutines)
+//   - Processes updates concurrently using a worker pool with size configurable via BotOpts.MaxWorkers
 //
 // The context controls graceful shutdown. When canceled, the bot:
 //   - Stops polling for new updates
@@ -589,6 +462,12 @@ func (bot *Bot[T]) AddL10n(l *L10n) *Bot[T] {
 //	// ... later ...
 //	cancel() // triggers graceful shutdown
 func (bot *Bot[T]) RunWithContext(ctx context.Context) {
+	defer func() {
+		if err := bot.Close(); err != nil {
+			bot.logger.Errorln(err)
+		}
+	}()
+
 	if len(bot.prefixes) == 0 {
 		bot.logger.Fatalln("no prefixes defined")
 		return
@@ -599,12 +478,18 @@ func (bot *Bot[T]) RunWithContext(ctx context.Context) {
 		return
 	}
 
-	bot.ExecRunners()
+	bot.ExecRunners(ctx)
 
 	bot.logger.Infoln("Bot running. Press CTRL+C to exit.")
 
 	// Start update polling in a goroutine
 	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				bot.logger.Errorln(fmt.Sprintf("panic in update polling: %v", r))
+			}
+			close(bot.updateQueue)
+		}()
 		for {
 			select {
 			case <-ctx.Done():
@@ -618,6 +503,7 @@ func (bot *Bot[T]) RunWithContext(ctx context.Context) {
 				}
 
 				for _, u := range updates {
+					u := u // copy loop variable to avoid race condition
 					select {
 					case bot.updateQueue <- &u:
 					case <-ctx.Done():
@@ -629,13 +515,16 @@ func (bot *Bot[T]) RunWithContext(ctx context.Context) {
 	}()
 
 	// Start worker pool for concurrent update handling
-	pool := pond.NewPool(16)
+	pool := pond.NewPool(bot.maxWorkers)
 	for update := range bot.updateQueue {
-		update := update // capture loop variable
+		u := update // capture loop variable
 		pool.Submit(func() {
-			bot.handle(update)
+			bot.handle(u)
 		})
 	}
+	pool.Stop() // Wait for all tasks to complete and stop the pool
+	bot.runnerOnceWG.Wait()
+	bot.runnerBgWG.Wait()
 }
 
 // Run starts the bot using a background context.

bot_opts.go

@@ -0,0 +1,226 @@
+package laniakea
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+)
+
+// BotOpts holds configuration options for initializing a Bot.
+//
+// Values are loaded from environment variables via LoadOptsFromEnv().
+// Use NewOpts() to create a zero-value struct and set fields manually.
+type BotOpts struct {
+	// Token is the Telegram bot token (required).
+	Token string
+
+	// UpdateTypes is a list of update types to listen for.
+	// Example: "["message", "edited_message", "callback_query"]"
+	// Defaults to empty (Telegram will return all types).
+	UpdateTypes []tgapi.UpdateType
+
+	// Debug enables debug-level logging.
+	Debug bool
+
+	// ErrorTemplate is the format string used to wrap error messages sent to users.
+	// Use "%s" to insert the actual error. Example: "❌ Error: %s"
+	ErrorTemplate string
+
+	// Prefixes is a list of command prefixes (e.g., ["/", "!"]).
+	// Defaults to ["/"] if not set via environment.
+	Prefixes []string
+
+	// LoggerBasePath is the directory where log files are written.
+	// Defaults to "./".
+	LoggerBasePath string
+
+	// UseRequestLogger enables detailed logging of all Telegram API requests.
+	UseRequestLogger bool
+
+	// WriteToFile enables writing logs to files (main.log and requests.log).
+	WriteToFile bool
+
+	// UseTestServer uses Telegram's test server (https://api.test.telegram.org).
+	UseTestServer bool
+
+	// APIUrl overrides the default Telegram API endpoint (useful for proxies or self-hosted).
+	APIUrl string
+
+	// RateLimit is the maximum number of API requests per second.
+	// Telegram allows up to 30 req/s for most bots. Defaults to 30.
+	RateLimit int
+
+	// DropRLOverflow drops incoming updates when rate limit is exceeded instead of queuing.
+	// Use this to prioritize responsiveness over reliability.
+	DropRLOverflow bool
+
+	// MaxWorkers is the maximum number of concurrency running update handlers.
+	MaxWorkers int
+}
+
+// LoadOptsFromEnv loads BotOpts from environment variables.
+//
+// Environment variables:
+//   - TG_TOKEN: Bot token (required)
+//   - UPDATE_TYPES: semicolon-separated update types (e.g., "message;callback_query")
+//   - DEBUG: "true" to enable debug logging
+//   - ERROR_TEMPLATE: format string for error messages (e.g., "❌ %s")
+//   - PREFIXES: semicolon-separated prefixes (e.g., "/;!bot")
+//   - LOGGER_BASE_PATH: directory for log files (default: "./")
+//   - USE_REQ_LOG: "true" to enable request logging
+//   - WRITE_TO_FILE: "true" to write logs to files
+//   - USE_TEST_SERVER: "true" to use Telegram test server
+//   - API_URL: custom API endpoint
+//   - RATE_LIMIT: max requests per second (default: 30)
+//   - DROP_RL_OVERFLOW: "true" to drop updates on rate limit overflow
+//
+// Returns a populated BotOpts. If TG_TOKEN is missing, behavior is undefined.
+func LoadOptsFromEnv() *BotOpts {
+	rateLimit := 30
+	if rl := os.Getenv("RATE_LIMIT"); rl != "" {
+		if n, err := strconv.Atoi(rl); err == nil {
+			rateLimit = n
+		}
+	}
+
+	stringUpdateTypes := strings.Split(os.Getenv("UPDATE_TYPES"), ";")
+	updateTypes := make([]tgapi.UpdateType, len(stringUpdateTypes))
+	for i, updateType := range stringUpdateTypes {
+		updateTypes[i] = tgapi.UpdateType(updateType)
+	}
+
+	return &BotOpts{
+		Token:       os.Getenv("TG_TOKEN"),
+		UpdateTypes: updateTypes,
+
+		Debug:         os.Getenv("DEBUG") == "true",
+		ErrorTemplate: os.Getenv("ERROR_TEMPLATE"),
+		Prefixes:      LoadPrefixesFromEnv(),
+
+		LoggerBasePath:   os.Getenv("LOGGER_BASE_PATH"),
+		UseRequestLogger: os.Getenv("USE_REQ_LOG") == "true",
+		WriteToFile:      os.Getenv("WRITE_TO_FILE") == "true",
+
+		UseTestServer: os.Getenv("USE_TEST_SERVER") == "true",
+		APIUrl:        os.Getenv("API_URL"),
+
+		RateLimit:      rateLimit,
+		DropRLOverflow: os.Getenv("DROP_RL_OVERFLOW") == "true",
+	}
+}
+
+// SetToken sets the Telegram bot token (required).
+func (opts *BotOpts) SetToken(token string) *BotOpts {
+	opts.Token = token
+	return opts
+}
+
+// SetUpdateTypes sets the list of update types to listen for.
+// If empty (default), Telegram will return all update types.
+// Example: opts.SetUpdateTypes("message", "callback_query").
+func (opts *BotOpts) SetUpdateTypes(types ...tgapi.UpdateType) *BotOpts {
+	opts.UpdateTypes = types
+	return opts
+}
+
+// SetDebug enables or disables debug-level logging.
+// Default is false.
+func (opts *BotOpts) SetDebug(debug bool) *BotOpts {
+	opts.Debug = debug
+	return opts
+}
+
+// SetErrorTemplate sets the format string for error messages sent to users.
+// Use "%s" to insert the actual error. Example: "❌ Error: %s"
+// If not set, defaults to "%s".
+func (opts *BotOpts) SetErrorTemplate(tpl string) *BotOpts {
+	opts.ErrorTemplate = tpl
+	return opts
+}
+
+// SetPrefixes sets the command prefixes (e.g., "/", "!").
+// If not set via environment, defaults to ["/"].
+func (opts *BotOpts) SetPrefixes(prefixes ...string) *BotOpts {
+	opts.Prefixes = prefixes
+	return opts
+}
+
+// SetLoggerBasePath sets the directory where log files are written.
+// Defaults to "./".
+func (opts *BotOpts) SetLoggerBasePath(path string) *BotOpts {
+	opts.LoggerBasePath = path
+	return opts
+}
+
+// SetUseRequestLogger enables detailed logging of all Telegram API requests.
+// Default is false.
+func (opts *BotOpts) SetUseRequestLogger(use bool) *BotOpts {
+	opts.UseRequestLogger = use
+	return opts
+}
+
+// SetWriteToFile enables writing logs to files (main.log and requests.log).
+// Default is false.
+func (opts *BotOpts) SetWriteToFile(write bool) *BotOpts {
+	opts.WriteToFile = write
+	return opts
+}
+
+// SetUseTestServer enables using Telegram's test server (https://api.telegram.org/bot<token>/test).
+// Default is false.
+func (opts *BotOpts) SetUseTestServer(use bool) *BotOpts {
+	opts.UseTestServer = use
+	return opts
+}
+
+// SetAPIUrl overrides the default Telegram API endpoint (useful for proxies or self-hosted).
+// If not set, defaults to "https://api.telegram.org".
+func (opts *BotOpts) SetAPIUrl(url string) *BotOpts {
+	opts.APIUrl = url
+	return opts
+}
+
+// SetRateLimit sets the maximum number of API requests per second.
+// Telegram allows up to 30 req/s for most bots. Defaults to 30.
+func (opts *BotOpts) SetRateLimit(limit int) *BotOpts {
+	opts.RateLimit = limit
+	return opts
+}
+
+// SetDropRLOverflow drops incoming updates when rate limit is exceeded instead of queuing.
+// Use this to prioritize responsiveness over reliability. Default is false.
+func (opts *BotOpts) SetDropRLOverflow(drop bool) *BotOpts {
+	opts.DropRLOverflow = drop
+	return opts
+}
+
+// SetMaxWorkers sets the maximum number of concurrent update handlers.
+// Must be called before NewBot, as the value is captured during bot creation.
+//
+// The optimal value depends on your bot's workload:
+//   - For I/O-bound handlers (e.g., database queries, external API calls), you may
+//     need more workers, but be mindful of downstream service limits.
+//   - For CPU-bound handlers, keep workers close to the number of CPU cores.
+//
+// Recommended starting points (adjust based on profiling and monitoring):
+//   - Small to medium bots with fast handlers: 16–32
+//   - Medium to large bots with fast handlers: 32–64
+//   - Large bots with heavy I/O: 64–128 (ensure your infrastructure can handle it)
+//
+// The default is 32. Monitor queue length and processing latency to fine-tune.
+func (opts *BotOpts) SetMaxWorkers(workers int) *BotOpts {
+	opts.MaxWorkers = workers
+	return opts
+}
+
+// LoadPrefixesFromEnv returns the PREFIXES environment variable split by semicolon.
+// Defaults to ["/"] if not set.
+func LoadPrefixesFromEnv() []string {
+	prefixesS, exists := os.LookupEnv("PREFIXES")
+	if !exists {
+		return []string{"/"}
+	}
+	return strings.Split(prefixesS, ";")
+}

cmd_generator.go

@@ -1,12 +1,3 @@
-// Package laniakea provides a framework for building Telegram bots with plugin-based
-// command registration and automatic command scope management.
-//
-// This module automatically generates and registers bot commands across different
-// chat scopes (private, group, admin) based on plugin-defined commands.
-//
-// Commands are derived from Plugin and Command structs, with optional descriptions
-// and argument formatting. Automatic registration avoids manual command setup and
-// ensures consistency across chat types.
 package laniakea
 
 import (
@@ -18,6 +9,7 @@ import (
 	"git.nix13.pw/scuroneko/laniakea/tgapi"
 )
 
+// CmdRegexp matches command names allowed for Telegram command registration.
 var CmdRegexp = regexp.MustCompile("^[a-zA-Z0-9]+$")
 
 // ErrTooManyCommands is returned when the total number of registered commands
@@ -28,19 +20,7 @@ var CmdRegexp = regexp.MustCompile("^[a-zA-Z0-9]+$")
 // bot initialization.
 var ErrTooManyCommands = errors.New("too many commands. max 100")
 
-// generateBotCommand converts a Command[T] into a tgapi.BotCommand with a
+// generateBotCommand builds a BotCommand description with generated usage text.
-// formatted description that includes usage instructions.
-//
-// The description is built as:
-//
-//	"<original_description>. Usage: /<command> <arg1> [<arg2>] ..."
-//
-// Required arguments are shown as-is; optional arguments are wrapped in square brackets.
-//
-// Example:
-//
-//	Command{command: "start", description: "Start the bot", args: []Arg{{text: "name", required: false}}}
-//	→ Description: "Start the bot. Usage: /start [name]"
 func generateBotCommand[T any](cmd *Command[T]) tgapi.BotCommand {
 	desc := ""
 	if len(cmd.description) > 0 {
@@ -50,33 +30,25 @@ func generateBotCommand[T any](cmd *Command[T]) tgapi.BotCommand {
 	var descArgs []string
 	for _, a := range cmd.args {
 		if a.required {
-			descArgs = append(descArgs, a.text)
+			descArgs = append(descArgs, fmt.Sprintf("<%s>", a.text))
 		} else {
 			descArgs = append(descArgs, fmt.Sprintf("[%s]", a.text))
 		}
 	}
 
+	usage := fmt.Sprintf("Usage: /%s %s", cmd.command, strings.Join(descArgs, " "))
 	if desc != "" {
-		desc = fmt.Sprintf("%s. Usage: /%s %s", desc, cmd.command, strings.Join(descArgs, " "))
+		desc = fmt.Sprintf("%s. %s", desc, usage)
-	} else {
+		return tgapi.BotCommand{Command: cmd.command, Description: desc}
-		desc = fmt.Sprintf("Usage: /%s %s", cmd.command, strings.Join(descArgs, " "))
 	}
-	return tgapi.BotCommand{Command: cmd.command, Description: desc}
+	return tgapi.BotCommand{Command: cmd.command, Description: usage}
 }
 
-// checkCmdRegex check if command satisfy regexp [a-zA-Z0-9]+
+// checkCmdRegex reports whether cmd matches CmdRegexp.
-// Return true if satisfy, else false.
+func checkCmdRegex(cmd string) bool { return CmdRegexp.MatchString(cmd) }
-func checkCmdRegex(cmd string) bool {
-	return CmdRegexp.MatchString(cmd)
-}
 
-// generateBotCommandForPlugin collects all non-skipped commands from a Plugin[T]
+// gatherCommandsForPlugin collects non-skipped, valid commands from one plugin.
-// and converts them into tgapi.BotCommand objects.
+func gatherCommandsForPlugin[T any](pl Plugin[T]) []tgapi.BotCommand {
-//
-// Commands marked with skipAutoCmd = true are excluded from auto-registration.
-// This allows plugins to opt out of automatic command generation (e.g., for
-// internal or hidden commands).
-func generateBotCommandForPlugin[T any](pl Plugin[T]) []tgapi.BotCommand {
 	commands := make([]tgapi.BotCommand, 0)
 	for _, cmd := range pl.commands {
 		if cmd.skipAutoCmd {
@@ -90,6 +62,21 @@ func generateBotCommandForPlugin[T any](pl Plugin[T]) []tgapi.BotCommand {
 	return commands
 }
 
+// gatherCommands collects all commands from all plugins
+// and converts them into tgapi.BotCommand objects.
+// See gatherCommandsForPlugin.
+func gatherCommands[T any](bot *Bot[T]) []tgapi.BotCommand {
+	commands := make([]tgapi.BotCommand, 0)
+	for _, pl := range bot.plugins {
+		if pl.skipAutoCmd {
+			continue
+		}
+		commands = append(commands, gatherCommandsForPlugin(pl)...)
+		bot.logger.Debugln(fmt.Sprintf("Registered %d commands from plugin %s", len(pl.commands), pl.name))
+	}
+	return commands
+}
+
 // AutoGenerateCommands registers all plugin-defined commands with Telegram's Bot API
 // across three scopes:
 //   - Private chats (users)
@@ -119,17 +106,7 @@ func (bot *Bot[T]) AutoGenerateCommands() error {
 		return fmt.Errorf("failed to delete existing commands: %w", err)
 	}
 
-	// Collect all non-skipped commands from all plugins
+	commands := gatherCommands(bot)
-	commands := make([]tgapi.BotCommand, 0)
-	for _, pl := range bot.plugins {
-		if pl.skipAutoCmd {
-			continue
-		}
-		commands = append(commands, generateBotCommandForPlugin(pl)...)
-		bot.logger.Debugln(fmt.Sprintf("Registered %d commands from plugin %s", len(pl.commands), pl.name))
-	}
-
-	// Enforce Telegram's 100-command limit
 	if len(commands) > 100 {
 		return ErrTooManyCommands
 	}
@@ -153,3 +130,39 @@ func (bot *Bot[T]) AutoGenerateCommands() error {
 
 	return nil
 }
+
+// AutoGenerateCommandsForScope registers all plugin-defined commands with Telegram's Bot API
+// for the specified command scope. It first deletes any existing commands in that scope
+// to ensure a clean state, then sets the new set of commands.
+//
+// The scope parameter defines where the commands should be available (e.g., private chats,
+// group chats, chat administrators). See tgapi.BotCommandScope and its predefined types.
+//
+// Returns ErrTooManyCommands if the total number of commands exceeds 100.
+// Returns any API error from Telegram (e.g., network issues, invalid scope).
+//
+// Usage:
+//
+//	privateScope := &tgapi.BotCommandScope{Type: tgapi.BotCommandScopePrivateType}
+//	if err := bot.AutoGenerateCommandsForScope(privateScope); err != nil {
+//	    log.Fatal(err)
+//	}
+func (bot *Bot[T]) AutoGenerateCommandsForScope(scope *tgapi.BotCommandScope) error {
+	_, err := bot.api.DeleteMyCommands(tgapi.DeleteMyCommandsP{Scope: scope})
+	if err != nil {
+		return fmt.Errorf("failed to delete existing commands: %w", err)
+	}
+	commands := gatherCommands(bot)
+	if len(commands) > 100 {
+		return ErrTooManyCommands
+	}
+
+	_, err = bot.api.SetMyCommands(tgapi.SetMyCommandsP{
+		Commands: commands,
+		Scope:    scope,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to set commands for scope %q: %w", scope.Type, err)
+	}
+	return nil
+}

doc.go

@@ -0,0 +1,55 @@
+/*
+Package laniakea provides a modular, extensible framework for building scalable Telegram bots.
+
+It offers a fluent API for configuration and separates concerns through several core concepts:
+
+  - Bot: The central instance managing API communication, update processing, logging,
+    rate limiting, and dependency injection. Created via NewBot[T].
+
+  - Plugins: Organize commands and payloads into reusable units.
+    A plugin can have multiple commands and shared middlewares.
+
+  - Commands: Named bot commands with descriptions, argument validation, and
+    execution logic. Automatically registrable across different chat scopes.
+
+  - Middleware: Functions that intercept and modify updates before they reach plugins.
+    Useful for authentication, logging, validation, etc. Return false to stop processing.
+
+  - MsgContext: Provides access to the incoming update and convenient methods for
+    responding, editing, deleting, and translating messages. Includes built-in rate limiting
+    and error handling. ⚠️ MarkdownV2 methods require manual escaping via EscapeMarkdownV2().
+
+  - InlineKeyboard: A fluent builder for constructing inline keyboards with styled buttons,
+    icons, URLs, and structured callback data (JSON or Base64).
+
+  - DraftProvider: Manages ephemeral, multi-step message drafts with automatic ID generation
+    (random or linear). Drafts can be built incrementally and flushed atomically.
+
+  - L10n: Simple key-based localization system with fallback language support.
+
+  - Runners: Background goroutines for periodic tasks or one‑off initialization,
+    with configurable timeouts and async execution.
+
+  - RateLimiting & Logging: Built‑in rate limiter (respects Telegram's retry_after)
+    and structured logging (JSON stdout + optional file output) with request‑level tracing.
+
+  - Dependency Injection: Pass any custom database context (e.g., *sql.DB) to all handlers
+    via the type parameter T in Bot[T].
+
+Example usage:
+
+	bot := laniakea.NewBot[mydb.DBContext](laniakea.LoadOptsFromEnv()).
+	    DatabaseContext(&myDB).
+	    AddUpdateType(tgapi.UpdateTypeMessage).
+	    AddPrefixes("/", "!").
+	    AddPlugins(&startPlugin, &helpPlugin).
+	    AddMiddleware(&authMiddleware, &logMiddleware).
+	    AddRunner(&cleanupRunner).
+	    AddL10n(l10n.New())
+
+	bot.Run()
+
+All public methods are safe for concurrent use unless stated otherwise.
+Direct field access is not recommended; use provided accessors (e.g., GetDBContext, SetUpdateOffset).
+*/
+package laniakea

drafts.go

@@ -1,40 +1,17 @@
-// Package laniakea provides a safe, high-level interface for managing Telegram
-// message drafts using the tgapi library. It allows creating, editing, and
-// flushing drafts with automatic ID generation and optional bulk flushing.
-//
-// Drafts are designed to be ephemeral, mutable buffers that can be built up
-// incrementally and then sent as final messages. The package ensures safe
-// state management by copying entities and isolating draft contexts.
-//
-// Two draft ID generation strategies are supported:
-//   - Random: Cryptographically secure random IDs (default). Ideal for distributed systems.
-//   - Linear: Monotonically increasing IDs. Useful for persistence, debugging, or recovery.
-//
-// Example usage:
-//
-//	provider := laniakea.NewRandomDraftProvider(api)
-//
-//	draft := provider.NewDraft(tgapi.ParseModeMarkdown)
-//	draft.SetChat(-1001234567890, 0)
-//	draft.Push("*Hello*").Push(" **world**!")
-//	err := draft.Flush() // Sends message and deletes draft
-//	if err != nil {
-//	    log.Printf("Failed to send draft: %v", err)
-//	}
-//
-//	// Or flush all pending drafts at once:
-//	err = provider.FlushAll() // Sends all drafts and clears them
-//
-// Note: Drafts are NOT thread-safe. Concurrent access requires external synchronization.
 package laniakea
 
 import (
+	"errors"
 	"math/rand/v2"
+	"sync"
 	"sync/atomic"
 
 	"git.nix13.pw/scuroneko/laniakea/tgapi"
 )
 
+// ErrDraftChatIDZero is returned when a draft is used without setting a chat ID.
+var ErrDraftChatIDZero = errors.New("zero draft chat ID")
+
 // draftIdGenerator defines an interface for generating unique draft IDs.
 type draftIdGenerator interface {
 	// Next returns the next unique draft ID.
@@ -68,15 +45,10 @@ func (g *LinearDraftIdGenerator) Next() uint64 {
 // DraftProvider is NOT thread-safe. Concurrent access from multiple goroutines
 // requires external synchronization.
 type DraftProvider struct {
+	mu        sync.RWMutex
 	api       *tgapi.API
 	drafts    map[uint64]*Draft
 	generator draftIdGenerator
-
-	// Internal defaults — not exposed directly to users.
-	chatID          int64
-	messageThreadID int
-	parseMode       tgapi.ParseMode
-	entities        []tgapi.MessageEntity
 }
 
 // NewRandomDraftProvider creates a new DraftProvider using random draft IDs.
@@ -107,57 +79,37 @@ func NewLinearDraftProvider(api *tgapi.API, startValue uint64) *DraftProvider {
 	}
 }
 
-// SetChat sets the target chat and optional message thread for all drafts created
-// by this provider. Must be called before NewDraft().
-//
-// If not set, NewDraft() will create drafts with zero chatID, which will cause
-// SendMessageDraft to fail. Use this method to avoid runtime errors.
-func (p *DraftProvider) SetChat(chatID int64, messageThreadID int) *DraftProvider {
-	p.chatID = chatID
-	p.messageThreadID = messageThreadID
-	return p
-}
-
-// SetParseMode sets the default parse mode for all new drafts.
-// Overrides the parse mode passed to NewDraft() only if not specified there.
-func (p *DraftProvider) SetParseMode(mode tgapi.ParseMode) *DraftProvider {
-	p.parseMode = mode
-	return p
-}
-
-// SetEntities sets the default message entities (e.g., bold, links, mentions)
-// to be copied into every new draft.
-//
-// Entities are shallow-copied — if you mutate the slice later, it will affect
-// future drafts. For safety, pass a copy if needed.
-func (p *DraftProvider) SetEntities(entities []tgapi.MessageEntity) *DraftProvider {
-	p.entities = entities
-	return p
-}
-
 // GetDraft retrieves a draft by its ID.
 //
 // Returns the draft and true if found, or nil and false if not found.
 func (p *DraftProvider) GetDraft(id uint64) (*Draft, bool) {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
 	draft, ok := p.drafts[id]
 	return draft, ok
 }
 
 // FlushAll sends all pending drafts as final messages and clears them.
 //
-// If any draft fails to send, FlushAll returns the error immediately and
+// If one or more drafts fail to send, FlushAll still attempts all drafts and
-// leaves other drafts unflushed. This allows for retry logic or logging.
+// returns the first encountered error.
 //
 // After successful flush, each draft is removed from the provider and cleared.
 func (p *DraftProvider) FlushAll() error {
-	var lastErr error
+	p.mu.RLock()
+	drafts := make([]*Draft, 0, len(p.drafts))
 	for _, draft := range p.drafts {
-		if err := draft.Flush(); err != nil {
+		drafts = append(drafts, draft)
-			lastErr = err
+	}
-			break // Stop on first error to avoid partial state
+	p.mu.RUnlock()
+
+	var firstErr error
+	for _, draft := range drafts {
+		if err := draft.Flush(); err != nil && firstErr == nil {
+			firstErr = err
 		}
 	}
-	return lastErr
+	return firstErr
 }
 
 // Draft represents a single message draft that can be edited and flushed.
@@ -186,22 +138,17 @@ type Draft struct {
 //
 // Panics if chatID is zero — call SetChat() on the provider first.
 func (p *DraftProvider) NewDraft(parseMode tgapi.ParseMode) *Draft {
-	if p.chatID == 0 {
-		panic("laniakea: DraftProvider.SetChat() must be called before NewDraft()")
-	}
-
 	id := p.generator.Next()
 	draft := &Draft{
-		api:             p.api,
+		api:       p.api,
-		provider:        p,
+		provider:  p,
-		chatID:          p.chatID,
+		parseMode: parseMode,
-		messageThreadID: p.messageThreadID,
+		ID:        id,
-		parseMode:       parseMode,
+		Message:   "",
-		entities:        p.entities, // Shallow copy — caller must ensure immutability
-		ID:              id,
-		Message:         "",
 	}
+	p.mu.Lock()
 	p.drafts[id] = draft
+	p.mu.Unlock()
 	return draft
 }
 
@@ -217,7 +164,7 @@ func (d *Draft) SetChat(chatID int64, messageThreadID int) *Draft {
 // SetEntities replaces the draft's message entities.
 //
 // Entities are stored by reference. If you plan to mutate the slice later,
-// pass a copy: `SetEntities(append([]tgapi.MessageEntity{}, myEntities...))`
+// pass a copy: `SetEntities(append([]tgapi.MessageEntity{}, myEntities...))`.
 func (d *Draft) SetEntities(entities []tgapi.MessageEntity) *Draft {
 	d.entities = entities
 	return d
@@ -253,7 +200,9 @@ func (d *Draft) Clear() {
 // want to cancel a draft without sending it.
 func (d *Draft) Delete() {
 	if d.provider != nil {
+		d.provider.mu.Lock()
 		delete(d.provider.drafts, d.ID)
+		d.provider.mu.Unlock()
 	}
 	d.Clear()
 }
@@ -295,6 +244,9 @@ func (d *Draft) Flush() error {
 
 // push is the internal helper for Push(). It updates the server draft via SendMessageDraft.
 func (d *Draft) push(text string) error {
+	if d.chatID == 0 {
+		return ErrDraftChatIDZero
+	}
 	d.Message += text
 	params := tgapi.SendMessageDraftP{
 		ChatID:    d.chatID,

examples/basic/.env

@@ -1,7 +0,0 @@
-TG_TOKEN=
-PREFIXES=/;!
-DEBUG=true
-USE_REQ_LOG=true
-WRITE_TO_FILE=false
-USE_TEST_SERVER=true
-API_URL=http://127.0.0.1:8081

examples/basic/example.go

@@ -1,30 +0,0 @@
-package main
-
-import (
-	"log"
-
-	"git.nix13.pw/scuroneko/laniakea"
-)
-
-func echo(ctx *laniakea.MsgContext, db *laniakea.NoDB) {
-	ctx.Answer(ctx.Text) // User input WITHOUT command
-}
-
-func main() {
-	opts := &laniakea.BotOpts{Token: "TOKEN"}
-	bot := laniakea.NewBot[laniakea.NoDB](opts)
-	defer bot.Close()
-
-	p := laniakea.NewPlugin[laniakea.NoDB]("ping")
-	p.AddCommand(p.NewCommand(echo, "echo"))
-	p.AddCommand(p.NewCommand(func(ctx *laniakea.MsgContext, db *laniakea.NoDB) {
-		ctx.Answer("Pong")
-	}, "ping"))
-
-	bot = bot.ErrorTemplate("Error\n\n%s").AddPlugins(p)
-
-	if err := bot.AutoGenerateCommands(); err != nil {
-		log.Println(err)
-	}
-	bot.Run()
-}

examples/basic/go.mod

@@ -1,20 +0,0 @@
-module example/basic
-
-go 1.26.1
-
-require git.nix13.pw/scuroneko/laniakea v1.0.0-beta.14
-
-replace (
-	git.nix13.pw/scuroneko/laniakea v1.0.0-beta.14 => ../../
-)
-
-require (
-	git.nix13.pw/scuroneko/extypes v1.2.1 // indirect
-	git.nix13.pw/scuroneko/slog v1.0.2 // indirect
-	github.com/alitto/pond/v2 v2.7.0 // indirect
-	github.com/fatih/color v1.18.0 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	golang.org/x/sys v0.42.0 // indirect
-	golang.org/x/time v0.15.0 // indirect
-)

examples/basic/go.sum

@@ -1,19 +0,0 @@
-git.nix13.pw/scuroneko/extypes v1.2.1 h1:IYrOjnWKL2EAuJYtYNa+luB1vBe6paE8VY/YD+5/RpQ=
-git.nix13.pw/scuroneko/extypes v1.2.1/go.mod h1:uZVs8Yo3RrYAG9dMad6qR6lsYY67t+459D9c65QAYAw=
-git.nix13.pw/scuroneko/laniakea v1.0.0-beta.13 h1:mRVxYh7CNrm8ccob+u6XxLzZRbs1fLNRg/nXaXY78yw=
-git.nix13.pw/scuroneko/laniakea v1.0.0-beta.13/go.mod h1:M8jwm195hzAl9bj9Bkl95WfHmWvuBX6micsdtOs/gmE=
-git.nix13.pw/scuroneko/slog v1.0.2 h1:vZyUROygxC2d5FJHUQM/30xFEHY1JT/aweDZXA4rm2g=
-git.nix13.pw/scuroneko/slog v1.0.2/go.mod h1:3Qm2wzkR5KjwOponMfG7TcGSDjmYaFqRAmLvSPTuWJI=
-github.com/alitto/pond/v2 v2.7.0 h1:c76L+yN916m/DRXjGCeUBHHu92uWnh/g1bwVk4zyyXg=
-github.com/alitto/pond/v2 v2.7.0/go.mod h1:xkjYEgQ05RSpWdfSd1nM3OVv7TBhLdy7rMp3+2Nq+yE=
-github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
-github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
-golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=

handler.go

@@ -4,14 +4,22 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"strings"
 
 	"git.nix13.pw/scuroneko/laniakea/tgapi"
 )
 
+// ErrInvalidPayloadType is returned when callback payload encoding type is unknown.
 var ErrInvalidPayloadType = errors.New("invalid payload type")
 
 func (bot *Bot[T]) handle(u *tgapi.Update) {
+	defer func() {
+		if r := recover(); r != nil {
+			bot.logger.Errorln(fmt.Sprintf("panic in handle: %v", r))
+		}
+	}()
+
 	ctx := &MsgContext{
 		Update: *u, Api: bot.api,
 		botLogger:     bot.logger,
@@ -21,7 +29,9 @@ func (bot *Bot[T]) handle(u *tgapi.Update) {
 		payloadType:   bot.payloadType,
 	}
 	for _, middleware := range bot.middlewares {
-		middleware.Execute(ctx, bot.dbContext)
+		if !middleware.Execute(ctx, bot.dbContext) {
+			return
+		}
 	}
 
 	if u.CallbackQuery != nil {
@@ -35,6 +45,9 @@ func (bot *Bot[T]) handleMessage(update *tgapi.Update, ctx *MsgContext) {
 	if update.Message == nil {
 		return
 	}
+	if update.Message.From == nil {
+		return
+	}
 
 	var text string
 	if len(update.Message.Text) > 0 {
@@ -84,7 +97,7 @@ func (bot *Bot[T]) handleMessage(update *tgapi.Update, ctx *MsgContext) {
 			if !plugin.executeMiddlewares(ctx, bot.dbContext) {
 				return
 			}
-			go plugin.executeCmd(cmd, ctx, bot.dbContext)
+			plugin.executeCmd(cmd, ctx, bot.dbContext)
 			return
 		}
 	}
@@ -99,8 +112,13 @@ func (bot *Bot[T]) handleCallback(update *tgapi.Update, ctx *MsgContext) {
 
 	ctx.FromID = update.CallbackQuery.From.ID
 	ctx.From = &update.CallbackQuery.From
-	ctx.Msg = &update.CallbackQuery.Message
+	if update.CallbackQuery.Message != nil {
-	ctx.CallbackMsgId = update.CallbackQuery.Message.MessageID
+		ctx.Msg = update.CallbackQuery.Message
+		ctx.CallbackMsgId = update.CallbackQuery.Message.MessageID
+	}
+	if update.CallbackQuery.InlineMessageID != nil {
+		ctx.InlineMsgId = *update.CallbackQuery.InlineMessageID
+	}
 	ctx.CallbackQueryId = update.CallbackQuery.ID
 	ctx.Args = data.Args
 
@@ -113,7 +131,7 @@ func (bot *Bot[T]) handleCallback(update *tgapi.Update, ctx *MsgContext) {
 		if !plugin.executeMiddlewares(ctx, bot.dbContext) {
 			return
 		}
-		go plugin.executePayload(data.Command, ctx, bot.dbContext)
+		plugin.executePayload(data.Command, ctx, bot.dbContext)
 		return
 	}
 }
@@ -144,8 +162,8 @@ func encodeBase64Payload(d CallbackData) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	dst := make([]byte, base64.StdEncoding.EncodedLen(len([]byte(data))))
+	dst := make([]byte, base64.RawURLEncoding.EncodedLen(len([]byte(data))))
-	base64.StdEncoding.Encode(dst, []byte(data))
+	base64.RawURLEncoding.Encode(dst, []byte(data))
 	return string(dst), nil
 }
 
@@ -159,7 +177,7 @@ func encodeBase64Payload(d CallbackData) (string, error) {
 //		return "", ErrInvalidPayloadType
 //	}
 func decodeBase64Payload(s string) (CallbackData, error) {
-	b, err := base64.StdEncoding.DecodeString(s)
+	b, err := base64.RawURLEncoding.DecodeString(s)
 	if err != nil {
 		return CallbackData{}, err
 	}

keyboard.go

@@ -1,13 +1,3 @@
-// Package laniakea provides a fluent builder system for constructing Telegram
-// inline keyboards with callback data and custom styling.
-//
-// This package supports:
-//   - Button builders with style (danger/success/primary), icons, URLs, and callbacks
-//   - Line-based keyboard layout with configurable max row size
-//   - Structured, JSON-serialized callback data for bot command routing
-//
-// Keyboard construction is stateful and builder-style: methods return the receiver
-// to enable chaining. Call Get() to finalize and retrieve the tgapi.ReplyMarkup.
 package laniakea
 
 import (
@@ -79,7 +69,7 @@ func (b InlineKbButtonBuilder) SetUrl(url string) InlineKbButtonBuilder {
 // Args are converted to strings using fmt.Sprint. Non-string types (e.g., int, bool)
 // are safely serialized, but complex structs may not serialize usefully.
 //
-// Example: SetCallbackDataJson("delete_user", 123, "confirm") → {"cmd":"delete_user","args":["123","confirm"]}
+// Example: SetCallbackDataJson("delete_user", 123, "confirm") → {"cmd":"delete_user","args":["123","confirm"]}.
 func (b InlineKbButtonBuilder) SetCallbackDataJson(cmd string, args ...any) InlineKbButtonBuilder {
 	b.callbackData = NewCallbackData(cmd, args...).ToJson()
 	return b
@@ -119,16 +109,32 @@ type InlineKeyboard struct {
 	payloadType BotPayloadType // Serialization format for callback data (JSON or Base64)
 }
 
-// NewInlineKeyboard creates a new keyboard builder with the specified maximum
+// NewInlineKeyboardJson creates a new keyboard builder with the specified maximum
 // number of buttons per row.
 //
-// Example: NewInlineKeyboard(3) creates a keyboard with at most 3 buttons per line.
+// Example: NewInlineKeyboardJson(3) creates a keyboard with at most 3 buttons per line.
-func NewInlineKeyboard(maxRow int) *InlineKeyboard {
+func NewInlineKeyboardJson(maxRow int) *InlineKeyboard {
+	return NewInlineKeyboard(BotPayloadJson, maxRow)
+}
+
+// NewInlineKeyboardBase64 creates a new keyboard builder with the specified maximum
+// number of buttons per row, using Base64 encoding for button payloads.
+//
+// Example: NewInlineKeyboardBase64(3) creates a keyboard with at most 3 buttons per line.
+func NewInlineKeyboardBase64(maxRow int) *InlineKeyboard {
+	return NewInlineKeyboard(BotPayloadBase64, maxRow)
+}
+
+// NewInlineKeyboard creates a new keyboard builder with the specified payload encoding
+// type and maximum number of buttons per row.
+//
+// Use NewInlineKeyboardJson or NewInlineKeyboardBase64 for the common cases.
+func NewInlineKeyboard(payloadType BotPayloadType, maxRow int) *InlineKeyboard {
 	return &InlineKeyboard{
 		CurrentLine: make(extypes.Slice[tgapi.InlineKeyboardButton], 0),
 		Lines:       make([][]tgapi.InlineKeyboardButton, 0),
 		maxRow:      maxRow,
-		payloadType: BotPayloadBase64,
+		payloadType: payloadType,
 	}
 }
 
@@ -204,7 +210,7 @@ func (in *InlineKeyboard) AddLine() *InlineKeyboard {
 // Returns a pointer to a ReplyMarkup suitable for use with tgapi.SendMessage.
 func (in *InlineKeyboard) Get() *tgapi.ReplyMarkup {
 	if in.CurrentLine.Len() > 0 {
-		in.Lines = append(in.Lines, in.CurrentLine)
+		in.AddLine()
 	}
 	return &tgapi.ReplyMarkup{InlineKeyboard: in.Lines}
 }

l10n.go

@@ -1,17 +1,7 @@
-// Package laniakea provides a simple, key-based localization system for
-// multi-language text translation.
-//
-// The system supports:
-//   - Multiple language entries per key (e.g., "ru", "en", "es")
-//   - Fallback language for missing translations
-//   - Key-as-fallback behavior: if a key or language is not found, returns the key itself
-//
-// This is designed for lightweight, static localization in bots or services
-// where dynamic translation services are unnecessary.
 package laniakea
 
 // DictEntry represents a single localized entry with language-to-text mappings.
-// Example: {"ru": "Привет", "en": "Hello"}
+// Example: {"ru": "Привет", "en": "Hello"}.
 type DictEntry map[string]string
 
 // L10n is a localization manager that maps keys to language-specific strings.

methods.go

@@ -6,6 +6,38 @@ import (
 	"git.nix13.pw/scuroneko/laniakea/tgapi"
 )
 
+// Updates fetches new updates from Telegram API using long polling.
+// It respects the bot's current update offset and automatically advances it
+// after successful retrieval. The method supports selective update types
+// through AllowedUpdates and includes optional request logging.
+//
+// Parameters:
+//   - None (uses bot's internal state for offset and allowed updates)
+//
+// Returns:
+//   - []tgapi.Update: slice of received updates (empty if none available)
+//   - error: any error encountered during the API call
+//
+// Behavior:
+//  1. Uses the bot's current update offset (via GetUpdateOffset)
+//  2. Requests updates with 30-second timeout
+//  3. Filters updates by types specified in bot.GetUpdateTypes()
+//  4. Logs raw update JSON if RequestLogger is configured
+//  5. Automatically updates the offset to the last received update ID + 1
+//  6. Returns all received updates (empty slice if none)
+//
+// Note: This is a blocking call that waits up to 30 seconds for new updates.
+// For non-blocking behavior, consider using webhooks instead.
+//
+// Example:
+//
+//	updates, err := bot.Updates()
+//	if err != nil {
+//	    log.Fatal(err)
+//	}
+//	for _, update := range updates {
+//	    // process update
+//	}
 func (bot *Bot[T]) Updates() ([]tgapi.Update, error) {
 	offset := bot.GetUpdateOffset()
 	params := tgapi.UpdateParams{

msg_context.go

@@ -1,27 +1,9 @@
-// Package laniakea provides a high-level context-based API for handling Telegram
-// bot interactions, including message responses, callback queries, inline keyboards,
-// localization, and message drafting. It wraps tgapi and adds convenience methods
-// with built-in rate limiting, error handling, and i18n support.
-//
-// The core type is MsgContext, which encapsulates the state of a Telegram update
-// and provides methods to respond, edit, delete, and translate messages.
-//
-// # Markdown Safety Warning
-//
-// All methods that accept MarkdownV2 formatting (e.g., AnswerMarkdown, EditCallbackfMarkdown)
-// require that user-provided text be escaped using laniakea.EscapeMarkdownV2().
-// Failure to escape user input may result in Telegram API errors, malformed messages,
-// or security issues.
-//
-// Example:
-//
-//	text := laniakea.EscapeMarkdownV2(userInput)
-//	ctx.AnswerMarkdown("You said: " + text)
 package laniakea
 
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"git.nix13.pw/scuroneko/laniakea/tgapi"
 	"git.nix13.pw/scuroneko/slog"
@@ -31,13 +13,16 @@ import (
 // It provides methods to respond, edit, delete, and translate messages, as well as
 // manage inline keyboards and message drafts.
 type MsgContext struct {
-	Api             *tgapi.API
+	Api    *tgapi.API
-	Msg             *tgapi.Message
+	Update tgapi.Update
-	Update          tgapi.Update
+
-	From            *tgapi.User
+	Msg  *tgapi.Message
+	From *tgapi.User
+
+	InlineMsgId     string
 	CallbackMsgId   int
 	CallbackQueryId string
-	FromID          int
+	FromID          int64
 	Prefix          string
 	Text            string
 	Args            []string
@@ -62,11 +47,19 @@ type AnswerMessage struct {
 // Used by Edit, EditMarkdown, EditCallback, etc.
 func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
 	params := tgapi.EditMessageTextP{
-		MessageID: messageId,
-		ChatID:    ctx.Msg.Chat.ID,
 		Text:      text,
 		ParseMode: parseMode,
 	}
+	switch {
+	case messageId > 0 && ctx.Msg != nil:
+		params.MessageID = messageId
+		params.ChatID = ctx.Msg.Chat.ID
+	case ctx.InlineMsgId != "":
+		params.InlineMessageID = ctx.InlineMsgId
+	default:
+		ctx.botLogger.Errorln("Can't edit message: no valid message target")
+		return nil
+	}
 	if keyboard != nil {
 		params.ReplyMarkup = keyboard.Get()
 	}
@@ -75,8 +68,12 @@ func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard
 		ctx.botLogger.Errorln(err)
 		return nil
 	}
+	resultMessageID := messageId
+	if msg.MessageID > 0 {
+		resultMessageID = msg.MessageID
+	}
 	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: false,
+		MessageID: resultMessageID, ctx: ctx, Text: text, IsMedia: false,
 	}
 }
 
@@ -95,9 +92,9 @@ func (m *AnswerMessage) EditMarkdown(text string) *AnswerMessage {
 }
 
 // editCallback is an internal helper to edit the message associated with a callback query.
-// Returns nil if CallbackMsgId is 0 (not a callback context).
+// Supports both regular callback messages and inline callback messages.
 func (ctx *MsgContext) editCallback(text string, keyboard *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
-	if ctx.CallbackMsgId == 0 {
+	if ctx.CallbackMsgId == 0 && ctx.InlineMsgId == "" {
 		ctx.botLogger.Errorln("Can't edit non-callback update message")
 		return nil
 	}
@@ -129,18 +126,22 @@ func (ctx *MsgContext) EditCallbackfMarkdown(format string, keyboard *InlineKeyb
 }
 
 // editPhotoText edits the caption of a photo/video message.
-// Returns nil if messageId is 0.
+// Returns nil when no valid edit target is available for the current context.
 func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
-	if messageId == 0 {
-		ctx.botLogger.Errorln("Can't edit caption message, message ID zero")
-		return nil
-	}
 	params := tgapi.EditMessageCaptionP{
-		ChatID:    ctx.Msg.Chat.ID,
-		MessageID: messageId,
 		Caption:   text,
 		ParseMode: parseMode,
 	}
+	switch {
+	case messageId > 0 && ctx.Msg != nil:
+		params.ChatID = ctx.Msg.Chat.ID
+		params.MessageID = messageId
+	case ctx.InlineMsgId != "":
+		params.InlineMessageID = ctx.InlineMsgId
+	default:
+		ctx.botLogger.Errorln("Can't edit caption: no valid message target")
+		return nil
+	}
 	if kb != nil {
 		params.ReplyMarkup = kb.Get()
 	}
@@ -148,9 +149,14 @@ func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeybo
 	msg, _, err := ctx.Api.EditMessageCaption(params)
 	if err != nil {
 		ctx.botLogger.Errorln(err)
+		return nil
+	}
+	resultMessageID := messageId
+	if msg.MessageID > 0 {
+		resultMessageID = msg.MessageID
 	}
 	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
+		MessageID: resultMessageID, ctx: ctx, Text: text, IsMedia: true,
 	}
 }
 
@@ -181,6 +187,10 @@ func (m *AnswerMessage) EditCaptionKeyboardMarkdown(text string, kb *InlineKeybo
 // answer sends a new message with optional keyboard and parse mode.
 // Uses API limiter to respect Telegram rate limits per chat.
 func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("Can't answer message without a message")
+		return nil
+	}
 	params := tgapi.SendMessageP{
 		ChatID:    ctx.Msg.Chat.ID,
 		Text:      text,
@@ -196,11 +206,6 @@ func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard, parseMode t
 		params.DirectMessagesTopicID = ctx.Msg.DirectMessageTopic.TopicID
 	}
 
-	cont := context.Background()
-	if err := ctx.Api.Limiter.Wait(cont, ctx.Msg.Chat.ID); err != nil {
-		ctx.botLogger.Errorln(err)
-		return nil
-	}
 	msg, err := ctx.Api.SendMessage(params)
 	if err != nil {
 		ctx.botLogger.Errorln(err)
@@ -249,6 +254,10 @@ func (ctx *MsgContext) KeyboardMarkdown(text string, keyboard *InlineKeyboard) *
 
 // answerPhoto sends a photo with optional caption and keyboard.
 func (ctx *MsgContext) answerPhoto(photoId, text string, kb *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("Can't answer message without a message")
+		return nil
+	}
 	params := tgapi.SendPhotoP{
 		ChatID:    ctx.Msg.Chat.ID,
 		Caption:   text,
@@ -310,6 +319,14 @@ func (ctx *MsgContext) AnswerPhotofMarkdown(photoId, template string, args ...an
 
 // delete removes a message by ID.
 func (ctx *MsgContext) delete(messageId int) {
+	if messageId == 0 {
+		ctx.botLogger.Errorln("Can't delete message: message ID zero")
+		return
+	}
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("Can't delete message: no chat message context")
+		return
+	}
 	_, err := ctx.Api.DeleteMessage(tgapi.DeleteMessageP{
 		ChatID:    ctx.Msg.Chat.ID,
 		MessageID: messageId,
@@ -323,7 +340,13 @@ func (ctx *MsgContext) delete(messageId int) {
 func (m *AnswerMessage) Delete() { m.ctx.delete(m.MessageID) }
 
 // CallbackDelete deletes the message that triggered the callback query.
-func (ctx *MsgContext) CallbackDelete() { ctx.delete(ctx.CallbackMsgId) }
+func (ctx *MsgContext) CallbackDelete() {
+	if ctx.CallbackMsgId == 0 {
+		ctx.botLogger.Errorln("Can't delete callback message: no callback message ID")
+		return
+	}
+	ctx.delete(ctx.CallbackMsgId)
+}
 
 // answerCallbackQuery sends a response to a callback query (optional text/alert/url).
 // Does nothing if CallbackQueryId is empty.
@@ -354,6 +377,10 @@ func (ctx *MsgContext) AnswerCbQueryUrl(u string) { ctx.answerCallbackQuery(u, "
 
 // SendAction sends a chat action (typing, uploading_photo, etc.) to indicate bot activity.
 func (ctx *MsgContext) SendAction(action tgapi.ChatActionType) {
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("Can't send action without chat message context")
+		return
+	}
 	params := tgapi.SendChatActionP{
 		ChatID: ctx.Msg.Chat.ID, Action: action,
 	}
@@ -385,7 +412,13 @@ func (ctx *MsgContext) error(err error) {
 func (ctx *MsgContext) Error(err error) { ctx.error(err) }
 
 func (ctx *MsgContext) newDraft(parseMode tgapi.ParseMode) *Draft {
-	c := context.Background()
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("can't create draft: ctx.Msg is nil")
+		return nil
+	}
+
+	c, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
 	if err := ctx.Api.Limiter.Wait(c, ctx.Msg.Chat.ID); err != nil {
 		ctx.botLogger.Errorln(err)
 		return nil
@@ -401,6 +434,9 @@ func (ctx *MsgContext) NewDraft() *Draft {
 	return ctx.newDraft(tgapi.ParseNone)
 }
 
+// NewDraftMarkdown creates a new message draft associated with the current chat,
+// with Markdown V2 parse mode enabled.
+// Uses the API limiter to avoid rate limiting.
 func (ctx *MsgContext) NewDraftMarkdown() *Draft {
 	return ctx.newDraft(tgapi.ParseMDV2)
 }
@@ -414,3 +450,9 @@ func (ctx *MsgContext) Translate(key string) string {
 	lang := Val(ctx.From.LanguageCode, ctx.l10n.GetFallbackLanguage())
 	return ctx.l10n.Translate(lang, key)
 }
+
+// NewInlineKeyboard creates a new keyboard builder with the context's payload
+// encoding type and the specified maximum number of buttons per row.
+func (ctx *MsgContext) NewInlineKeyboard(maxRow int) *InlineKeyboard {
+	return NewInlineKeyboard(ctx.payloadType, maxRow)
+}

plugins.go

@@ -1,15 +1,3 @@
-// Package laniakea provides a structured system for defining and executing
-// bot commands and payloads with middleware support, argument validation,
-// and plugin-based organization.
-//
-// The core concepts are:
-//   - Command: A named bot command with arguments, description, and executor.
-//   - Plugin: A collection of commands and payloads, with shared middlewares.
-//   - Middleware: Interceptors that can validate, modify, or block execution.
-//   - CommandArg: Type-safe argument definitions with regex validation.
-//
-// This system is designed to be used with MsgContext from the laniakea package
-// to handle Telegram bot interactions in a modular, type-safe way.
 package laniakea
 
 import (
@@ -33,11 +21,14 @@ const (
 	CommandValueAnyType CommandValueType = "any"
 )
 
-// CommandRegexInt matches one or more digits.
+var (
-var CommandRegexInt = regexp.MustCompile(`\d+`)
+	// CommandRegexInt matches one or more digits.
-
+	CommandRegexInt = regexp.MustCompile(`\d+`)
-// CommandRegexString matches any non-empty string.
+	// CommandRegexString matches any non-empty string.
-var CommandRegexString = regexp.MustCompile(".+")
+	CommandRegexString = regexp.MustCompile(`.+`)
+	// CommandRegexBool matches true or false.
+	CommandRegexBool = regexp.MustCompile(`true|false`)
+)
 
 // ErrCmdArgCountMismatch is returned when the number of provided arguments
 // is less than the number of required arguments.
@@ -58,15 +49,23 @@ type CommandArg struct {
 // NewCommandArg creates a new CommandArg with the given text and type.
 // Uses a default regex based on the type (string or int).
 // For CommandValueAnyType, no validation is performed.
-func NewCommandArg(text string, valueType CommandValueType) *CommandArg {
+func NewCommandArg(text string) *CommandArg {
+	return &CommandArg{CommandValueAnyType, text, CommandRegexString, false}
+}
+
+// SetValueType sets expected value type and switches built-in validation regexp.
+func (c *CommandArg) SetValueType(t CommandValueType) *CommandArg {
 	regex := CommandRegexString
-	switch valueType {
+	switch t {
 	case CommandValueIntType:
 		regex = CommandRegexInt
+	case CommandValueBoolType:
+		regex = CommandRegexBool
 	case CommandValueAnyType:
 		regex = nil // Skip validation
 	}
-	return &CommandArg{valueType, text, regex, false}
+	c.regex = regex
+	return c
 }
 
 // SetRequired marks this argument as required.
@@ -98,7 +97,7 @@ func NewCommand[T any](exec CommandExecutor[T], command string, args ...CommandA
 }
 
 // NewPayload creates a new Command with the given executor, command payload string, and arguments.
-// The command string can POTENTIALLY contain any symbols, but recommended to use only "_", "-", ".", a-Z, 0-9
+// The command string can contain any symbols, but it is recommended to use only "_", "-", ".", a-z, A-Z, and 0-9.
 func NewPayload[T any](exec CommandExecutor[T], command string, args ...CommandArg) *Command[T] {
 	return &Command[T]{command, "", exec, args, make(extypes.Slice[Middleware[T]], 0), false}
 }
@@ -225,11 +224,6 @@ func (p *Plugin[T]) executeCmd(cmd string, ctx *MsgContext, dbContext *T) {
 		return
 	}
 
-	// Run plugin middlewares
-	if !p.executeMiddlewares(ctx, dbContext) {
-		return
-	}
-
 	// Run command-specific middlewares
 	for _, m := range command.middlewares {
 		if !m.Execute(ctx, dbContext) {
@@ -256,11 +250,6 @@ func (p *Plugin[T]) executePayload(payload string, ctx *MsgContext, dbContext *T
 		return
 	}
 
-	// Run plugin middlewares
-	if !p.executeMiddlewares(ctx, dbContext) {
-		return
-	}
-
 	// Run command-specific middlewares
 	for _, m := range command.middlewares {
 		if !m.Execute(ctx, dbContext) {
@@ -320,7 +309,10 @@ func (m *Middleware[T]) SetAsync(async bool) *Middleware[T] {
 // Otherwise, returns the result of the executor.
 func (m *Middleware[T]) Execute(ctx *MsgContext, db *T) bool {
 	if m.async {
-		go m.executor(ctx, db)
+		ctx := *ctx // copy context to avoid race condition
+		go func(ctx MsgContext) {
+			m.executor(&ctx, db)
+		}(ctx)
 		return true
 	}
 	return m.executor(ctx, db)

runners.go

@@ -1,16 +1,7 @@
-// Package laniakea provides a system for managing background and one-time
-// runner functions that operate on a Bot instance, with support for
-// asynchronous execution, timeouts, and lifecycle control.
-//
-// Runners are used for periodic tasks (e.g., cleanup, stats updates) or
-// one-time initialization logic. They are executed via Bot.ExecRunners().
-//
-// Important: Runners are not thread-safe for concurrent modification.
-// Builder methods (Onetime, Async, Timeout) must be called sequentially
-// and only before Execute().
 package laniakea
 
 import (
+	"context"
 	"time"
 )
 
@@ -83,7 +74,7 @@ func (r *Runner[T]) Timeout(timeout time.Duration) *Runner[T] {
 	return r
 }
 
-// ExecRunners executes all runners registered on the Bot.
+// ExecRunners executes all runners registered on the Bot with context-based lifecycle management.
 //
 // It logs warnings for misconfigured runners:
 //   - Sync, non-onetime runners are skipped (invalid configuration).
@@ -92,11 +83,13 @@ func (r *Runner[T]) Timeout(timeout time.Duration) *Runner[T] {
 // Execution logic:
 //   - onetime + async: Runs once in a goroutine.
 //   - onetime + sync:  Runs once synchronously; warns if slower than 2 seconds.
-//   - !onetime + async: Runs in an infinite loop with timeout between iterations.
+//   - !onetime + async: Runs in a loop with timeout between iterations until ctx.Done().
 //   - !onetime + sync: Skipped with warning.
 //
-// This method is typically called once during bot startup.
+// Background runners listen for ctx.Done() and gracefully shut down when the context is canceled.
-func (bot *Bot[T]) ExecRunners() {
+//
+// This method is typically called once during bot startup in RunWithContext.
+func (bot *Bot[T]) ExecRunners(ctx context.Context) {
 	bot.logger.Infoln("Executing runners...")
 	for _, runner := range bot.runners {
 		// Validate configuration
@@ -105,12 +98,15 @@ func (bot *Bot[T]) ExecRunners() {
 			continue
 		}
 		if !runner.onetime && runner.async && runner.timeout == 0 {
-			bot.logger.Warnf("Background runner \"%s\" has no timeout — may cause tight loop\n", runner.name)
+			bot.logger.Warnf("Background runner \"%s\" has no timeout — skipping\n", runner.name)
+			continue
 		}
 
 		if runner.onetime && runner.async {
 			// One-time async: fire and forget
+			bot.runnerOnceWG.Add(1)
 			go func(r Runner[T]) {
+				defer bot.runnerOnceWG.Done()
 				err := r.fn(bot)
 				if err != nil {
 					bot.logger.Warnf("Runner %s failed: %s\n", r.name, err)
@@ -128,14 +124,22 @@ func (bot *Bot[T]) ExecRunners() {
 				bot.logger.Warnf("Runner %s too slow. Elapsed time %v >= 2s\n", runner.name, elapsed)
 			}
 		} else if !runner.onetime && runner.async {
-			// Background loop: periodic execution
+			// Background loop: periodic execution with graceful shutdown
+			bot.runnerBgWG.Add(1)
 			go func(r Runner[T]) {
+				defer bot.runnerBgWG.Done()
+				ticker := time.NewTicker(r.timeout)
+				defer ticker.Stop()
 				for {
-					err := r.fn(bot)
+					select {
-					if err != nil {
+					case <-ctx.Done():
-						bot.logger.Warnf("Runner %s failed: %s\n", r.name, err)
+						return
+					case <-ticker.C:
+						err := r.fn(bot)
+						if err != nil {
+							bot.logger.Warnf("Runner %s failed: %s\n", r.name, err)
+						}
 					}
-					time.Sleep(r.timeout)
 				}
 			}(runner)
 		}

tgapi/api.go

@@ -76,7 +76,11 @@ func (opts *APIOpts) SetLimiterDrop(b bool) *APIOpts {
 	return opts
 }
 
-// API is the main Telegram Bot API client.
+// API is the main Telegram Bot API client for JSON requests.
+//
+// Use API methods when sending JSON payloads (for example with file_id, URL, or other
+// non-multipart fields). For multipart file uploads, use Uploader.
+//
 // It manages HTTP requests, rate limiting, retries, and connection pooling.
 type API struct {
 	token         string
@@ -102,7 +106,7 @@ func NewAPI(opts *APIOpts) *API {
 	}
 
 	pool := newWorkerPool(16, 256)
-	pool.start(context.Background())
+	pool.start()
 
 	return &API{
 		token:             opts.token,
@@ -118,12 +122,14 @@ func NewAPI(opts *APIOpts) *API {
 
 // CloseApi shuts down the internal worker pool and closes the logger.
 // Must be called to avoid resource leaks.
+// See https://core.telegram.org/bots/api
 func (api *API) CloseApi() error {
 	api.pool.stop()
 	return api.logger.Close()
 }
 
 // GetLogger returns the internal logger for custom logging.
+// See https://core.telegram.org/bots/api
 func (api *API) GetLogger() *slog.Logger {
 	return api.logger
 }
@@ -161,27 +167,13 @@ type TelegramRequest[R, P any] struct {
 	chatId int64
 }
 
-// NewRequest and NewRequestWithChatID are DEPRECATED.
+// NewRequest creates an untyped TelegramRequest for the given method and params with no chat ID.
-// They encourage unsafe, untyped usage and bypass Go's type safety.
-// Instead, define explicit, type-safe methods for each Telegram API endpoint.
-//
-// Example:
-//
-//	func (api *API) SendMessage(ctx context.Context, chatID int64, text string) (Message, error) { ... }
-//
-// This provides:
-//
-//	✅ Compile-time validation
-//	✅ IDE autocompletion
-//	✅ Clear API surface
-//	✅ Better error messages
-//
-// DO NOT use these constructors in production code.
-// This can be used ONLY for testing or if you NEED method, that wasn't added as function.
 func NewRequest[R, P any](method string, params P) TelegramRequest[R, P] {
 	return TelegramRequest[R, P]{method, params, 0}
 }
 
+// NewRequestWithChatID creates an untyped TelegramRequest with an associated chat ID.
+// The chat ID is used for per-chat rate limiting.
 func NewRequestWithChatID[R, P any](method string, params P, chatId int64) TelegramRequest[R, P] {
 	return TelegramRequest[R, P]{method, params, chatId}
 }
@@ -191,12 +183,10 @@ func NewRequestWithChatID[R, P any](method string, params P, chatId int64) Teleg
 // Must be called within a worker pool context if using DoWithContext.
 func (r TelegramRequest[R, P]) doRequest(ctx context.Context, api *API) (R, error) {
 	var zero R
-
+	reqData, err := json.Marshal(r.params)
-	data, err := json.Marshal(r.params)
 	if err != nil {
 		return zero, fmt.Errorf("failed to marshal request: %w", err)
 	}
-	buf := bytes.NewBuffer(data)
 
 	methodPrefix := ""
 	if api.useTestServer {
@@ -204,7 +194,7 @@ func (r TelegramRequest[R, P]) doRequest(ctx context.Context, api *API) (R, erro
 	}
 	url := fmt.Sprintf("%s/bot%s%s/%s", api.apiUrl, api.token, methodPrefix, r.method)
 
-	req, err := http.NewRequestWithContext(ctx, "POST", url, buf)
+	req, err := http.NewRequestWithContext(ctx, "POST", url, nil)
 	if err != nil {
 		return zero, fmt.Errorf("failed to create request: %w", err)
 	}
@@ -213,7 +203,6 @@ func (r TelegramRequest[R, P]) doRequest(ctx context.Context, api *API) (R, erro
 	req.Header.Set("Accept", "application/json")
 	req.Header.Set("User-Agent", fmt.Sprintf("Laniakea/%s", utils.VersionString))
 	req.Header.Set("Accept-Encoding", "gzip")
-	req.ContentLength = int64(len(data))
 
 	for {
 		// Apply rate limiting before making the request
@@ -222,22 +211,25 @@ func (r TelegramRequest[R, P]) doRequest(ctx context.Context, api *API) (R, erro
 				return zero, err
 			}
 		}
+		buf := bytes.NewBuffer(reqData)
+		req.Body = io.NopCloser(buf)
+		req.ContentLength = int64(len(reqData))
 
-		api.logger.Debugln("REQ", url, string(data))
+		api.logger.Debugln("REQ", url, string(reqData))
 		resp, err := api.client.Do(req)
 		if err != nil {
 			return zero, fmt.Errorf("HTTP request failed: %w", err)
 		}
 
-		data, err = readBody(resp.Body)
+		respData, err := readBody(resp.Body)
 		_ = resp.Body.Close() // ensure body is closed
 		if err != nil {
 			return zero, fmt.Errorf("failed to read response body: %w", err)
 		}
 
-		api.logger.Debugln("RES", r.method, string(data))
+		api.logger.Debugln("RES", r.method, string(respData))
 
-		response, err := parseBody[R](data)
+		response, err := parseBody[R](respData)
 		if err != nil {
 			return zero, fmt.Errorf("failed to parse response: %w", err)
 		}
@@ -249,10 +241,12 @@ func (r TelegramRequest[R, P]) doRequest(ctx context.Context, api *API) (R, erro
 				api.logger.Warnf("Rate limited by Telegram, retry after %d seconds (chat: %d)", after, r.chatId)
 
 				// Apply cooldown to global or chat-specific limiter
-				if r.chatId > 0 {
+				if api.Limiter != nil {
-					api.Limiter.SetChatLock(r.chatId, after)
+					if r.chatId > 0 {
-				} else {
+						api.Limiter.SetChatLock(r.chatId, after)
-					api.Limiter.SetGlobalLock(after)
+					} else {
+						api.Limiter.SetGlobalLock(after)
+					}
 				}
 
 				// Wait and retry
@@ -311,21 +305,13 @@ func readBody(body io.ReadCloser) ([]byte, error) {
 	return io.ReadAll(reader)
 }
 
-// parseBody unmarshals Telegram API response and returns structured result.
+// parseBody unmarshals a Telegram API response into a typed ApiResponse.
-// Returns ErrRateLimit internally if error_code == 429 — caller must handle via response.Ok check.
+// Only returns an error on malformed JSON; non-OK responses are left for the caller to handle.
 func parseBody[R any](data []byte) (ApiResponse[R], error) {
 	var resp ApiResponse[R]
 	err := json.Unmarshal(data, &resp)
 	if err != nil {
 		return resp, fmt.Errorf("failed to unmarshal JSON: %w", err)
 	}
-
-	if !resp.Ok {
-		if resp.ErrorCode == 429 {
-			return resp, ErrRateLimit // internal use only
-		}
-		return resp, fmt.Errorf("[%d] %s", resp.ErrorCode, resp.Description)
-	}
-
 	return resp, nil
 }

tgapi/attachments_methods.go

@@ -15,7 +15,7 @@ type SendPhotoP struct {
 
 	ShowCaptionAboveMedia bool   `json:"show_caption_above_media,omitempty"`
 	HasSpoiler            bool   `json:"has_spoiler,omitempty"`
-	DisableNotifications  bool   `json:"disable_notifications,omitempty"`
+	DisableNotifications  bool   `json:"disable_notification,omitempty"`
 	ProtectContent        bool   `json:"protect_content,omitempty"`
 	AllowPaidBroadcast    bool   `json:"allow_paid_broadcast,omitempty"`
 	MessageEffectID       string `json:"message_effect_id,omitempty"`
@@ -107,7 +107,7 @@ type SendVideoP struct {
 	Duration int    `json:"duration,omitempty"`
 	Width    int    `json:"width,omitempty"`
 	Height   int    `json:"height,omitempty"`
-	Cover    int    `json:"cover,omitempty"`
+	Cover    string `json:"cover,omitempty"`
 
 	StartTimestamp  int             `json:"start_timestamp,omitempty"`
 	Caption         string          `json:"caption,omitempty"`
@@ -276,7 +276,7 @@ type SendMediaGroupP struct {
 
 // SendMediaGroup sends a group of photos, videos, documents or audios as an album.
 // See https://core.telegram.org/bots/api#sendmediagroup
-func (api *API) SendMediaGroup(params SendMediaGroupP) (Message, error) {
+func (api *API) SendMediaGroup(params SendMediaGroupP) ([]Message, error) {
-	req := NewRequestWithChatID[Message]("sendMediaGroup", params, params.ChatID)
+	req := NewRequestWithChatID[[]Message]("sendMediaGroup", params, params.ChatID)
 	return req.Do(api)
 }

tgapi/attachments_types.go

@@ -70,5 +70,5 @@ type PhotoSize struct {
 	FileUniqueID string `json:"file_unique_id"`
 	Width        int    `json:"width"`
 	Height       int    `json:"height"`
-	FileSize     int    `json:"file_size,omitempty"`
+	FileSize     int64  `json:"file_size,omitempty"`
 }

tgapi/bot_methods.go

@@ -154,7 +154,7 @@ func (api *API) RemoveMyProfilePhoto() (bool, error) {
 // SetChatMenuButtonP holds parameters for the setChatMenuButton method.
 // See https://core.telegram.org/bots/api#setchatmenubutton
 type SetChatMenuButtonP struct {
-	ChatID     int            `json:"chat_id"`
+	ChatID     int64          `json:"chat_id"`
 	MenuButton MenuButtonType `json:"menu_button"`
 }
 
@@ -169,7 +169,7 @@ func (api *API) SetChatMenuButton(params SetChatMenuButtonP) (bool, error) {
 // GetChatMenuButtonP holds parameters for the getChatMenuButton method.
 // See https://core.telegram.org/bots/api#getchatmenubutton
 type GetChatMenuButtonP struct {
-	ChatID int `json:"chat_id"`
+	ChatID int64 `json:"chat_id"`
 }
 
 // GetChatMenuButton returns the current menu button for the given chat.
@@ -217,8 +217,8 @@ func (api *API) GetAvailableGifts() (Gifts, error) {
 // SendGiftP holds parameters for the sendGift method.
 // See https://core.telegram.org/bots/api#sendgift
 type SendGiftP struct {
-	UserID        int             `json:"user_id,omitempty"`
+	UserID        int64           `json:"user_id,omitempty"`
-	ChatID        int             `json:"chat_id,omitempty"`
+	ChatID        int64           `json:"chat_id,omitempty"`
 	GiftID        string          `json:"gift_id"`
 	PayForUpgrade bool            `json:"pay_for_upgrade"`
 	Text          string          `json:"text"`
@@ -237,7 +237,7 @@ func (api *API) SendGift(params SendGiftP) (bool, error) {
 // GiftPremiumSubscriptionP holds parameters for the giftPremiumSubscription method.
 // See https://core.telegram.org/bots/api#giftpremiumsubscription
 type GiftPremiumSubscriptionP struct {
-	UserID        int             `json:"user_id"`
+	UserID        int64           `json:"user_id"`
 	MonthCount    int             `json:"month_count"`
 	StarCount     int             `json:"star_count"`
 	Text          string          `json:"text,omitempty"`

tgapi/bot_types.go

@@ -31,8 +31,8 @@ const (
 // See https://core.telegram.org/bots/api#botcommandscope
 type BotCommandScope struct {
 	Type   BotCommandScopeType `json:"type"`
-	ChatID *int                `json:"chat_id,omitempty"`
+	ChatID *int64              `json:"chat_id,omitempty"`
-	UserID *int                `json:"user_id,omitempty"`
+	UserID *int64              `json:"user_id,omitempty"`
 }
 
 // BotName represents the bot's name.

tgapi/business_methods.go

@@ -3,7 +3,7 @@ package tgapi
 // VerifyUserP holds parameters for the verifyUser method.
 // See https://core.telegram.org/bots/api#verifyuser
 type VerifyUserP struct {
-	UserID            int    `json:"user_id"`
+	UserID            int64  `json:"user_id"`
 	CustomDescription string `json:"custom_description,omitempty"`
 }
 
@@ -18,7 +18,7 @@ func (api *API) VerifyUser(params VerifyUserP) (bool, error) {
 // VerifyChatP holds parameters for the verifyChat method.
 // See https://core.telegram.org/bots/api#verifychat
 type VerifyChatP struct {
-	ChatID            int    `json:"chat_id"`
+	ChatID            int64  `json:"chat_id"`
 	CustomDescription string `json:"custom_description,omitempty"`
 }
 
@@ -33,7 +33,7 @@ func (api *API) VerifyChat(params VerifyChatP) (bool, error) {
 // RemoveUserVerificationP holds parameters for the removeUserVerification method.
 // See https://core.telegram.org/bots/api#removeuserverification
 type RemoveUserVerificationP struct {
-	UserID int `json:"user_id"`
+	UserID int64 `json:"user_id"`
 }
 
 // RemoveUserVerification removes a user's verification.
@@ -47,7 +47,7 @@ func (api *API) RemoveUserVerification(params RemoveUserVerificationP) (bool, er
 // RemoveChatVerificationP holds parameters for the removeChatVerification method.
 // See https://core.telegram.org/bots/api#removechatverification
 type RemoveChatVerificationP struct {
-	ChatID int `json:"chat_id"`
+	ChatID int64 `json:"chat_id"`
 }
 
 // RemoveChatVerification removes a chat's verification.
@@ -62,7 +62,7 @@ func (api *API) RemoveChatVerification(params RemoveChatVerificationP) (bool, er
 // See https://core.telegram.org/bots/api#readbusinessmessage
 type ReadBusinessMessageP struct {
 	BusinessConnectionID string `json:"business_connection_id"`
-	ChatID               int    `json:"chat_id"`
+	ChatID               int64  `json:"chat_id"`
 	MessageID            int    `json:"message_id"`
 }
 
@@ -74,18 +74,31 @@ func (api *API) ReadBusinessMessage(params ReadBusinessMessageP) (bool, error) {
 	return req.Do(api)
 }
 
-// DeleteBusinessMessageP holds parameters for the deleteBusinessMessage method.
+// GetBusinessConnectionP holds parameters for the getBusinessConnection method.
-// See https://core.telegram.org/bots/api#deletebusinessmessage
+// See https://core.telegram.org/bots/api#getbusinessconnection
-type DeleteBusinessMessageP struct {
+type GetBusinessConnectionP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+}
+
+// GetBusinessConnection returns information about a business connection.
+// See https://core.telegram.org/bots/api#getbusinessconnection
+func (api *API) GetBusinessConnection(params GetBusinessConnectionP) (BusinessConnection, error) {
+	req := NewRequest[BusinessConnection]("getBusinessConnection", params)
+	return req.Do(api)
+}
+
+// DeleteBusinessMessagesP holds parameters for the deleteBusinessMessages method.
+// See https://core.telegram.org/bots/api#deletebusinessmessages
+type DeleteBusinessMessagesP struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	MessageIDs           []int  `json:"message_ids"`
 }
 
-// DeleteBusinessMessage deletes business messages.
+// DeleteBusinessMessages deletes business messages.
 // Returns true on success.
-// See https://core.telegram.org/bots/api#deletebusinessmessage
+// See https://core.telegram.org/bots/api#deletebusinessmessages
-func (api *API) DeleteBusinessMessage(params DeleteBusinessMessageP) (bool, error) {
+func (api *API) DeleteBusinessMessages(params DeleteBusinessMessagesP) (bool, error) {
-	req := NewRequest[bool]("deleteBusinessMessage", params)
+	req := NewRequest[bool]("deleteBusinessMessages", params)
 	return req.Do(api)
 }
 
@@ -191,22 +204,22 @@ type GetBusinessAccountStarBalanceP struct {
 // GetBusinessAccountStarBalance returns the star balance of a business account.
 // See https://core.telegram.org/bots/api#getbusinessaccountstarbalance
 func (api *API) GetBusinessAccountStarBalance(params GetBusinessAccountStarBalanceP) (StarAmount, error) {
-	req := NewRequest[StarAmount]("getBusinessAccountGiftSettings", params) // Note: method name in call is incorrect, should be "getBusinessAccountStarBalance". We'll keep as is, but comment refers to correct.
+	req := NewRequest[StarAmount]("getBusinessAccountStarBalance", params)
 	return req.Do(api)
 }
 
-// TransferBusinessAccountStartP holds parameters for the transferBusinessAccountStart method.
+// TransferBusinessAccountStarsP holds parameters for the transferBusinessAccountStars method.
-// See https://core.telegram.org/bots/api#transferbusinessaccountstart
+// See https://core.telegram.org/bots/api#transferbusinessaccountstars
-type TransferBusinessAccountStartP struct {
+type TransferBusinessAccountStarsP struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	StarCount            int    `json:"star_count"`
 }
 
-// TransferBusinessAccountStart transfers stars from a business account.
+// TransferBusinessAccountStars transfers stars from a business account.
 // Returns true on success.
-// See https://core.telegram.org/bots/api#transferbusinessaccountstart
+// See https://core.telegram.org/bots/api#transferbusinessaccountstars
-func (api *API) TransferBusinessAccountStart(params TransferBusinessAccountStartP) (bool, error) {
+func (api *API) TransferBusinessAccountStars(params TransferBusinessAccountStarsP) (bool, error) {
-	req := NewRequest[bool]("transferBusinessAccountStart", params)
+	req := NewRequest[bool]("transferBusinessAccountStars", params)
 	return req.Do(api)
 }
 
@@ -270,7 +283,7 @@ func (api *API) UpgradeGift(params UpgradeGiftP) (bool, error) {
 type TransferGiftP struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	OwnedGiftID          string `json:"owned_gift_id"`
-	NewOwnerChatID       int    `json:"new_owner_chat_id"`
+	NewOwnerChatID       int64  `json:"new_owner_chat_id"`
 	StarCount            int    `json:"star_count,omitempty"`
 }
 
@@ -316,7 +329,7 @@ func (api *API) PostStoryVideo(params PostStoryP) (Story, error) {
 // See https://core.telegram.org/bots/api#repoststory
 type RepostStoryP struct {
 	BusinessConnectionID string `json:"business_connection_id"`
-	FromChatID           int    `json:"from_chat_id"`
+	FromChatID           int64  `json:"from_chat_id"`
 	FromStoryID          int    `json:"from_story_id"`
 	ActivePeriod         int    `json:"active_period"`
 	PostToChatPage       bool   `json:"post_to_chat_page,omitempty"`

tgapi/business_types.go

@@ -54,7 +54,7 @@ type BusinessBotRights struct {
 type BusinessConnection struct {
 	ID         string             `json:"id"`
 	User       User               `json:"user"`
-	UserChatID int                `json:"user_chat_id"`
+	UserChatID int64              `json:"user_chat_id"`
 	Date       int                `json:"date"`
 	Rights     *BusinessBotRights `json:"rights,omitempty"`
 	IsEnabled  bool               `json:"is_enabled"`

tgapi/chat_methods.go

@@ -4,7 +4,7 @@ package tgapi
 // See https://core.telegram.org/bots/api#banchatmember
 type BanChatMemberP struct {
 	ChatID         int64 `json:"chat_id"`
-	UserID         int   `json:"user_id"`
+	UserID         int64 `json:"user_id"`
 	UntilDate      int   `json:"until_date,omitempty"`
 	RevokeMessages bool  `json:"revoke_messages,omitempty"`
 }
@@ -21,7 +21,7 @@ func (api *API) BanChatMember(params BanChatMemberP) (bool, error) {
 // See https://core.telegram.org/bots/api#unbanchatmember
 type UnbanChatMemberP struct {
 	ChatID       int64 `json:"chat_id"`
-	UserID       int   `json:"user_id"`
+	UserID       int64 `json:"user_id"`
 	OnlyIfBanned bool  `json:"only_if_banned"`
 }
 
@@ -37,7 +37,7 @@ func (api *API) UnbanChatMember(params UnbanChatMemberP) (bool, error) {
 // See https://core.telegram.org/bots/api#restrictchatmember
 type RestrictChatMemberP struct {
 	ChatID                        int64           `json:"chat_id"`
-	UserID                        int             `json:"user_id"`
+	UserID                        int64           `json:"user_id"`
 	Permissions                   ChatPermissions `json:"permissions"`
 	UseIndependentChatPermissions bool            `json:"use_independent_chat_permissions,omitempty"`
 	UntilDate                     int             `json:"until_date,omitempty"`
@@ -55,7 +55,7 @@ func (api *API) RestrictChatMember(params RestrictChatMemberP) (bool, error) {
 // See https://core.telegram.org/bots/api#promotechatmember
 type PromoteChatMember struct {
 	ChatID      int64 `json:"chat_id"`
-	UserID      int   `json:"user_id"`
+	UserID      int64 `json:"user_id"`
 	IsAnonymous bool  `json:"is_anonymous,omitempty"`
 
 	CanManageChat           bool `json:"can_manage_chat,omitempty"`
@@ -88,7 +88,7 @@ func (api *API) PromoteChatMember(params PromoteChatMember) (bool, error) {
 // See https://core.telegram.org/bots/api#setchatadministratorcustomtitle
 type SetChatAdministratorCustomTitleP struct {
 	ChatID      int64  `json:"chat_id"`
-	UserID      int    `json:"user_id"`
+	UserID      int64  `json:"user_id"`
 	CustomTitle string `json:"custom_title"`
 }
 
@@ -104,7 +104,7 @@ func (api *API) SetChatAdministratorCustomTitle(params SetChatAdministratorCusto
 // See https://core.telegram.org/bots/api#setchatmembertag
 type SetChatMemberTagP struct {
 	ChatID int64  `json:"chat_id"`
-	UserID int    `json:"user_id"`
+	UserID int64  `json:"user_id"`
 	Tag    string `json:"tag,omitempty"`
 }
 
@@ -183,7 +183,7 @@ type CreateChatInviteLinkP struct {
 	Name               *string `json:"name,omitempty"`
 	ExpireDate         int     `json:"expire_date,omitempty"`
 	MemberLimit        int     `json:"member_limit,omitempty"`
-	CreatesJoinRequest int     `json:"creates_join_request,omitempty"`
+	CreatesJoinRequest bool    `json:"creates_join_request,omitempty"`
 }
 
 // CreateChatInviteLink creates an additional invite link for a chat.
@@ -203,7 +203,7 @@ type EditChatInviteLinkP struct {
 	Name               string `json:"name,omitempty"`
 	ExpireDate         int    `json:"expire_date,omitempty"`
 	MemberLimit        int    `json:"member_limit,omitempty"`
-	CreatesJoinRequest int    `json:"creates_join_request,omitempty"`
+	CreatesJoinRequest bool   `json:"creates_join_request,omitempty"`
 }
 
 // EditChatInviteLink edits a non‑primary invite link.
@@ -266,7 +266,7 @@ func (api *API) RevokeChatInviteLink(params RevokeChatInviteLinkP) (ChatInviteLi
 // See https://core.telegram.org/bots/api#approvechatjoinrequest
 type ApproveChatJoinRequestP struct {
 	ChatID int64 `json:"chat_id"`
-	UserID int   `json:"user_id"`
+	UserID int64 `json:"user_id"`
 }
 
 // ApproveChatJoinRequest approves a chat join request.
@@ -281,7 +281,7 @@ func (api *API) ApproveChatJoinRequest(params ApproveChatJoinRequestP) (bool, er
 // See https://core.telegram.org/bots/api#declinechatjoinrequest
 type DeclineChatJoinRequestP struct {
 	ChatID int64 `json:"chat_id"`
-	UserID int   `json:"user_id"`
+	UserID int64 `json:"user_id"`
 }
 
 // DeclineChatJoinRequest declines a chat join request.
@@ -292,13 +292,23 @@ func (api *API) DeclineChatJoinRequest(params DeclineChatJoinRequestP) (bool, er
 	return req.Do(api)
 }
 
-// SetChatPhoto is a stub method (needs implementation).
+// SetChatPhotoP holds parameters for the setChatPhoto method.
-// Currently incomplete.
+// See https://core.telegram.org/bots/api#setchatphoto
-func (api *API) SetChatPhoto() {
+type SetChatPhotoP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// SetChatPhoto changes the chat photo.
+// photo is the file to upload as the new photo.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setchatphoto
+func (api *API) SetChatPhoto(params SetChatPhotoP, photo UploaderFile) (bool, error) {
 	uploader := NewUploader(api)
 	defer func() {
 		_ = uploader.Close()
 	}()
+	req := NewUploaderRequestWithChatID[bool]("setChatPhoto", params, params.ChatID, photo.SetType(UploaderPhotoType))
+	return req.Do(uploader)
 }
 
 // DeleteChatPhotoP holds parameters for the deleteChatPhoto method.
@@ -449,7 +459,7 @@ func (api *API) GetChatMemberCount(params GetChatMembersCountP) (int, error) {
 // See https://core.telegram.org/bots/api#getchatmember
 type GetChatMemberP struct {
 	ChatID int64 `json:"chat_id"`
-	UserID int   `json:"user_id"`
+	UserID int64 `json:"user_id"`
 }
 
 // GetChatMember returns information about a member of a chat.
@@ -492,7 +502,7 @@ func (api *API) DeleteChatStickerSet(params DeleteChatStickerSetP) (bool, error)
 // See https://core.telegram.org/bots/api#getuserchatboosts
 type GetUserChatBoostsP struct {
 	ChatID int64 `json:"chat_id"`
-	UserID int   `json:"user_id"`
+	UserID int64 `json:"user_id"`
 }
 
 // GetUserChatBoosts returns the list of boosts a user has given to a chat.

tgapi/chat_types.go

@@ -26,7 +26,7 @@ const (
 // ChatFullInfo contains full information about a chat.
 // See https://core.telegram.org/bots/api#chatfullinfo
 type ChatFullInfo struct {
-	ID               int        `json:"id"`
+	ID               int64      `json:"id"`
 	Type             ChatType   `json:"type"`
 	Title            string     `json:"title"`
 	Username         string     `json:"username"`
@@ -78,7 +78,7 @@ type ChatFullInfo struct {
 	StickerSetName               *string `json:"sticker_set_name,omitempty"`
 	CanSetStickerSet             *bool   `json:"can_set_sticker_set,omitempty"`
 	CustomEmojiStickerSetName    *string `json:"custom_emoji_sticker_set_name,omitempty"`
-	LinkedChatID                 *int    `json:"linked_chat_id,omitempty"`
+	LinkedChatID                 *int64  `json:"linked_chat_id,omitempty"`
 
 	Location             *ChatLocation     `json:"location,omitempty"`
 	Rating               *UserRating       `json:"rating,omitempty"`
@@ -108,7 +108,7 @@ type ChatPermissions struct {
 	CanSendPolls         bool `json:"can_send_polls"`
 	CanSendOtherMessages bool `json:"can_send_other_messages"`
 	CanAddWebPagePreview bool `json:"can_add_web_page_preview"`
-	CatEditTag           bool `json:"cat_edit_tag"` // Note: field name likely a typo, should be "can_edit_tag"
+	CanEditTag           bool `json:"can_edit_tag"`
 	CanChangeInfo        bool `json:"can_change_info"`
 	CanInviteUsers       bool `json:"can_invite_users"`
 	CanPinMessages       bool `json:"can_pin_messages"`
@@ -127,7 +127,7 @@ type ChatLocation struct {
 type ChatInviteLink struct {
 	InviteLink        string `json:"invite_link"`
 	Creator           User   `json:"creator"`
-	CreateJoinRequest bool   `json:"create_join_request"`
+	CreateJoinRequest bool   `json:"creates_join_request"`
 	IsPrimary         bool   `json:"is_primary"`
 	IsRevoked         bool   `json:"is_revoked"`
 

tgapi/errors.go

@@ -5,3 +5,4 @@ import "errors"
 var ErrRateLimit = errors.New("rate limit exceeded")
 var ErrPoolUnexpected = errors.New("unexpected response from pool")
 var ErrPoolQueueFull = errors.New("worker pool queue full")
+var ErrPoolStopped = errors.New("worker pool stopped")

tgapi/games_methods.go

@@ -0,0 +1,69 @@
+package tgapi
+
+// SendGameP holds parameters for the sendGame method.
+// See https://core.telegram.org/bots/api#sendgame
+type SendGameP struct {
+	BusinessConnectionID string `json:"business_connection_id,omitempty"`
+	ChatID               int64  `json:"chat_id"`
+	MessageThreadID      int    `json:"message_thread_id,omitempty"`
+
+	GameShortName string `json:"game_short_name"`
+
+	DisableNotification bool                  `json:"disable_notification,omitempty"`
+	ProtectContent      bool                  `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool                  `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string                `json:"message_effect_id,omitempty"`
+	ReplyParameters     *ReplyParameters      `json:"reply_parameters,omitempty"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+// SendGame sends a game message.
+// See https://core.telegram.org/bots/api#sendgame
+func (api *API) SendGame(params SendGameP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendGame", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetGameScoreP holds parameters for the setGameScore method.
+// See https://core.telegram.org/bots/api#setgamescore
+type SetGameScoreP struct {
+	UserID             int64  `json:"user_id"`
+	Score              int    `json:"score"`
+	Force              bool   `json:"force,omitempty"`
+	DisableEditMessage bool   `json:"disable_edit_message,omitempty"`
+	ChatID             int64  `json:"chat_id,omitempty"`
+	MessageID          int    `json:"message_id,omitempty"`
+	InlineMessageID    string `json:"inline_message_id,omitempty"`
+}
+
+// SetGameScore sets a user's score in a game message.
+// If inline_message_id is provided, returns a boolean success flag.
+// Otherwise returns the edited Message.
+// See https://core.telegram.org/bots/api#setgamescore
+func (api *API) SetGameScore(params SetGameScoreP) (Message, bool, error) {
+	var zero Message
+	if params.InlineMessageID != "" {
+		req := NewRequestWithChatID[bool]("setGameScore", params, params.ChatID)
+		res, err := req.Do(api)
+		return zero, res, err
+	}
+	req := NewRequestWithChatID[Message]("setGameScore", params, params.ChatID)
+	res, err := req.Do(api)
+	return res, false, err
+}
+
+// GetGameHighScoresP holds parameters for the getGameHighScores method.
+// See https://core.telegram.org/bots/api#getgamehighscores
+type GetGameHighScoresP struct {
+	UserID          int64  `json:"user_id"`
+	ChatID          int64  `json:"chat_id,omitempty"`
+	MessageID       int    `json:"message_id,omitempty"`
+	InlineMessageID string `json:"inline_message_id,omitempty"`
+}
+
+// GetGameHighScores returns game high score data for a user.
+// See https://core.telegram.org/bots/api#getgamehighscores
+func (api *API) GetGameHighScores(params GetGameHighScoresP) ([]GameHighScore, error) {
+	req := NewRequestWithChatID[[]GameHighScore]("getGameHighScores", params, params.ChatID)
+	return req.Do(api)
+}

tgapi/games_types.go

@@ -0,0 +1,9 @@
+package tgapi
+
+// GameHighScore represents one row in a game high score table.
+// See https://core.telegram.org/bots/api#gamehighscore
+type GameHighScore struct {
+	Position int  `json:"position"`
+	User     User `json:"user"`
+	Score    int  `json:"score"`
+}

tgapi/inline_methods.go

@@ -0,0 +1,52 @@
+package tgapi
+
+// AnswerInlineQueryP holds parameters for the answerInlineQuery method.
+// See https://core.telegram.org/bots/api#answerinlinequery
+type AnswerInlineQueryP struct {
+	InlineQueryID string                    `json:"inline_query_id"`
+	Results       []InlineQueryResult       `json:"results"`
+	CacheTime     int                       `json:"cache_time,omitempty"`
+	IsPersonal    bool                      `json:"is_personal,omitempty"`
+	NextOffset    string                    `json:"next_offset,omitempty"`
+	Button        *InlineQueryResultsButton `json:"button,omitempty"`
+}
+
+// AnswerInlineQuery sends answers to an inline query.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#answerinlinequery
+func (api *API) AnswerInlineQuery(params AnswerInlineQueryP) (bool, error) {
+	req := NewRequest[bool]("answerInlineQuery", params)
+	return req.Do(api)
+}
+
+// AnswerWebAppQueryP holds parameters for the answerWebAppQuery method.
+// See https://core.telegram.org/bots/api#answerwebappquery
+type AnswerWebAppQueryP struct {
+	WebAppQueryID string            `json:"web_app_query_id"`
+	Result        InlineQueryResult `json:"result"`
+}
+
+// AnswerWebAppQuery sets the result of a Web App interaction.
+// See https://core.telegram.org/bots/api#answerwebappquery
+func (api *API) AnswerWebAppQuery(params AnswerWebAppQueryP) (SentWebAppMessage, error) {
+	req := NewRequest[SentWebAppMessage]("answerWebAppQuery", params)
+	return req.Do(api)
+}
+
+// SavePreparedInlineMessageP holds parameters for the savePreparedInlineMessage method.
+// See https://core.telegram.org/bots/api#savepreparedinlinemessage
+type SavePreparedInlineMessageP struct {
+	UserID            int64             `json:"user_id"`
+	Result            InlineQueryResult `json:"result"`
+	AllowUserChats    bool              `json:"allow_user_chats,omitempty"`
+	AllowBotChats     bool              `json:"allow_bot_chats,omitempty"`
+	AllowGroupChats   bool              `json:"allow_group_chats,omitempty"`
+	AllowChannelChats bool              `json:"allow_channel_chats,omitempty"`
+}
+
+// SavePreparedInlineMessage stores a prepared message for Mini App users.
+// See https://core.telegram.org/bots/api#savepreparedinlinemessage
+func (api *API) SavePreparedInlineMessage(params SavePreparedInlineMessageP) (PreparedInlineMessage, error) {
+	req := NewRequest[PreparedInlineMessage]("savePreparedInlineMessage", params)
+	return req.Do(api)
+}

tgapi/inline_types.go

@@ -0,0 +1,26 @@
+package tgapi
+
+// InlineQueryResult is a JSON-serializable inline query result object.
+// See https://core.telegram.org/bots/api#inlinequeryresult
+type InlineQueryResult map[string]any
+
+// InlineQueryResultsButton represents a button shown above inline query results.
+// See https://core.telegram.org/bots/api#inlinequeryresultsbutton
+type InlineQueryResultsButton struct {
+	Text           string      `json:"text"`
+	WebApp         *WebAppInfo `json:"web_app,omitempty"`
+	StartParameter string      `json:"start_parameter,omitempty"`
+}
+
+// SentWebAppMessage describes an inline message sent by a Web App on behalf of a user.
+// See https://core.telegram.org/bots/api#sentwebappmessage
+type SentWebAppMessage struct {
+	InlineMessageID string `json:"inline_message_id,omitempty"`
+}
+
+// PreparedInlineMessage describes a prepared inline message.
+// See https://core.telegram.org/bots/api#preparedinlinemessage
+type PreparedInlineMessage struct {
+	ID             string `json:"id"`
+	ExpirationDate int    `json:"expiration_date"`
+}

tgapi/messages_methods.go

@@ -12,7 +12,7 @@ type SendMessageP struct {
 	ParseMode            ParseMode           `json:"parse_mode,omitempty"`
 	Entities             []MessageEntity     `json:"entities,omitempty"`
 	LinkPreviewOptions   *LinkPreviewOptions `json:"link_preview_options,omitempty"`
-	DisableNotifications bool                `json:"disable_notifications,omitempty"`
+	DisableNotifications bool                `json:"disable_notification,omitempty"`
 	ProtectContent       bool                `json:"protect_content,omitempty"`
 	AllowPaidBroadcast   bool                `json:"allow_paid_broadcast,omitempty"`
 	MessageEffectID      string              `json:"message_effect_id,omitempty"`
@@ -69,8 +69,8 @@ type ForwardMessagesP struct {
 // ForwardMessages forwards multiple messages.
 // Returns an array of message IDs of the sent messages.
 // See https://core.telegram.org/bots/api#forwardmessages
-func (api *API) ForwardMessages(params ForwardMessagesP) ([]int, error) {
+func (api *API) ForwardMessages(params ForwardMessagesP) ([]MessageID, error) {
-	req := NewRequestWithChatID[[]int]("forwardMessages", params, params.ChatID)
+	req := NewRequestWithChatID[[]MessageID]("forwardMessages", params, params.ChatID)
 	return req.Do(api)
 }
 
@@ -103,8 +103,11 @@ type CopyMessageP struct {
 // Returns the MessageID of the sent copy.
 // See https://core.telegram.org/bots/api#copymessage
 func (api *API) CopyMessage(params CopyMessageP) (int, error) {
-	req := NewRequestWithChatID[int]("copyMessage", params, params.ChatID)
+	msgID, err := NewRequestWithChatID[MessageID]("copyMessage", params, params.ChatID).Do(api)
-	return req.Do(api)
+	if err != nil {
+		return 0, err
+	}
+	return msgID.MessageID, nil
 }
 
 // CopyMessagesP holds parameters for the copyMessages method.
@@ -124,18 +127,18 @@ type CopyMessagesP struct {
 // CopyMessages copies multiple messages.
 // Returns an array of message IDs of the sent copies.
 // See https://core.telegram.org/bots/api#copymessages
-func (api *API) CopyMessages(params CopyMessagesP) ([]int, error) {
+func (api *API) CopyMessages(params CopyMessagesP) ([]MessageID, error) {
-	req := NewRequestWithChatID[[]int]("copyMessages", params, params.ChatID)
+	req := NewRequestWithChatID[[]MessageID]("copyMessages", params, params.ChatID)
 	return req.Do(api)
 }
 
 // SendLocationP holds parameters for the sendLocation method.
 // See https://core.telegram.org/bots/api#sendlocation
 type SendLocationP struct {
-	BusinessConnectionID  int   `json:"business_connection_id,omitempty"`
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
-	ChatID                int64 `json:"chat_id"`
+	ChatID                int64  `json:"chat_id"`
-	MessageThreadID       int   `json:"message_thread_id,omitempty"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
-	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
 
 	Latitude             float64 `json:"latitude"`
 	Longitude            float64 `json:"longitude"`
@@ -164,10 +167,10 @@ func (api *API) SendLocation(params SendLocationP) (Message, error) {
 // SendVenueP holds parameters for the sendVenue method.
 // See https://core.telegram.org/bots/api#sendvenue
 type SendVenueP struct {
-	BusinessConnectionID  int   `json:"business_connection_id,omitempty"`
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
-	ChatID                int64 `json:"chat_id"`
+	ChatID                int64  `json:"chat_id"`
-	MessageThreadID       int   `json:"message_thread_id,omitempty"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
-	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
 
 	Latitude        float64 `json:"latitude"`
 	Longitude       float64 `json:"longitude"`
@@ -198,10 +201,10 @@ func (api *API) SendVenue(params SendVenueP) (Message, error) {
 // SendContactP holds parameters for the sendContact method.
 // See https://core.telegram.org/bots/api#sendcontact
 type SendContactP struct {
-	BusinessConnectionID  int   `json:"business_connection_id,omitempty"`
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
-	ChatID                int64 `json:"chat_id"`
+	ChatID                int64  `json:"chat_id"`
-	MessageThreadID       int   `json:"message_thread_id,omitempty"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
-	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
 
 	PhoneNumber string `json:"phone_number"`
 	FirstName   string `json:"first_name"`
@@ -228,12 +231,12 @@ func (api *API) SendContact(params SendContactP) (Message, error) {
 // SendPollP holds parameters for the sendPoll method.
 // See https://core.telegram.org/bots/api#sendpoll
 type SendPollP struct {
-	BusinessConnectionID int   `json:"business_connection_id,omitempty"`
+	BusinessConnectionID string `json:"business_connection_id,omitempty"`
-	ChatID               int64 `json:"chat_id"`
+	ChatID               int64  `json:"chat_id"`
-	MessageThreadID      int   `json:"message_thread_id,omitempty"`
+	MessageThreadID      int    `json:"message_thread_id,omitempty"`
 
 	Question              string            `json:"question"`
-	QuestionParseMode     ParseMode         `json:"question_mode,omitempty"`
+	QuestionParseMode     ParseMode         `json:"question_parse_mode,omitempty"`
 	QuestionEntities      []MessageEntity   `json:"question_entities,omitempty"`
 	Options               []InputPollOption `json:"options"`
 	IsAnonymous           bool              `json:"is_anonymous,omitempty"`
@@ -266,7 +269,7 @@ func (api *API) SendPoll(params SendPollP) (Message, error) {
 // SendChecklistP holds parameters for the sendChecklist method.
 // See https://core.telegram.org/bots/api#sendchecklist
 type SendChecklistP struct {
-	BusinessConnectionID int            `json:"business_connection_id"`
+	BusinessConnectionID string         `json:"business_connection_id"`
 	ChatID               int64          `json:"chat_id"`
 	Checklist            InputChecklist `json:"checklist"`
 
@@ -288,10 +291,10 @@ func (api *API) SendChecklist(params SendChecklistP) (Message, error) {
 // SendDiceP holds parameters for the sendDice method.
 // See https://core.telegram.org/bots/api#senddice
 type SendDiceP struct {
-	BusinessConnectionID  int   `json:"business_connection_id,omitempty"`
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
-	ChatID                int64 `json:"chat_id"`
+	ChatID                int64  `json:"chat_id"`
-	MessageThreadID       int   `json:"message_thread_id,omitempty"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
-	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
 
 	Emoji string `json:"emoji,omitempty"`
 
@@ -313,6 +316,7 @@ func (api *API) SendDice(params SendDiceP) (Message, error) {
 }
 
 // SendMessageDraftP holds parameters for the sendMessageDraft method.
+// See https://core.telegram.org/bots/api#sendmessagedraft
 type SendMessageDraftP struct {
 	ChatID          int64           `json:"chat_id"`
 	MessageThreadID int             `json:"message_thread_id,omitempty"`
@@ -322,7 +326,9 @@ type SendMessageDraftP struct {
 	Entities        []MessageEntity `json:"entities,omitempty"`
 }
 
-// SendMessageDraft sends a previously saved draft message.
+// SendMessageDraft sends or updates a draft message in the target chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#sendmessagedraft
 func (api *API) SendMessageDraft(params SendMessageDraftP) (bool, error) {
 	req := NewRequestWithChatID[bool]("sendMessageDraft", params, params.ChatID)
 	return req.Do(api)
@@ -425,7 +431,7 @@ type EditMessageMediaP struct {
 	ChatID               int64                 `json:"chat_id,omitempty"`
 	MessageID            int                   `json:"message_id,omitempty"`
 	InlineMessageID      string                `json:"inline_message_id,omitempty"`
-	Message              InputMedia            `json:"message"`
+	Media                InputMedia            `json:"media"`
 	ReplyMarkup          *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
 }
 

tgapi/messages_types.go

@@ -2,6 +2,11 @@ package tgapi
 
 import "git.nix13.pw/scuroneko/extypes"
 
+// MessageID represents a message identifier wrapper returned by some API methods.
+type MessageID struct {
+	MessageID int `json:"message_id"`
+}
+
 // MessageReplyMarkup represents an inline keyboard markup for a message.
 // It is used in the Message type.
 type MessageReplyMarkup struct {
@@ -113,8 +118,8 @@ type MessageEntity struct {
 // ReplyParameters describes the parameters to use when replying to a message.
 // See https://core.telegram.org/bots/api#replyparameters
 type ReplyParameters struct {
-	MessageID int `json:"message_id"`
+	MessageID int   `json:"message_id"`
-	ChatID    int `json:"chat_id,omitempty"`
+	ChatID    int64 `json:"chat_id,omitempty"`
 
 	AllowSendingWithoutReply bool             `json:"allow_sending_without_reply,omitempty"`
 	Quote                    string           `json:"quote,omitempty"`
@@ -179,11 +184,13 @@ type ReplyKeyboardMarkup struct {
 // CallbackQuery represents an incoming callback query from a callback button in an inline keyboard.
 // See https://core.telegram.org/bots/api#callbackquery
 type CallbackQuery struct {
-	ID      string  `json:"id"`
+	ID              string   `json:"id"`
-	From    User    `json:"from"`
+	From            User     `json:"from"`
-	Message Message `json:"message"`
+	Message         *Message `json:"message,omitempty"`
-
+	InlineMessageID *string  `json:"inline_message_id,omitempty"`
-	Data string `json:"data"`
+	ChatInstance    string   `json:"chat_instance,omitempty"`
+	Data            string   `json:"data,omitempty"`
+	GameShortName   string   `json:"game_short_name,omitempty"`
 }
 
 // InputPollOption contains information about one answer option in a poll to be sent.

tgapi/methods.go

@@ -6,26 +6,6 @@ import (
 	"net/http"
 )
 
-// ParseMode represents the text formatting mode for message parsing.
-type ParseMode string
-
-const (
-	// ParseMDV2 enables MarkdownV2 style parsing.
-	ParseMDV2 ParseMode = "MarkdownV2"
-	// ParseHTML enables HTML style parsing.
-	ParseHTML ParseMode = "HTML"
-	// ParseMD enables legacy Markdown style parsing.
-	ParseMD ParseMode = "Markdown"
-	// ParseNone disables any parsing.
-	ParseNone ParseMode = "None"
-)
-
-// EmptyParams is a placeholder for methods that take no parameters.
-type EmptyParams struct{}
-
-// NoParams is a convenient instance of EmptyParams.
-var NoParams = EmptyParams{}
-
 // UpdateParams holds parameters for the getUpdates method.
 // See https://core.telegram.org/bots/api#getupdates
 type UpdateParams struct {
@@ -65,6 +45,47 @@ func (api *API) GetUpdates(params UpdateParams) ([]Update, error) {
 	return req.Do(api)
 }
 
+// SetWebhookP holds parameters for the setWebhook method.
+// See https://core.telegram.org/bots/api#setwebhook
+type SetWebhookP struct {
+	URL                string       `json:"url"`
+	Certificate        string       `json:"certificate,omitempty"`
+	IPAddress          string       `json:"ip_address,omitempty"`
+	MaxConnections     int          `json:"max_connections,omitempty"`
+	AllowedUpdates     []UpdateType `json:"allowed_updates,omitempty"`
+	DropPendingUpdates bool         `json:"drop_pending_updates,omitempty"`
+	SecretToken        string       `json:"secret_token,omitempty"`
+}
+
+// SetWebhook sets a webhook URL for incoming updates.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setwebhook
+func (api *API) SetWebhook(params SetWebhookP) (bool, error) {
+	req := NewRequest[bool]("setWebhook", params)
+	return req.Do(api)
+}
+
+// DeleteWebhookP holds parameters for the deleteWebhook method.
+// See https://core.telegram.org/bots/api#deletewebhook
+type DeleteWebhookP struct {
+	DropPendingUpdates bool `json:"drop_pending_updates,omitempty"`
+}
+
+// DeleteWebhook removes the current webhook integration.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#deletewebhook
+func (api *API) DeleteWebhook(params DeleteWebhookP) (bool, error) {
+	req := NewRequest[bool]("deleteWebhook", params)
+	return req.Do(api)
+}
+
+// GetWebhookInfo returns the current webhook status.
+// See https://core.telegram.org/bots/api#getwebhookinfo
+func (api *API) GetWebhookInfo() (WebhookInfo, error) {
+	req := NewRequest[WebhookInfo]("getWebhookInfo", NoParams)
+	return req.Do(api)
+}
+
 // GetFileP holds parameters for the getFile method.
 // See https://core.telegram.org/bots/api#getfile
 type GetFileP struct {

tgapi/methods_types.go

@@ -0,0 +1,35 @@
+package tgapi
+
+// ParseMode represents the text formatting mode for message parsing.
+type ParseMode string
+
+const (
+	// ParseMDV2 enables MarkdownV2 style parsing.
+	ParseMDV2 ParseMode = "MarkdownV2"
+	// ParseHTML enables HTML style parsing.
+	ParseHTML ParseMode = "HTML"
+	// ParseMD enables legacy Markdown style parsing.
+	ParseMD ParseMode = "Markdown"
+	// ParseNone disables any parsing.
+	ParseNone ParseMode = "None"
+)
+
+// EmptyParams is a placeholder for methods that take no parameters.
+type EmptyParams struct{}
+
+// NoParams is a convenient instance of EmptyParams.
+var NoParams = EmptyParams{}
+
+// WebhookInfo describes the current webhook status.
+// See https://core.telegram.org/bots/api#webhookinfo
+type WebhookInfo struct {
+	URL                          string   `json:"url"`
+	HasCustomCertificate         bool     `json:"has_custom_certificate"`
+	PendingUpdateCount           int      `json:"pending_update_count"`
+	IPAddress                    string   `json:"ip_address,omitempty"`
+	LastErrorDate                int      `json:"last_error_date,omitempty"`
+	LastErrorMessage             string   `json:"last_error_message,omitempty"`
+	LastSynchronizationErrorDate int      `json:"last_synchronization_error_date,omitempty"`
+	MaxConnections               int      `json:"max_connections,omitempty"`
+	AllowedUpdates               []string `json:"allowed_updates,omitempty"`
+}

tgapi/passport_methods.go

@@ -0,0 +1,16 @@
+package tgapi
+
+// SetPassportDataErrorsP holds parameters for the setPassportDataErrors method.
+// See https://core.telegram.org/bots/api#setpassportdataerrors
+type SetPassportDataErrorsP struct {
+	UserID int64                  `json:"user_id"`
+	Errors []PassportElementError `json:"errors"`
+}
+
+// SetPassportDataErrors informs a user about Telegram Passport data errors.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setpassportdataerrors
+func (api *API) SetPassportDataErrors(params SetPassportDataErrorsP) (bool, error) {
+	req := NewRequest[bool]("setPassportDataErrors", params)
+	return req.Do(api)
+}

tgapi/passport_types.go

@@ -0,0 +1,5 @@
+package tgapi
+
+// PassportElementError is a JSON-serializable passport element error object.
+// See https://core.telegram.org/bots/api#passportelementerror
+type PassportElementError map[string]any

tgapi/payments_methods.go

@@ -0,0 +1,117 @@
+package tgapi
+
+// SendInvoiceP holds parameters for the sendInvoice method.
+// See https://core.telegram.org/bots/api#sendinvoice
+type SendInvoiceP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Title         string         `json:"title"`
+	Description   string         `json:"description"`
+	Payload       string         `json:"payload"`
+	ProviderToken string         `json:"provider_token,omitempty"`
+	Currency      string         `json:"currency"`
+	Prices        []LabeledPrice `json:"prices"`
+
+	MaxTipAmount        int    `json:"max_tip_amount,omitempty"`
+	SuggestedTipAmounts []int  `json:"suggested_tip_amounts,omitempty"`
+	StartParameter      string `json:"start_parameter,omitempty"`
+	ProviderData        string `json:"provider_data,omitempty"`
+	PhotoURL            string `json:"photo_url,omitempty"`
+	PhotoSize           int    `json:"photo_size,omitempty"`
+	PhotoWidth          int    `json:"photo_width,omitempty"`
+	PhotoHeight         int    `json:"photo_height,omitempty"`
+	NeedName            bool   `json:"need_name,omitempty"`
+	NeedPhoneNumber     bool   `json:"need_phone_number,omitempty"`
+	NeedEmail           bool   `json:"need_email,omitempty"`
+	NeedShippingAddress bool   `json:"need_shipping_address,omitempty"`
+	SendPhoneToProvider bool   `json:"send_phone_number_to_provider,omitempty"`
+	SendEmailToProvider bool   `json:"send_email_to_provider,omitempty"`
+	IsFlexible          bool   `json:"is_flexible,omitempty"`
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *InlineKeyboardMarkup    `json:"reply_markup,omitempty"`
+}
+
+// SendInvoice sends an invoice.
+// See https://core.telegram.org/bots/api#sendinvoice
+func (api *API) SendInvoice(params SendInvoiceP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendInvoice", params, params.ChatID)
+	return req.Do(api)
+}
+
+// CreateInvoiceLinkP holds parameters for the createInvoiceLink method.
+// See https://core.telegram.org/bots/api#createinvoicelink
+type CreateInvoiceLinkP struct {
+	BusinessConnectionID string `json:"business_connection_id,omitempty"`
+
+	Title         string         `json:"title"`
+	Description   string         `json:"description"`
+	Payload       string         `json:"payload"`
+	ProviderToken string         `json:"provider_token,omitempty"`
+	Currency      string         `json:"currency"`
+	Prices        []LabeledPrice `json:"prices"`
+
+	SubscriptionPeriod  int    `json:"subscription_period,omitempty"`
+	MaxTipAmount        int    `json:"max_tip_amount,omitempty"`
+	SuggestedTipAmounts []int  `json:"suggested_tip_amounts,omitempty"`
+	ProviderData        string `json:"provider_data,omitempty"`
+	PhotoURL            string `json:"photo_url,omitempty"`
+	PhotoSize           int    `json:"photo_size,omitempty"`
+	PhotoWidth          int    `json:"photo_width,omitempty"`
+	PhotoHeight         int    `json:"photo_height,omitempty"`
+	NeedName            bool   `json:"need_name,omitempty"`
+	NeedPhoneNumber     bool   `json:"need_phone_number,omitempty"`
+	NeedEmail           bool   `json:"need_email,omitempty"`
+	NeedShippingAddress bool   `json:"need_shipping_address,omitempty"`
+	SendPhoneToProvider bool   `json:"send_phone_number_to_provider,omitempty"`
+	SendEmailToProvider bool   `json:"send_email_to_provider,omitempty"`
+	IsFlexible          bool   `json:"is_flexible,omitempty"`
+}
+
+// CreateInvoiceLink creates an invoice link.
+// See https://core.telegram.org/bots/api#createinvoicelink
+func (api *API) CreateInvoiceLink(params CreateInvoiceLinkP) (string, error) {
+	req := NewRequest[string]("createInvoiceLink", params)
+	return req.Do(api)
+}
+
+// AnswerShippingQueryP holds parameters for the answerShippingQuery method.
+// See https://core.telegram.org/bots/api#answershippingquery
+type AnswerShippingQueryP struct {
+	ShippingQueryID string           `json:"shipping_query_id"`
+	OK              bool             `json:"ok"`
+	ShippingOptions []ShippingOption `json:"shipping_options,omitempty"`
+	ErrorMessage    string           `json:"error_message,omitempty"`
+}
+
+// AnswerShippingQuery answers a shipping query.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#answershippingquery
+func (api *API) AnswerShippingQuery(params AnswerShippingQueryP) (bool, error) {
+	req := NewRequest[bool]("answerShippingQuery", params)
+	return req.Do(api)
+}
+
+// AnswerPreCheckoutQueryP holds parameters for the answerPreCheckoutQuery method.
+// See https://core.telegram.org/bots/api#answerprecheckoutquery
+type AnswerPreCheckoutQueryP struct {
+	PreCheckoutQueryID string `json:"pre_checkout_query_id"`
+	OK                 bool   `json:"ok"`
+	ErrorMessage       string `json:"error_message,omitempty"`
+}
+
+// AnswerPreCheckoutQuery answers a pre-checkout query.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#answerprecheckoutquery
+func (api *API) AnswerPreCheckoutQuery(params AnswerPreCheckoutQueryP) (bool, error) {
+	req := NewRequest[bool]("answerPreCheckoutQuery", params)
+	return req.Do(api)
+}

tgapi/payments_types.go

@@ -0,0 +1,16 @@
+package tgapi
+
+// LabeledPrice represents a price portion.
+// See https://core.telegram.org/bots/api#labeledprice
+type LabeledPrice struct {
+	Label  string `json:"label"`
+	Amount int    `json:"amount"`
+}
+
+// ShippingOption represents one shipping option.
+// See https://core.telegram.org/bots/api#shippingoption
+type ShippingOption struct {
+	ID     string         `json:"id"`
+	Title  string         `json:"title"`
+	Prices []LabeledPrice `json:"prices"`
+}

tgapi/pool.go

@@ -14,13 +14,16 @@ type workerPool struct {
 	workers   int                  // количество воркеров (горутин)
 	wg        sync.WaitGroup       // синхронизирует завершение всех воркеров при остановке
 	quit      chan struct{}        // канал для сигнала остановки
+	stopOnce  sync.Once            // гарантирует идемпотентную остановку пула
 	started   bool                 // флаг, указывающий, запущен ли пул
+	stopped   bool                 // флаг, указывающий, что пул остановлен
 	startedMu sync.Mutex           // мьютекс для безопасного доступа к started
 }
 
 // requestEnvelope — приватная структура, инкапсулирующая задачу и канал для результата.
 // Используется только внутри пакета для передачи задач воркерам.
 type requestEnvelope struct {
+	ctx      context.Context                    // контекст конкретной задачи
 	doFunc   func(context.Context) (any, error) // функция, выполняющая запрос
 	resultCh chan requestResult                 // канал, через который воркер вернёт результат
 }
@@ -53,7 +56,7 @@ func newWorkerPool(workers int, queueSize int) *workerPool {
 // start запускает воркеры (горутины), которые будут обрабатывать задачи из очереди.
 // Метод идемпотентен: если пул уже запущен — ничего не делает.
 // Должен вызываться перед первым вызовом submit.
-func (p *workerPool) start(ctx context.Context) {
+func (p *workerPool) start() {
 	p.startedMu.Lock()
 	defer p.startedMu.Unlock()
 	if p.started {
@@ -64,7 +67,7 @@ func (p *workerPool) start(ctx context.Context) {
 	// Запускаем воркеры — каждый будет обрабатывать задачи в бесконечном цикле
 	for i := 0; i < p.workers; i++ {
 		p.wg.Add(1)
-		go p.worker(ctx) // запускаем горутину с контекстом
+		go p.worker() // запускаем горутину
 	}
 }
 
@@ -72,8 +75,15 @@ func (p *workerPool) start(ctx context.Context) {
 // Отправляет сигнал остановки через quit-канал и ждёт завершения всех активных задач.
 // Безопасно вызывать многократно — после остановки повторные вызовы не имеют эффекта.
 func (p *workerPool) stop() {
-	close(p.quit) // сигнал для всех воркеров — выйти из цикла
+	p.stopOnce.Do(func() {
-	p.wg.Wait()   // ждём, пока все воркеры завершатся
+		p.startedMu.Lock()
+		p.stopped = true
+		p.started = false
+		close(p.quit) // сигнал для всех воркеров — выйти из цикла
+		p.startedMu.Unlock()
+
+		p.wg.Wait() // ждём, пока все воркеры завершатся
+	})
 }
 
 // submit отправляет задачу в очередь и возвращает канал, через который будет получен результат.
@@ -81,8 +91,15 @@ func (p *workerPool) stop() {
 // Канал результата имеет буфер 1, чтобы не блокировать воркера при записи.
 // Контекст используется для отмены задачи, если клиент отменил запрос до отправки.
 func (p *workerPool) submit(ctx context.Context, do func(context.Context) (any, error)) (<-chan requestResult, error) {
+	p.startedMu.Lock()
+	if p.stopped || !p.started {
+		p.startedMu.Unlock()
+		return nil, ErrPoolStopped
+	}
+
 	// Проверяем, не превышена ли очередь
 	if len(p.taskCh) >= p.queueSize {
+		p.startedMu.Unlock()
 		return nil, ErrPoolQueueFull
 	}
 
@@ -91,6 +108,7 @@ func (p *workerPool) submit(ctx context.Context, do func(context.Context) (any,
 
 	// Создаём обёртку задачи
 	envelope := requestEnvelope{
+		ctx:      ctx,
 		doFunc:   do,
 		resultCh: resultCh,
 	}
@@ -98,12 +116,15 @@ func (p *workerPool) submit(ctx context.Context, do func(context.Context) (any,
 	// Пытаемся отправить задачу в очередь
 	select {
 	case <-ctx.Done():
+		p.startedMu.Unlock()
 		// Клиент отменил операцию до отправки — возвращаем ошибку отмены
 		return nil, ctx.Err()
 	case p.taskCh <- envelope:
+		p.startedMu.Unlock()
 		// Успешно отправлено — возвращаем канал для чтения результата
 		return resultCh, nil
 	default:
+		p.startedMu.Unlock()
 		// Очередь переполнена — не должно происходить при проверке len(p.taskCh), но на всякий случай
 		return nil, ErrPoolQueueFull
 	}
@@ -117,26 +138,38 @@ func (p *workerPool) submit(ctx context.Context, do func(context.Context) (any,
 //   - закрывает канал, чтобы клиент мог прочитать и завершить
 //
 // После закрытия quit-канала — воркер завершает работу.
-func (p *workerPool) worker(ctx context.Context) {
+func (p *workerPool) worker() {
 	defer p.wg.Done() // уменьшаем WaitGroup при завершении горутины
 
 	for {
 		select {
 		case <-p.quit:
-			// Получен сигнал остановки — выходим из цикла
+			// Получен сигнал остановки — дренируем очередь и выходим.
-			return
+			// После stop() новые задачи не принимаются.
+			for {
+				select {
+				case envelope := <-p.taskCh:
+					p.executeEnvelope(envelope)
+				default:
+					return
+				}
+			}
 
 		case envelope := <-p.taskCh:
-			// Выполняем задачу с переданным контекстом (клиентский или общий)
+			p.executeEnvelope(envelope)
-			value, err := envelope.doFunc(ctx)
-
-			// Записываем результат в канал — не блокируем, т.к. буфер 1
-			envelope.resultCh <- requestResult{
-				value: value,
-				err:   err,
-			}
-			// Закрываем канал — клиент знает, что результат пришёл и больше не будет
-			close(envelope.resultCh)
 		}
 	}
 }
+
+func (p *workerPool) executeEnvelope(envelope requestEnvelope) {
+	// Выполняем задачу с переданным контекстом (клиентский или общий)
+	value, err := envelope.doFunc(envelope.ctx)
+
+	// Записываем результат в канал — не блокируем, т.к. буфер 1
+	envelope.resultCh <- requestResult{
+		value: value,
+		err:   err,
+	}
+	// Закрываем канал — клиент знает, что результат пришёл и больше не будет
+	close(envelope.resultCh)
+}

tgapi/stars_methods.go

@@ -0,0 +1,53 @@
+package tgapi
+
+// GetStarTransactionsP holds parameters for the getStarTransactions method.
+// See https://core.telegram.org/bots/api#getstartransactions
+type GetStarTransactionsP struct {
+	Offset int `json:"offset,omitempty"`
+	Limit  int `json:"limit,omitempty"`
+}
+
+// GetMyStarBalance returns the bot's Telegram Star balance.
+// See https://core.telegram.org/bots/api#getmystarbalance
+func (api *API) GetMyStarBalance() (StarAmount, error) {
+	req := NewRequest[StarAmount]("getMyStarBalance", NoParams)
+	return req.Do(api)
+}
+
+// GetStarTransactions returns Telegram Star transactions for the bot.
+// See https://core.telegram.org/bots/api#getstartransactions
+func (api *API) GetStarTransactions(params GetStarTransactionsP) (StarTransactions, error) {
+	req := NewRequest[StarTransactions]("getStarTransactions", params)
+	return req.Do(api)
+}
+
+// RefundStarPaymentP holds parameters for the refundStarPayment method.
+// See https://core.telegram.org/bots/api#refundstarpayment
+type RefundStarPaymentP struct {
+	UserID                  int64  `json:"user_id"`
+	TelegramPaymentChargeID string `json:"telegram_payment_charge_id"`
+}
+
+// RefundStarPayment refunds a successful Telegram Stars payment.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#refundstarpayment
+func (api *API) RefundStarPayment(params RefundStarPaymentP) (bool, error) {
+	req := NewRequest[bool]("refundStarPayment", params)
+	return req.Do(api)
+}
+
+// EditUserStarSubscriptionP holds parameters for the editUserStarSubscription method.
+// See https://core.telegram.org/bots/api#edituserstarsubscription
+type EditUserStarSubscriptionP struct {
+	UserID                  int64  `json:"user_id"`
+	TelegramPaymentChargeID string `json:"telegram_payment_charge_id"`
+	IsCanceled              bool   `json:"is_canceled"`
+}
+
+// EditUserStarSubscription cancels or re-enables a user star subscription extension.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#edituserstarsubscription
+func (api *API) EditUserStarSubscription(params EditUserStarSubscriptionP) (bool, error) {
+	req := NewRequest[bool]("editUserStarSubscription", params)
+	return req.Do(api)
+}

tgapi/stars_types.go

@@ -0,0 +1,18 @@
+package tgapi
+
+// StarTransaction describes a Telegram Star transaction.
+// See https://core.telegram.org/bots/api#startransaction
+type StarTransaction struct {
+	ID             string         `json:"id"`
+	Amount         int            `json:"amount"`
+	NanostarAmount int            `json:"nanostar_amount,omitempty"`
+	Date           int            `json:"date"`
+	Source         map[string]any `json:"source,omitempty"`
+	Receiver       map[string]any `json:"receiver,omitempty"`
+}
+
+// StarTransactions contains a list of Telegram Star transactions.
+// See https://core.telegram.org/bots/api#startransactions
+type StarTransactions struct {
+	Transactions []StarTransaction `json:"transactions"`
+}

tgapi/stickers_methods.go

@@ -49,10 +49,29 @@ func (api *API) GetCustomEmojiStickers(params GetCustomEmojiStickersP) ([]Sticke
 	return req.Do(api)
 }
 
+// UploadStickerFileP holds parameters for the uploadStickerFile method.
+// See https://core.telegram.org/bots/api#uploadstickerfile
+type UploadStickerFileP struct {
+	UserID        int64              `json:"user_id"`
+	StickerFormat InputStickerFormat `json:"sticker_format"`
+}
+
+// UploadStickerFile uploads a sticker file for later use in sticker set methods.
+// sticker is the file to upload.
+// See https://core.telegram.org/bots/api#uploadstickerfile
+func (api *API) UploadStickerFile(params UploadStickerFileP, sticker UploaderFile) (File, error) {
+	uploader := NewUploader(api)
+	defer func() {
+		_ = uploader.Close()
+	}()
+	req := NewUploaderRequest[File]("uploadStickerFile", params, sticker.SetType(UploaderStickerType))
+	return req.Do(uploader)
+}
+
 // CreateNewStickerSetP holds parameters for the createNewStickerSet method.
 // See https://core.telegram.org/bots/api#createnewstickerset
 type CreateNewStickerSetP struct {
-	UserID int    `json:"user_id"`
+	UserID int64  `json:"user_id"`
 	Name   string `json:"name"`
 	Title  string `json:"title"`
 
@@ -72,7 +91,7 @@ func (api *API) CreateNewStickerSet(params CreateNewStickerSetP) (bool, error) {
 // AddStickerToSetP holds parameters for the addStickerToSet method.
 // See https://core.telegram.org/bots/api#addstickertoset
 type AddStickerToSetP struct {
-	UserID  int          `json:"user_id"`
+	UserID  int64        `json:"user_id"`
 	Name    string       `json:"name"`
 	Sticker InputSticker `json:"sticker"`
 }
@@ -117,7 +136,7 @@ func (api *API) DeleteStickerFromSet(params DeleteStickerFromSetP) (bool, error)
 // ReplaceStickerInSetP holds parameters for the replaceStickerInSet method.
 // See https://core.telegram.org/bots/api#replacestickerinset
 type ReplaceStickerInSetP struct {
-	UserID     int          `json:"user_id"`
+	UserID     int64        `json:"user_id"`
 	Name       string       `json:"name"`
 	OldSticker string       `json:"old_sticker"`
 	Sticker    InputSticker `json:"sticker"`
@@ -195,7 +214,7 @@ func (api *API) SetStickerSetTitle(params SetStickerSetTitleP) (bool, error) {
 // See https://core.telegram.org/bots/api#setstickersetthumbnail
 type SetStickerSetThumbnailP struct {
 	Name      string             `json:"name"`
-	UserID    int                `json:"user_id"`
+	UserID    int64              `json:"user_id"`
 	Thumbnail string             `json:"thumbnail"`
 	Format    InputStickerFormat `json:"format"`
 }
@@ -218,9 +237,7 @@ type SetCustomEmojiStickerSetThumbnailP struct {
 // SetCustomEmojiStickerSetThumbnail sets the thumbnail of a custom emoji sticker set.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setcustomemojistickersetthumbnail
-//
+func (api *API) SetCustomEmojiStickerSetThumbnail(params SetCustomEmojiStickerSetThumbnailP) (bool, error) {
-// Note: This method uses SetStickerSetThumbnailP as its parameter type, which might be inconsistent.
-func (api *API) SetCustomEmojiStickerSetThumbnail(params SetStickerSetThumbnailP) (bool, error) {
 	req := NewRequest[bool]("setCustomEmojiStickerSetThumbnail", params)
 	return req.Do(api)
 }

tgapi/stickers_types.go

@@ -52,7 +52,7 @@ type Sticker struct {
 	MaskPosition   *MaskPosition `json:"mask_position,omitempty"`
 	CustomEmojiID  *string       `json:"custom_emoji_id,omitempty"`
 	NeedRepainting *bool         `json:"need_repainting,omitempty"`
-	FileSize       *int          `json:"file_size,omitempty"`
+	FileSize       *int64        `json:"file_size,omitempty"`
 }
 
 // StickerSet represents a sticker set.

tgapi/types.go

@@ -1,6 +1,6 @@
 package tgapi
 
-// UpdateType represents the type of an incoming update.
+// UpdateType represents the type of incoming update.
 type UpdateType string
 
 const (
@@ -160,7 +160,7 @@ type PaidMediaPurchased struct {
 type File struct {
 	FileId       string `json:"file_id"`
 	FileUniqueID string `json:"file_unique_id"`
-	FileSize     int    `json:"file_size,omitempty"`
+	FileSize     int64  `json:"file_size,omitempty"`
 	FilePath     string `json:"file_path,omitempty"`
 }
 
@@ -175,7 +175,7 @@ type Audio struct {
 	Title     string     `json:"title,omitempty"`
 	FileName  string     `json:"file_name,omitempty"`
 	MimeType  string     `json:"mime_type,omitempty"`
-	FileSize  int        `json:"file_size,omitempty"`
+	FileSize  int64      `json:"file_size,omitempty"`
 	Thumbnail *PhotoSize `json:"thumbnail,omitempty"`
 }
 
@@ -234,7 +234,7 @@ type ChatMemberUpdated struct {
 type ChatJoinRequest struct {
 	Chat       Chat            `json:"chat"`
 	From       User            `json:"from"`
-	UserChatID int             `json:"user_chat_id"`
+	UserChatID int64           `json:"user_chat_id"`
 	Date       int64           `json:"date"`
 	Bio        *string         `json:"bio,omitempty"`
 	InviteLink *ChatInviteLink `json:"invite_link,omitempty"`

tgapi/uploader_api.go

@@ -3,7 +3,6 @@ package tgapi
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 	"mime/multipart"
 	"net/http"
@@ -15,47 +14,74 @@ import (
 )
 
 const (
-	UploaderPhotoType     UploaderFileType = "photo"
+	// UploaderPhotoType is the multipart field name for photo uploads.
-	UploaderVideoType     UploaderFileType = "video"
+	UploaderPhotoType UploaderFileType = "photo"
-	UploaderAudioType     UploaderFileType = "audio"
+	// UploaderVideoType is the multipart field name for video uploads.
-	UploaderDocumentType  UploaderFileType = "document"
+	UploaderVideoType UploaderFileType = "video"
-	UploaderVoiceType     UploaderFileType = "voice"
+	// UploaderAudioType is the multipart field name for audio uploads.
+	UploaderAudioType UploaderFileType = "audio"
+	// UploaderDocumentType is the multipart field name for document uploads.
+	UploaderDocumentType UploaderFileType = "document"
+	// UploaderVoiceType is the multipart field name for voice uploads.
+	UploaderVoiceType UploaderFileType = "voice"
+	// UploaderVideoNoteType is the multipart field name for video-note uploads.
 	UploaderVideoNoteType UploaderFileType = "video_note"
+	// UploaderThumbnailType is the multipart field name for thumbnail uploads.
 	UploaderThumbnailType UploaderFileType = "thumbnail"
+	// UploaderStickerType is the multipart field name for sticker uploads.
+	UploaderStickerType UploaderFileType = "sticker"
 )
 
+// UploaderFileType represents the Telegram form field name for a file upload.
 type UploaderFileType string
+
+// UploaderFile holds the data and metadata for a single file to be uploaded.
 type UploaderFile struct {
 	filename string
 	data     []byte
 	field    UploaderFileType
 }
 
+// NewUploaderFile creates a new UploaderFile, auto-detecting the field type from the file extension.
+// If detection is incorrect, use SetType to override.
 func NewUploaderFile(name string, data []byte) UploaderFile {
 	t := uploaderTypeByExt(name)
 	return UploaderFile{filename: name, data: data, field: t}
 }
 
-// SetType used when auto-detect failed.
+// SetType overrides the auto-detected upload field type.
-// i.e. you sending a voice message, but it detects as audio, or if you send audio with thumbnail
+// For example, use it when a voice file is detected as audio.
 func (f UploaderFile) SetType(t UploaderFileType) UploaderFile {
 	f.field = t
 	return f
 }
 
+// Uploader is a Telegram Bot API client specialized for multipart file uploads.
+//
+// Use Uploader methods when you need to upload binary files directly
+// (InputFile/multipart). For JSON-only calls (file_id, URL, plain params), use API.
 type Uploader struct {
 	api    *API
 	logger *slog.Logger
 }
 
+// NewUploader creates a multipart uploader bound to an API client.
 func NewUploader(api *API) *Uploader {
 	logger := slog.CreateLogger().Level(utils.GetLoggerLevel()).Prefix("UPLOADER")
 	logger.AddWriter(logger.CreateJsonStdoutWriter())
 	return &Uploader{api, logger}
 }
-func (u *Uploader) Close() error            { return u.logger.Close() }
+
+// Close flushes and closes uploader logger resources.
+// See https://core.telegram.org/bots/api
+func (u *Uploader) Close() error { return u.logger.Close() }
+
+// GetLogger returns uploader logger instance.
+// See https://core.telegram.org/bots/api
 func (u *Uploader) GetLogger() *slog.Logger { return u.logger }
 
+// UploaderRequest is a multipart file upload request to the Telegram API.
+// Use NewUploaderRequest or NewUploaderRequestWithChatID to construct one.
 type UploaderRequest[R, P any] struct {
 	method string
 	files  []UploaderFile
@@ -63,48 +89,46 @@ type UploaderRequest[R, P any] struct {
 	chatId int64
 }
 
+// NewUploaderRequest creates a new multipart upload request with no associated chat ID.
 func NewUploaderRequest[R, P any](method string, params P, files ...UploaderFile) UploaderRequest[R, P] {
 	return UploaderRequest[R, P]{method: method, files: files, params: params, chatId: 0}
 }
+
+// NewUploaderRequestWithChatID creates a new multipart upload request with an associated chat ID.
+// The chat ID is used for per-chat rate limiting.
 func NewUploaderRequestWithChatID[R, P any](method string, params P, chatId int64, files ...UploaderFile) UploaderRequest[R, P] {
 	return UploaderRequest[R, P]{method: method, files: files, params: params, chatId: chatId}
 }
 func (r UploaderRequest[R, P]) doRequest(ctx context.Context, up *Uploader) (R, error) {
 	var zero R
 
-	buf, contentType, err := prepareMultipart(r.files, r.params)
-	if err != nil {
-		return zero, err
-	}
-
 	methodPrefix := ""
 	if up.api.useTestServer {
 		methodPrefix = "/test"
 	}
 	url := fmt.Sprintf("%s/bot%s%s/%s", up.api.apiUrl, up.api.token, methodPrefix, r.method)
-	req, err := http.NewRequestWithContext(ctx, "POST", url, buf)
-	if err != nil {
-		return zero, err
-	}
-	req.Header.Set("Content-Type", contentType)
-	req.Header.Set("Accept", "application/json")
-	req.Header.Set("User-Agent", fmt.Sprintf("Laniakea/%s", utils.VersionString))
-	req.Header.Set("Accept-Encoding", "gzip")
-	req.ContentLength = int64(buf.Len())
 
 	for {
 		if up.api.Limiter != nil {
-			if up.api.dropOverflowLimit {
+			if err := up.api.Limiter.Check(ctx, up.api.dropOverflowLimit, r.chatId); err != nil {
-				if !up.api.Limiter.GlobalAllow() {
+				return zero, err
-					return zero, errors.New("rate limited")
-				}
-			} else {
-				if err := up.api.Limiter.GlobalWait(ctx); err != nil {
-					return zero, err
-				}
 			}
 		}
 
+		buf, contentType, err := prepareMultipart(r.files, r.params)
+		if err != nil {
+			return zero, err
+		}
+		req, err := http.NewRequestWithContext(ctx, "POST", url, buf)
+		if err != nil {
+			return zero, err
+		}
+		req.Header.Set("Content-Type", contentType)
+		req.Header.Set("Accept", "application/json")
+		req.Header.Set("User-Agent", fmt.Sprintf("Laniakea/%s", utils.VersionString))
+		req.Header.Set("Accept-Encoding", "gzip")
+		req.ContentLength = int64(buf.Len())
+
 		up.logger.Debugln("UPLOADER REQ", r.method)
 		resp, err := up.api.client.Do(req)
 		if err != nil {
@@ -127,10 +151,12 @@ func (r UploaderRequest[R, P]) doRequest(ctx context.Context, up *Uploader) (R,
 			if response.ErrorCode == 429 && response.Parameters != nil && response.Parameters.RetryAfter != nil {
 				after := *response.Parameters.RetryAfter
 				up.logger.Warnf("Rate limited, retry after %d seconds (chat: %d)", after, r.chatId)
-				if r.chatId > 0 {
+				if up.api.Limiter != nil {
-					up.api.Limiter.SetChatLock(r.chatId, after)
+					if r.chatId > 0 {
-				} else {
+						up.api.Limiter.SetChatLock(r.chatId, after)
-					up.api.Limiter.SetGlobalLock(after)
+					} else {
+						up.api.Limiter.SetGlobalLock(after)
+					}
 				}
 
 				select {
@@ -145,6 +171,9 @@ func (r UploaderRequest[R, P]) doRequest(ctx context.Context, up *Uploader) (R,
 		return response.Result, nil
 	}
 }
+
+// DoWithContext executes the upload request asynchronously via the worker pool.
+// Returns the result or error. Respects context cancellation.
 func (r UploaderRequest[R, P]) DoWithContext(ctx context.Context, up *Uploader) (R, error) {
 	var zero R
 
@@ -168,10 +197,15 @@ func (r UploaderRequest[R, P]) DoWithContext(ctx context.Context, up *Uploader)
 		return zero, ErrPoolUnexpected
 	}
 }
+
+// Do executes the upload request synchronously with a background context.
+// Use only for simple, non-critical uploads.
 func (r UploaderRequest[R, P]) Do(up *Uploader) (R, error) {
 	return r.DoWithContext(context.Background(), up)
 }
 
+// prepareMultipart builds a multipart form body from the given files and params.
+// Params are encoded via utils.Encode. The writer boundary is finalized before returning.
 func prepareMultipart[P any](files []UploaderFile, params P) (*bytes.Buffer, string, error) {
 	buf := bytes.NewBuffer(nil)
 	w := multipart.NewWriter(buf)
@@ -204,6 +238,8 @@ func prepareMultipart[P any](files []UploaderFile, params P) (*bytes.Buffer, str
 	return buf, w.FormDataContentType(), nil
 }
 
+// uploaderTypeByExt infers the Telegram upload field name from a file extension.
+// Falls back to UploaderDocumentType for unrecognized extensions.
 func uploaderTypeByExt(filename string) UploaderFileType {
 	ext := filepath.Ext(filename)
 	switch ext {

tgapi/uploader_methods.go

@@ -24,10 +24,10 @@ type UploadPhotoP struct {
 	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
 }
 
-// UploadPhoto uploads a photo and sends it as a message.
+// SendPhoto uploads a photo via multipart and sends it as a message.
 // file is the photo file to upload.
 // See https://core.telegram.org/bots/api#sendphoto
-func (u *Uploader) UploadPhoto(params UploadPhotoP, file UploaderFile) (Message, error) {
+func (u *Uploader) SendPhoto(params UploadPhotoP, file UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendPhoto", params, params.ChatID, file)
 	return req.Do(u)
 }
@@ -58,10 +58,10 @@ type UploadAudioP struct {
 	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
 }
 
-// UploadAudio uploads an audio file and sends it as a message.
+// SendAudio uploads an audio file via multipart and sends it as a message.
 // files are the audio file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendaudio
-func (u *Uploader) UploadAudio(params UploadAudioP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendAudio(params UploadAudioP, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendAudio", params, params.ChatID, files...)
 	return req.Do(u)
 }
@@ -89,11 +89,11 @@ type UploadDocumentP struct {
 	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
 }
 
-// UploadDocument uploads a document and sends it as a message.
+// SendDocument uploads a document via multipart and sends it as a message.
 // files are the document file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#senddocument
-func (u *Uploader) UploadDocument(params UploadDocumentP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendDocument(params UploadDocumentP, files ...UploaderFile) (Message, error) {
-	req := NewUploaderRequest[Message]("sendDocument", params, files...)
+	req := NewUploaderRequestWithChatID[Message]("sendDocument", params, params.ChatID, files...)
 	return req.Do(u)
 }
 
@@ -127,11 +127,11 @@ type UploadVideoP struct {
 	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
 }
 
-// UploadVideo uploads a video and sends it as a message.
+// SendVideo uploads a video via multipart and sends it as a message.
 // files are the video file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendvideo
-func (u *Uploader) UploadVideo(params UploadVideoP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVideo(params UploadVideoP, files ...UploaderFile) (Message, error) {
-	req := NewUploaderRequest[Message]("sendVideo", params, files...)
+	req := NewUploaderRequestWithChatID[Message]("sendVideo", params, params.ChatID, files...)
 	return req.Do(u)
 }
 
@@ -163,11 +163,11 @@ type UploadAnimationP struct {
 	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
 }
 
-// UploadAnimation uploads an animation (GIF or H.264/MPEG-4 AVC video without sound) and sends it as a message.
+// SendAnimation uploads an animation via multipart and sends it as a message.
 // files are the animation file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendanimation
-func (u *Uploader) UploadAnimation(params UploadAnimationP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendAnimation(params UploadAnimationP, files ...UploaderFile) (Message, error) {
-	req := NewUploaderRequest[Message]("sendAnimation", params, files...)
+	req := NewUploaderRequestWithChatID[Message]("sendAnimation", params, params.ChatID, files...)
 	return req.Do(u)
 }
 
@@ -194,11 +194,11 @@ type UploadVoiceP struct {
 	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
 }
 
-// UploadVoice uploads a voice note and sends it as a message.
+// SendVoice uploads a voice note via multipart and sends it as a message.
 // files are the voice file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendvoice
-func (u *Uploader) UploadVoice(params UploadVoiceP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVoice(params UploadVoiceP, files ...UploaderFile) (Message, error) {
-	req := NewUploaderRequest[Message]("sendVoice", params, files...)
+	req := NewUploaderRequestWithChatID[Message]("sendVoice", params, params.ChatID, files...)
 	return req.Do(u)
 }
 
@@ -223,11 +223,11 @@ type UploadVideoNoteP struct {
 	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
 }
 
-// UploadVideoNote uploads a video note (rounded video) and sends it as a message.
+// SendVideoNote uploads a video note via multipart and sends it as a message.
 // files are the video note file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendvideonote
-func (u *Uploader) UploadVideoNote(params UploadVideoNoteP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVideoNote(params UploadVideoNoteP, files ...UploaderFile) (Message, error) {
-	req := NewUploaderRequest[Message]("sendVideoNote", params, files...)
+	req := NewUploaderRequestWithChatID[Message]("sendVideoNote", params, params.ChatID, files...)
 	return req.Do(u)
 }
 
@@ -237,10 +237,10 @@ type UploadChatPhotoP struct {
 	ChatID int64 `json:"chat_id"`
 }
 
-// UploadChatPhoto uploads a new chat photo.
+// SetChatPhoto uploads a new chat photo.
 // photo is the photo file to upload.
 // See https://core.telegram.org/bots/api#setchatphoto
-func (u *Uploader) UploadChatPhoto(params UploadChatPhotoP, photo UploaderFile) (Message, error) {
+func (u *Uploader) SetChatPhoto(params UploadChatPhotoP, photo UploaderFile) (bool, error) {
-	req := NewUploaderRequest[Message]("sendChatPhoto", params, photo)
+	req := NewUploaderRequestWithChatID[bool]("setChatPhoto", params, params.ChatID, photo)
 	return req.Do(u)
 }

tgapi/users_methods.go

@@ -3,9 +3,9 @@ package tgapi
 // GetUserProfilePhotosP holds parameters for the GetUserProfilePhotos method.
 // See https://core.telegram.org/bots/api#getuserprofilephotos
 type GetUserProfilePhotosP struct {
-	UserID int `json:"user_id"`
+	UserID int64 `json:"user_id"`
-	Offset int `json:"offset,omitempty"`
+	Offset int   `json:"offset,omitempty"`
-	Limit  int `json:"limit,omitempty"`
+	Limit  int   `json:"limit,omitempty"`
 }
 
 // GetUserProfilePhotos returns a list of profile pictures for a user.
@@ -18,9 +18,9 @@ func (api *API) GetUserProfilePhotos(params GetUserProfilePhotosP) (UserProfileP
 // GetUserProfileAudiosP holds parameters for the GetUserProfileAudios method.
 // See https://core.telegram.org/bots/api#getuserprofileaudios
 type GetUserProfileAudiosP struct {
-	UserID int `json:"user_id"`
+	UserID int64 `json:"user_id"`
-	Offset int `json:"offset,omitempty"`
+	Offset int   `json:"offset,omitempty"`
-	Limit  int `json:"limit,omitempty"`
+	Limit  int   `json:"limit,omitempty"`
 }
 
 // GetUserProfileAudios returns a list of profile audios for a user.
@@ -33,7 +33,7 @@ func (api *API) GetUserProfileAudios(params GetUserProfileAudiosP) (UserProfileA
 // SetUserEmojiStatusP holds parameters for the SetUserEmojiStatus method.
 // See https://core.telegram.org/bots/api#setuseremojistatus
 type SetUserEmojiStatusP struct {
-	UserID         int    `json:"user_id"`
+	UserID         int64  `json:"user_id"`
 	EmojiID        string `json:"emoji_status_custom_emoji_id,omitempty"`
 	ExpirationDate int    `json:"emoji_status_expiration_date,omitempty"`
 }
@@ -49,7 +49,7 @@ func (api *API) SetUserEmojiStatus(params SetUserEmojiStatusP) (bool, error) {
 // GetUserGiftsP holds parameters for the GetUserGifts method.
 // See https://core.telegram.org/bots/api#getusergifts
 type GetUserGiftsP struct {
-	UserID                      int    `json:"user_id"`
+	UserID                      int64  `json:"user_id"`
 	ExcludeUnlimited            bool   `json:"exclude_unlimited,omitempty"`
 	ExcludeLimitedUpgradable    bool   `json:"exclude_limited_upgradable,omitempty"`
 	ExcludeLimitedNonUpgradable bool   `json:"exclude_limited_non_upgradable,omitempty"`

tgapi/users_types.go

@@ -3,7 +3,7 @@ package tgapi
 // User represents a Telegram user or bot.
 // See https://core.telegram.org/bots/api#user
 type User struct {
-	ID                        int     `json:"id"`
+	ID                        int64   `json:"id"`
 	IsBot                     bool    `json:"is_bot"`
 	FirstName                 string  `json:"first_name"`
 	LastName                  *string `json:"last_name,omitempty"`

utils.go

@@ -6,7 +6,10 @@ import (
 	"git.nix13.pw/scuroneko/laniakea/utils"
 )
 
+// Ptr returns a pointer to v.
 func Ptr[T any](v T) *T { return &v }
+
+// Val returns dereferenced pointer value or def when p is nil.
 func Val[T any](p *T, def T) T {
 	if p != nil {
 		return *p
@@ -14,8 +17,8 @@ func Val[T any](p *T, def T) T {
 	return def
 }
 
-// EscapeMarkdown
+// EscapeMarkdown escapes special characters for legacy Telegram Markdown.
-// Deprecated. Use MarkdownV2
+// Deprecated: Use EscapeMarkdownV2.
 func EscapeMarkdown(s string) string {
 	s = strings.ReplaceAll(s, "_", `\_`)
 	s = strings.ReplaceAll(s, "*", `\*`)
@@ -40,6 +43,8 @@ func EscapeMarkdownV2(s string) string {
 	}
 	return s
 }
+
+// EscapePunctuation escapes '.', '!' and '-' for MarkdownV2 fragments.
 func EscapePunctuation(s string) string {
 	symbols := []string{".", "!", "-"}
 	for _, symbol := range symbols {
@@ -48,6 +53,7 @@ func EscapePunctuation(s string) string {
 	return s
 }
 
+// Version constants mirror values from the internal utils/version package.
 const (
 	VersionString = utils.VersionString
 	VersionMajor  = utils.VersionMajor

utils/limiter.go

@@ -22,7 +22,7 @@ type RateLimiter struct {
 
 	chatLocks    map[int64]time.Time     // per-chat cooldown timestamps
 	chatLimiters map[int64]*rate.Limiter // per-chat token buckets (1 req/sec)
-	chatMu       sync.Mutex              // protects chatLocks and chatLimiters
+	chatMu       sync.RWMutex            // protects chatLocks and chatLimiters
 }
 
 // NewRateLimiter creates a new RateLimiter with default limits.
@@ -36,6 +36,17 @@ func NewRateLimiter() *RateLimiter {
 	}
 }
 
+// SetGlobalRate overrides global request-per-second limit and burst.
+// If rps <= 0, current settings are kept.
+func (rl *RateLimiter) SetGlobalRate(rps int) {
+	if rps <= 0 {
+		return
+	}
+	rl.globalMu.Lock()
+	defer rl.globalMu.Unlock()
+	rl.globalLimiter = rate.NewLimiter(rate.Limit(rps), rps)
+}
+
 // SetGlobalLock sets a global cooldown period (e.g., after receiving 429 from Telegram).
 // If retryAfter <= 0, no lock is applied.
 func (rl *RateLimiter) SetGlobalLock(retryAfter int) {
@@ -64,7 +75,11 @@ func (rl *RateLimiter) GlobalWait(ctx context.Context) error {
 	if err := rl.waitForGlobalUnlock(ctx); err != nil {
 		return err
 	}
-	return rl.globalLimiter.Wait(ctx)
+	limiter := rl.getGlobalLimiter()
+	if limiter == nil {
+		return nil
+	}
+	return limiter.Wait(ctx)
 }
 
 // Wait blocks until a request for the given chat can be made.
@@ -77,8 +92,21 @@ func (rl *RateLimiter) Wait(ctx context.Context, chatID int64) error {
 	if err := rl.waitForGlobalUnlock(ctx); err != nil {
 		return err
 	}
-	limiter := rl.getChatLimiter(chatID)
+	limiter := rl.getGlobalLimiter()
-	return limiter.Wait(ctx)
+	if limiter != nil {
+		if err := limiter.Wait(ctx); err != nil {
+			return err
+		}
+	}
+	chatLimiter := rl.getChatLimiter(chatID)
+	return chatLimiter.Wait(ctx)
+}
+
+// getGlobalLimiter returns the global limiter safely under read lock.
+func (rl *RateLimiter) getGlobalLimiter() *rate.Limiter {
+	rl.globalMu.RLock()
+	defer rl.globalMu.RUnlock()
+	return rl.globalLimiter
 }
 
 // GlobalAllow checks if a global request can be made without blocking.
@@ -91,7 +119,11 @@ func (rl *RateLimiter) GlobalAllow() bool {
 	if !until.IsZero() && time.Now().Before(until) {
 		return false
 	}
-	return rl.globalLimiter.Allow()
+	limiter := rl.getGlobalLimiter()
+	if limiter == nil {
+		return true
+	}
+	return limiter.Allow()
 }
 
 // Allow checks if a request for the given chat can be made without blocking.
@@ -107,21 +139,22 @@ func (rl *RateLimiter) Allow(chatID int64) bool {
 	}
 
 	// Check chat cooldown
-	rl.chatMu.Lock()
+	rl.chatMu.RLock()
 	chatUntil, ok := rl.chatLocks[chatID]
-	rl.chatMu.Unlock()
+	rl.chatMu.RUnlock()
 	if ok && !chatUntil.IsZero() && time.Now().Before(chatUntil) {
 		return false
 	}
 
 	// Check global token bucket
-	if !rl.globalLimiter.Allow() {
+	limiter := rl.getGlobalLimiter()
+	if limiter != nil && !limiter.Allow() {
 		return false
 	}
 
 	// Check chat token bucket
-	limiter := rl.getChatLimiter(chatID)
+	chatLimiter := rl.getChatLimiter(chatID)
-	return limiter.Allow()
+	return chatLimiter.Allow()
 }
 
 // Check applies rate limiting based on configuration.
@@ -135,11 +168,15 @@ func (rl *RateLimiter) Allow(chatID int64) bool {
 // chatID == 0 means no specific chat context (e.g., inline query, webhook without chat).
 func (rl *RateLimiter) Check(ctx context.Context, dropOverflow bool, chatID int64) error {
 	if dropOverflow {
-		if chatID != 0 && !rl.Allow(chatID) {
+		if chatID != 0 {
-			return ErrDropOverflow
+			if !rl.Allow(chatID) {
-		}
+
-		if !rl.GlobalAllow() {
+				return ErrDropOverflow
-			return ErrDropOverflow
+			}
+		} else {
+			if !rl.GlobalAllow() {
+				return ErrDropOverflow
+			}
 		}
 	} else if chatID != 0 {
 		if err := rl.Wait(ctx, chatID); err != nil {
@@ -175,9 +212,9 @@ func (rl *RateLimiter) waitForGlobalUnlock(ctx context.Context) error {
 // waitForChatUnlock blocks until the specified chat's cooldown expires or context is done.
 // Does not check token bucket — only cooldown.
 func (rl *RateLimiter) waitForChatUnlock(ctx context.Context, chatID int64) error {
-	rl.chatMu.Lock()
+	rl.chatMu.RLock()
 	until, ok := rl.chatLocks[chatID]
-	rl.chatMu.Unlock()
+	rl.chatMu.RUnlock()
 
 	if !ok || until.IsZero() || time.Now().After(until) {
 		return nil
@@ -193,8 +230,10 @@ func (rl *RateLimiter) waitForChatUnlock(ctx context.Context, chatID int64) erro
 
 // getChatLimiter returns the rate limiter for the given chat, creating it if needed.
 // Uses 1 request per second with burst of 1 — conservative for per-user limits.
-// Must be called with rl.chatMu held.
 func (rl *RateLimiter) getChatLimiter(chatID int64) *rate.Limiter {
+	rl.chatMu.Lock()
+	defer rl.chatMu.Unlock()
+
 	if lim, ok := rl.chatLimiters[chatID]; ok {
 		return lim
 	}

utils/multipart.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 )
 
+// Encode writes struct fields into multipart form-data using json tags as field names.
 func Encode[T any](w *multipart.Writer, req T) error {
 	v := reflect.ValueOf(req)
 	if v.Kind() == reflect.Ptr {
@@ -49,11 +50,9 @@ func Encode[T any](w *multipart.Writer, req T) error {
 
 		switch field.Kind() {
 		case reflect.String:
-			if !isEmpty {
+			fw, err = w.CreateFormField(fieldName)
-				fw, err = w.CreateFormField(fieldName)
+			if err == nil {
-				if err == nil {
+				_, err = fw.Write([]byte(field.String()))
-					_, err = fw.Write([]byte(field.String()))
-				}
 			}
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 			fw, err = w.CreateFormField(fieldName)
@@ -65,11 +64,17 @@ func Encode[T any](w *multipart.Writer, req T) error {
 			if err == nil {
 				_, err = fw.Write([]byte(strconv.FormatUint(field.Uint(), 10)))
 			}
-		case reflect.Float32, reflect.Float64:
+		case reflect.Float32:
+			fw, err = w.CreateFormField(fieldName)
+			if err == nil {
+				_, err = fw.Write([]byte(strconv.FormatFloat(field.Float(), 'f', -1, 32)))
+			}
+		case reflect.Float64:
 			fw, err = w.CreateFormField(fieldName)
 			if err == nil {
 				_, err = fw.Write([]byte(strconv.FormatFloat(field.Float(), 'f', -1, 64)))
 			}
+
 		case reflect.Bool:
 			fw, err = w.CreateFormField(fieldName)
 			if err == nil {
@@ -103,8 +108,12 @@ func Encode[T any](w *multipart.Writer, req T) error {
 						_, err = fw.Write([]byte(strconv.FormatUint(elem.Uint(), 10)))
 					case reflect.Bool:
 						_, err = fw.Write([]byte(strconv.FormatBool(elem.Bool())))
-					case reflect.Float32, reflect.Float64:
+					case reflect.Float32:
+						_, err = fw.Write([]byte(strconv.FormatFloat(elem.Float(), 'f', -1, 32)))
+					case reflect.Float64:
 						_, err = fw.Write([]byte(strconv.FormatFloat(elem.Float(), 'f', -1, 64)))
+					default:
+						continue
 					}
 					if err != nil {
 						break

utils/utils.go

@@ -6,6 +6,7 @@ import (
 	"git.nix13.pw/scuroneko/slog"
 )
 
+// GetLoggerLevel returns DEBUG when DEBUG=true in env, otherwise FATAL.
 func GetLoggerLevel() slog.LogLevel {
 	level := slog.FATAL
 	if os.Getenv("DEBUG") == "true" {

utils/version.go

@@ -1,9 +1,9 @@
 package utils
 
 const (
-	VersionString = "1.0.0-beta.16"
+	VersionString = "1.0.0-beta.22"
 	VersionMajor  = 1
 	VersionMinor  = 0
 	VersionPatch  = 0
-	VersionBeta   = 16
+	VersionBeta   = 22
 )