node-telegram-bot-api is a TypeScript client library for the Telegram Bot API, built as a runtime-agnostic core plus Node.js and Bun adapters. It exposes a Bot class with koa-style middleware, Context helpers, generated Api methods that map 1:1 to Telegram endpoints, and both long-polling and webhook update ingestion. The package targets Node 18+, Bun, Deno, Cloudflare Workers, and Vercel Edge by restricting src/core to Web-standard APIs and enforcing these boundaries with CI gates. It is a library, not a standalone app; consumers embed it to build Telegram bots. In production, the library receives updates either from getUpdates long polling (an AsyncGenerator with retry, backoff, and conflict handling) or from webhook callbacks (Web-standard Request to Response handlers plus adapters for Express, Next.js App Router, and Node HTTP). It includes a resilient transport layer with timeouts, retries, token-bucket rate limiting, and streaming multipart uploads, plus optional session middleware with pluggable stores (memory, file, SQLite, Redis) and a reply/callback tracking layer for structured conversations. The full Telegram type surface is auto-generated from live Bot API documentation by scripts/api-parser.ts, producing schemas.ts and api.ts, and the e2e suite exercises real Telegram endpoints. Architecturally, the most reusable patterns are generic middleware composition, an injectable fetch transport with backoff, a token-bucket rate limiter with per-key LRU state, and a streaming multipart encoder that avoids buffering whole uploads in memory. Session stores are deliberately minimal string-keyed KV contracts, with versioned envelopes allowing optional layers to extend state. The codebase is well tested, documented with 18 examples, and under active maintenance. This is not a data_research repository; the code generation pipeline is a build-time tool, not the product itself.
python-telegram-bot is a pure Python, asynchronous library that provides both low-level bindings to the Telegram Bot API and a high-level application framework for building Telegram bots. In production, it handles authentication, message sending/receiving, update processing, and bot lifecycle management. The library is used by developers to create bots that can respond to commands, messages, inline queries, callback queries, and other Telegram events, with support for payments, passports, polls, and more. The architecture is organized into three layers: the core `telegram` package containing data models for all Telegram API types (Chat, User, Message, etc.) with consistent serialization and equality semantics; the `telegram.ext` extension framework providing handlers (CommandHandler, MessageHandler, ConversationHandler), an Application class for orchestrating update processing, job queues, persistence, and rate limiting; and the `telegram.request` layer using httpx for async HTTP communication. The library uses async/await throughout and follows a handler-based event-driven pattern. Key entry points include `telegram.ext.Application` (built via `ApplicationBuilder`), `telegram.Bot` for direct API calls, and various handler classes. The primary data flow involves receiving updates from Telegram via polling or webhook, parsing them into `Update` objects, dispatching to registered handlers based on filters, and executing callback functions that can call Bot methods to respond. The library supports custom context types, persistent storage of bot/user/chat data, and scheduled jobs. External dependencies are minimal: `httpx` is the only required runtime dependency. Optional features require additional packages: `cryptography` for Telegram Passport, `APScheduler` for job queues, `cachetools` for callback data caching, `tornado` for webhook server, `aiolimiter` for rate limiting, and `pytz`/`zoneinfo` for timezone support. The library is extensively tested with both offline unit tests and online integration tests against the live Telegram API.
Necord is a NestJS module for creating Discord bots that integrates Discord.js with the NestJS dependency injection system. It provides decorators for defining Discord interactions (slash commands, context menus, message components, modals, etc.) and handles event listening through a discovery mechanism. The architecture follows NestJS patterns with modules, providers, and decorators, using explorer services to scan for decorated methods at runtime. Key features include automatic command registration, custom parameter decorators for interaction data, and advanced context management for asynchronous event handlers using Node.js async_hooks.
discord-haskell is a Haskell library for building Discord bots. It provides type-safe bindings to the Discord API, handling both REST requests and WebSocket gateway connections. The library features automatic rate limiting, resilient connection handling with reconnection logic, optional caching of guild/channel/user data, and comprehensive support for Discord interactions including slash commands, buttons, select menus, and modals. Built with a modular architecture separating gateway, REST, and type concerns, it uses ReaderT for dependency injection and provides a clean interface for bot developers.
JDA (Java Discord API) is a comprehensive Java library for building Discord bots. It provides a full-featured client for Discord's REST API and Gateway (WebSocket) protocol, including support for slash commands, message components (buttons, select menus, modals), voice/audio (Opus, DAVE encryption), auto-moderation, scheduled events, forum channels, polls, stickers, soundboard, and sharding. The architecture is event-driven with a rich hierarchy of typed events, an asynchronous request system (RestAction) with combinators (map, flatMap, delay), and a fluent manager pattern for entity modifications. It includes a custom component tree with immutable replacement, ETF (Erlang External Term Format) encoding for gateway payloads, and a thread-safe caching layer using Trove maps. The codebase is well-structured with extensive unit tests, snapshot testing, and architecture compliance tests. It is actively maintained with regular releases and a large community.
maxapi is an async Python SDK and bot framework for the MAX messenger platform. It provides a high-level client (`Bot`) for all MAX Bot API endpoints, an event-driven dispatcher with router hierarchy (`Dispatcher`/`Router`), composable filters (magic filter `F`, `Command`, `StateFilter`, etc.), middleware chains, a finite state machine (FSM) with multiple backends (memory, Redis), and webhook integrations for aiohttp, FastAPI, and Litestar. The library is heavily inspired by aiogram but adapted to MAX API specifics such as attachment types, callback payloads, and deep linking. It includes extensive utility code for formatting (HTML/Markdown), inline keyboard building, VCF parsing, and time helpers. The codebase is well-structured with Pydantic v2 models for all API entities, rigorous retry logic, and a comprehensive test suite covering unit, integration, and webhook scenarios. While not a standalone application, it serves as a foundational component for building production-ready MAX bots.
vkbottle is an asynchronous Python framework for building VK (VKontakte) bots and interacting with the VK API. It provides both high-level abstractions (Bot, User, labelers, rules, middlewares, state dispensers) and low-level API clients with pluggable request/response validation, token rotation, and error handling. The framework is fully async, built on asyncio and aiohttp, and supports long polling, callback API, and dual mode (simultaneous polling and callback). It includes extensive tooling for keyboards, templates, uploaders, markdown-to-VK-format conversion, VKScript generation, event deduplication, and a waiter machine for awaiting future events. The architecture is modular with abstract base classes for nearly every component, enabling custom implementations. The codebase is well-structured with clear separation of concerns, extensive test coverage, and CI/CD pipelines. Deprecated components (LoopWrapper, Blueprints) are clearly marked, and the library is actively maintained with a mature version 4.11.0.
OTClient is a fully functional open-source alternative client for the MMORPG Tibia, implemented in C++20 and Lua. It is a cross-platform desktop application that renders a 2D tile-based game world using OpenGL, communicates with game servers via a custom TCP protocol (with encryption, compression, and version negotiation), and provides a rich Lua-scripted user interface built on a custom UI framework (OTML). The repository contains the complete client engine (graphics, networking, audio, input, platform abstraction), game-specific modules (action bars, minimap, market, NPC trade, skill wheel, etc.), and a significant set of bot/automation mods (cavebot, targetbot, loot system). The architecture follows a hybrid C++/Lua model where the core engine is in C++ and all game logic and UI are implemented in Lua, allowing extensive customization and module loading. While the codebase is generally well-structured with reusable components (event dispatcher, layout system, protocol abstraction), it also carries technical debt from accumulated version-specific conditionals, a large bot subsystem that may violate game terms of service, and some duplication between Lua modules.
This is a cross-platform software development kit (SDK) for rendering Adaptive Cards—a JSON-based card format used by Microsoft products like Teams, Outlook, and Cortana. The repository provides a shared C++ object model for parsing and serializing card definitions, along with platform-specific renderers for Android, iOS, UWP (WinUI), .NET (WPF), and Node.js. It also includes a templating engine for dynamic data binding, a visual designer tool, and multiple test applications. The architecture is a library/framework model: each platform has its own rendering layer that converts the parsed card model into native UI components. The codebase is large and well-organized, with clear separation between the shared model and platform implementations. However, feature parity across platforms is incomplete (e.g., v1.5 features are missing in .NET renderer), and there is significant duplication of logic across platforms, which introduces maintenance risk.
This repository is a large collection of sample applications for the Microsoft 365 Agents Toolkit (formerly Teams Toolkit). It contains dozens of independent projects demonstrating how to build Microsoft Teams tabs, bots, message extensions, notification bots, Office Add-ins, SharePoint Framework web parts, and Copilot extensions (agents). Each sample is self-contained with its own infrastructure-as-code (Bicep), app manifest, environment configuration, and source code in TypeScript, JavaScript, Python, or C#. The samples range from simple hello-world tabs to complex AI-powered agents that integrate with Azure OpenAI, Microsoft Graph, and Azure AI Foundry. While primarily an application repository, a few samples include small datasets (e.g., AdventureWorks SQLite database for a data-analyst agent, CSV files for a Copilot connector) used for demonstration purposes. The codebase is heavily boilerplate-driven, with many files (like Privacy components, auth-end.html, TeamsUserCredential wrappers) duplicated across projects. This duplication creates maintenance overhead but also makes each sample independently usable. The most well-crafted components are the notification infrastructure (NotificationBot with configurable storage backends) and the proxy agent patterns that bridge M365 Copilot with external AI services. The repository includes a validation tool to enforce sample structure and metadata, CI/CD workflows, and dependabot configuration. However, many samples are archived (under /archive), and there is version inconsistency across samples (Node 16 vs 22, old botbuilder vs new agents-hosting SDK). Overall, it serves as a practical reference for developers building on the Microsoft 365 extensibility platform, but individual samples should be vetted for currency before reuse.