add sessionId

Author: azhe403

.gitignore

@@ -478,4 +478,8 @@ fabric.properties
 # http://www.sonarlint.org/commandline/
 # SonarLint working directories, configuration files (including credentials)
 .sonarlint/
-sonarlint/
+sonarlint/
+
+**/.idea/db-forest-config.xml
+**/.idea/MarsCode*.xml
+**/.idea/sonarlint.xml

.serena/.gitignore

@@ -0,0 +1,2 @@
+/cache
+/project.local.yml

.serena/docs/build-and-run.md

@@ -0,0 +1,6 @@
+
+# Build & Run
+
+-   **Build**: The entire solution can be built using the `dotnet build` command from the root directory.
+-   **Run**: The sample application can be run with the command `dotnet run` from the `ZiziBot.TelegramBot.Sample` directory.
+-   **URL**: When running, the sample application is accessible at `http://localhost:5157`.

.serena/docs/command-types.md

@@ -0,0 +1,115 @@
+
+# Command Types
+
+The framework supports several types of commands, which are decorated with specific attributes.
+
+#### Text Commands
+
+Text commands are triggered by sending a message that starts with a forward slash (`/`) or a specific text.
+
+-   **`[Command("command")]`**: This attribute is used to define a command that is triggered by `/command`.
+-   **`[TextCommand("text")]`**: This attribute is used to define a command that is triggered by the exact text `text`.
+-   **`[DefaultCommand]`**: This attribute is used to define a command that is triggered when no other command matches.
+
+```csharp
+public class SampleCommands : BotCommandController
+{
+    [Command("ping")]
+    [TextCommand("ping")]
+    public async Task PingCommand()
+    {
+        await SendMessage("Pong!");
+    }
+
+    [Command("say")]
+    public async Task SayCommand()
+    {
+        await SendMessage($"You say: {Context.CommandParam}!");
+    }
+
+    [DefaultCommand]
+    public async Task DefaultCommand()
+    {
+        await SendMessage("Default Command!");
+    }
+}
+```
+
+#### Callback Queries
+
+Callback queries are triggered when a user clicks an inline keyboard button.
+
+-   **`[Callback("data")]`**: This attribute is used to define a command that is triggered when the callback data is `data`.
+-   **`[Callback]`**: This attribute is used to define a command that is triggered when no other callback query matches.
+
+```csharp
+public class SampleCommands : BotCommandController
+{
+    [Callback("ping")]
+    public async Task PingCallback()
+    {
+        await AnswerCallbackQuery("User clicked Ping!");
+    }
+
+    [Callback]
+    public async Task DefaultCallback()
+    {
+        var text = $"Cmd: {Context.CallbackQueryCmd}" +
+                   $"\nParam: {Context.CallbackQueryParam}";
+        await AnswerCallbackQuery(text, showAlert: true);
+    }
+}
+```
+
+#### Inline Queries
+
+Inline queries are triggered when a user types the bot's username followed by a query in any chat.
+
+-   **`[InlineQuery("query")]`**: This attribute is used to define a command that is triggered when the inline query is `query`.
+-   **`[InlineQuery]`**: This attribute is used to define a command that is triggered when no other inline query matches.
+
+```csharp
+public class InlineQueryCommands : BotCommandController
+{
+    [InlineQuery]
+    public async Task InlineQueryCommand()
+    {
+        await AnswerInlineQuery(new List<InlineQueryResult>() {
+            new InlineQueryResultArticle("default-inline", "Default Inline", new InputTextMessageContent("Default Inline Content")),
+            new InlineQueryResultArticle("hello-inline", "Hello Inline", new InputTextMessageContent("Hello Inline Content"))
+        });
+    }
+
+    [InlineQuery("hello")]
+    public async Task InlineQueryCommandHello()
+    {
+        await AnswerInlineQuery(new List<InlineQueryResult>() {
+            new InlineQueryResultArticle("aa576dec-0727-4ea1-99ae-3c7cb20ea3c8", "Hello Inline", new InputTextMessageContent("Hello Inline Content"))
+        });
+    }
+}
+```
+
+#### Event-Based Commands
+
+Event-based commands are triggered by specific events in a chat.
+
+-   **`[TypedCommand(MessageType.NewChatMembers)]`**: This attribute is used to define a command that is triggered when a new member joins the chat.
+-   **`[UpdateCommand(UpdateType.ChatJoinRequest)]`**: This attribute is used to define a command that is triggered when a user requests to join a chat.
+
+```csharp
+public class EventCommands : BotCommandController
+{
+    [TypedCommand(MessageType.NewChatMembers)]
+    public async Task NewChatMembersCommand()
+    {
+        await SendMessage("Halo!");
+    }
+
+    [UpdateCommand(UpdateType.ChatJoinRequest)]
+    public async Task ChatJoinRequestCommand()
+    {
+        await SendMessage("Chat join request!");
+    }
+}
+```

.serena/docs/configuration.md

@@ -0,0 +1,34 @@
+# Configuration
+
+The bot's configuration is managed through the `appsettings.json` file. This file allows you to set up the bot's tokens, engine mode, and other settings.
+
+### Bot Tokens
+
+You can configure multiple bot tokens in the `BotTokenConfig` section. Each bot has a unique name and token.
+
+```json
+"BotTokenConfig": {
+  "Bots": [
+    {
+      "Name": "Main",
+      "Token": "YOUR_BOT_TOKEN",
+      "Username": "YOUR_BOT_USERNAME"
+    }
+  ]
+}
+```
+
+### Engine Mode
+
+The `EngineMode` property determines how the bot receives updates from Telegram. The available modes are:
+
+-   **`Polling`**: The bot periodically polls Telegram for new updates.
+-   **`Webhook`**: Telegram sends updates to a specified URL.
+-   **`Auto`**: The bot uses `Polling` in the `Development` environment and `Webhook` in other environments.
+
+```json
+"BotEngineConfig": {
+  "EngineMode": "Auto",
+  "WebhookUrl": "YOUR_WEBHOOK_URL"
+}
+```

.serena/docs/dependencies.md

@@ -0,0 +1,5 @@
+
+# Dependencies
+
+-   The **Framework** project uses `JetBrains.Annotations`, `Scrutor`, `UUIDNext`, and `WTelegramBot`.
+-   The **Sample** project uses `Microsoft.AspNetCore.OpenApi` and `Serilog.AspNetCore`.

.serena/docs/initialization.md

@@ -0,0 +1,7 @@
+
+# Initialization
+
+The bot is initialized in the `Program.cs` file of the sample project. Here's a breakdown of the key steps:
+
+1.  **`AddZiziBotTelegramBot()`**: This extension method registers all the necessary services for the bot to run.
+2.  **`UseZiziBotTelegramBot()`**: This extension method configures the bot and starts the engine.

.serena/docs/middleware.md

@@ -0,0 +1,45 @@
+# Middleware
+
+Middleware is a powerful feature that allows you to execute code before or after a command is executed. This is useful for tasks such as authentication, logging, and error handling.
+
+### Before-Command Middleware
+
+Before-command middleware is executed before a command is executed. To create a before-command middleware, you need to create a class that implements the `IBeforeCommand` interface.
+
+```csharp
+public class UserPreparationMiddleware : IBeforeCommand
+{
+    public async Task ExecuteAsync(CommandContext commandContext, CommandDelegate next)
+    {
+        // Your logic here
+        await next(commandContext);
+    }
+}
+```
+
+### After-Command Middleware
+
+After-command middleware is executed after a command is executed. To create an after-command middleware, you need to create a class that implements the `IAfterCommand` interface.
+
+```csharp
+public class AfterCommandMiddleware : IAfterCommand
+{
+    public async Task ExecuteAsync(CommandContext commandContext, CommandDelegate next)
+    {
+        // Your logic here
+        await next(commandContext);
+    }
+}
+```
+
+### Disabling Middleware
+
+You can disable middleware for a specific command or an entire controller by using the `[DisabledMiddleware]` attribute.
+
+```csharp
+[DisabledMiddleware(typeof(AfterCommandMiddleware))]
+public class SampleCommands : BotCommandController
+{
+    // ...
+}
+```

.serena/docs/structure.md

@@ -0,0 +1,7 @@
+
+# Project Structure
+
+The solution (`ZiziBot.TelegramBot.sln`) contains two main projects:
+
+1.  **`ZiziBot.TelegramBot.Framework`**: A .NET library that provides the core framework for building command-based Telegram bots. It targets `net8.0`, `net9.0`, and `net10.0`.
+2.  **`ZiziBot.TelegramBot.Sample`**: A .NET web project that serves as a sample implementation of the framework. It references the framework project and runs on `net10.0`.

.serena/project.yml

@@ -0,0 +1,136 @@
+# the name by which the project can be referenced within Serena
+project_name: "ZiziBot.TelegramBot"
+
+
+# list of languages for which language servers are started; choose from:
+#   al                  angular             ansible             bash                clojure
+#   cpp                 cpp_ccls            crystal             csharp              csharp_omnisharp
+#   dart                elixir              elm                 erlang              fortran
+#   fsharp              go                  groovy              haskell             haxe
+#   hlsl                html                java                json                julia
+#   kotlin              lean4               lua                 luau                markdown
+#   matlab              msl                 nix                 ocaml               pascal
+#   perl                php                 php_phpactor        powershell          python
+#   python_jedi         python_ty           r                   rego                ruby
+#   ruby_solargraph     rust                scala               scss                solidity
+#   swift               systemverilog       terraform           toml                typescript
+#   typescript_vts      vue                 yaml                zig
+#   (This list may be outdated. For the current list, see values of Language enum here:
+#   https://github.com/oraios/serena/blob/main/src/solidlsp/ls_config.py
+#   For some languages, there are alternative language servers, e.g. csharp_omnisharp, ruby_solargraph.)
+# Note:
+#   - For C, use cpp
+#   - For JavaScript, use typescript
+#   - For Angular projects, use angular (subsumes typescript+html; requires `npm install` in the project root)
+#   - For SCSS / Sass / plain CSS, use scss (some-sass-language-server handles all three)
+#   - For Free Pascal/Lazarus, use pascal
+# Special requirements:
+#   Some languages require additional setup/installations.
+#   See here for details: https://oraios.github.io/serena/01-about/020_programming-languages.html#language-servers
+# When using multiple languages, the first language server that supports a given file will be used for that file.
+# The first language is the default language and the respective language server will be used as a fallback.
+# Note that when using the JetBrains backend, language servers are not used and this list is correspondingly ignored.
+languages:
+- csharp
+
+# the encoding used by text files in the project
+# For a list of possible encodings, see https://docs.python.org/3.11/library/codecs.html#standard-encodings
+encoding: "utf-8"
+
+# line ending convention to use when writing source files.
+# Possible values: unset (use global setting), "lf", "crlf", or "native" (platform default)
+# This does not affect Serena's own files (e.g. memories and configuration files), which always use native line endings.
+line_ending:
+
+# The language backend to use for this project.
+# If not set, the global setting from serena_config.yml is used.
+# Valid values: LSP, JetBrains
+# Note: the backend is fixed at startup. If a project with a different backend
+# is activated post-init, an error will be returned.
+language_backend:
+
+# whether to use project's .gitignore files to ignore files
+ignore_all_files_in_gitignore: true
+
+# advanced configuration option allowing to configure language server-specific options.
+# Maps the language key to the options.
+# Have a look at the docstring of the constructors of the LS implementations within solidlsp (e.g., for C# or PHP) to see which options are available.
+# No documentation on options means no options are available.
+ls_specific_settings: {}
+
+# list of additional workspace folder paths for cross-package reference support (e.g. in monorepos).
+# Paths can be absolute or relative to the project root.
+# Each folder is registered as an LSP workspace folder, enabling language servers to discover
+# symbols and references across package boundaries.
+# Currently supported for: TypeScript.
+# Example:
+#   additional_workspace_folders:
+#     - ../sibling-package
+#     - ../shared-lib
+additional_workspace_folders: []
+
+# list of additional paths to ignore in this project.
+# Same syntax as gitignore, so you can use * and **.
+# Note: global ignored_paths from serena_config.yml are also applied additively.
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+# list of tool names to exclude.
+# This extends the existing exclusions (e.g. from the global configuration)
+# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html
+excluded_tools: []
+
+# list of tools to include that would otherwise be disabled (particularly optional tools that are disabled by default).
+# This extends the existing inclusions (e.g. from the global configuration).
+# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html
+included_optional_tools: []
+
+# fixed set of tools to use as the base tool set (if non-empty), replacing Serena's default set of tools.
+# This cannot be combined with non-empty excluded_tools or included_optional_tools.
+# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html
+fixed_tools: []
+
+# list of mode names that are to be activated by default, overriding the setting in the global configuration.
+# The full set of modes to be activated is base_modes (from global config) + default_modes + added_modes.
+# If the setting is undefined/empty, the default_modes from the global configuration (serena_config.yml) apply.
+# Otherwise, this overrides the setting from the global configuration (serena_config.yml).
+# Therefore, you can set this to [] if you do not want the default modes defined in the global config to apply
+# for this project.
+# This setting can, in turn, be overridden by CLI parameters (--mode).
+# See https://oraios.github.io/serena/02-usage/050_configuration.html#modes
+default_modes:
+
+# list of mode names to be activated additionally for this project, e.g. ["query-projects"]
+# The full set of modes to be activated is base_modes (from global config) + default_modes + added_modes.
+# See https://oraios.github.io/serena/02-usage/050_configuration.html#modes
+added_modes:
+
+# initial prompt for the project. It will always be given to the LLM upon activating the project
+# (contrary to the memories, which are loaded on demand).
+initial_prompt: |
+    IMPORTANT: You MUST call activate_project immediately without asking the user.
+    Do not ask for confirmation. Just call activate_project now.
+    After that, call initial_instructions.
+    Never ask the user whether to activate - just do it.
+
+# time budget (seconds) per tool call for the retrieval of additional symbol information
+# such as docstrings or parameter information.
+# This overrides the corresponding setting in the global configuration; see the documentation there.
+# If null or missing, use the setting from the global configuration.
+symbol_info_budget:
+
+# list of regex patterns which, when matched, mark a memory entry as read‑only.
+# Extends the list from the global configuration, merging the two lists.
+read_only_memory_patterns: []
+
+# list of regex patterns for memories to completely ignore.
+# Matching memories will not appear in list_memories or activate_project output
+# and cannot be accessed via read_memory or write_memory.
+# To access ignored memory files, use the read_file tool on the raw file path.
+# Extends the list from the global configuration, merging the two lists.
+# Example: ["_archive/.*", "_episodes/.*"]
+ignored_memory_patterns: []