diff --git a/.env b/.env
index 56a36f2fa40..127267ebaec 100644
--- a/.env
+++ b/.env
@@ -87,6 +87,7 @@ LEGISLATIVES_AVECVOUS_HOST=legislatives.avecvous.code
 RENAISSANCE_HOST=renaissance.code
 APP_RENAISSANCE_HOST=renaissance.code
 WEBHOOK_RENAISSANCE_HOST=webhook.renaissance.code
+WEBHOOK_PROXY_HOST=
 API_RENAISSANCE_HOST=api.renaissance.code
 RENAISSANCE_QRCODE_HOST=qr.renaissance.code
 
diff --git a/config/packages/security.yaml b/config/packages/security.yaml
index 2e381de0485..6038738cdda 100644
--- a/config/packages/security.yaml
+++ b/config/packages/security.yaml
@@ -69,6 +69,8 @@ security:
             - ROLE_APP_ADMIN_AUDIENCE_ALL
         ROLE_ADMIN_COMMUNICATION_QR_CODES:
             - ROLE_APP_ADMIN_QR_CODE_ALL
+        ROLE_ADMIN_COMMUNICATION_CHATBOTS:
+            - ROLE_APP_ADMIN_CHATBOT_CHATBOT_ALL
 
         ## Adhérents
         ROLE_ADMIN_ADHERENT_ADHERENTS:
@@ -309,12 +311,10 @@ security:
             - ROLE_APP_ADMIN_CLIENT_ALL
         ROLE_ADMIN_TECH_SCOPES:
             - ROLE_APP_ADMIN_SCOPE_ALL
-        ROLE_ADMIN_TECH_CHATBOTS:
-            - ROLE_APP_ADMIN_CHATBOT_CHATBOT_ALL
         ROLE_ADMIN_TECH_TELEGRAM_BOTS:
             - ROLE_APP_ADMIN_TELEGRAM_BOT_ALL
         ROLE_ADMIN_TECH_OPENAI_ASSISTANTS:
-            - ROLE_APP_ADMIN_OPEN_AI_ASSISTANT_ALL
+            - ROLE_APP_ADMIN_OPENAI_ASSISTANT_ALL
 
         ## Idées
         ROLE_ADMIN_IDEES_OLDOLF:
diff --git a/config/services.yaml b/config/services.yaml
index 0818af4be42..f9beecd5522 100644
--- a/config/services.yaml
+++ b/config/services.yaml
@@ -118,6 +118,10 @@ services:
             tags: ['app.acquisition_statistics.calculator']
         App\Adherent\Tag\TagGenerator\TagGeneratorInterface:
             tags: ['app.adherent.tag.generator']
+        App\Chatbot\Assistant\AssistantHandlerInterface:
+            tags: ['app.chatbot.assistant_handler']
+        App\Telegram\Update\UpdateHandlerInterface:
+            tags: ['app.telegram.update_handler']
 
     # Imports
     App\:
@@ -491,3 +495,11 @@ services:
     App\Adhesion\Handler\GenerateActivationCodeCommandHandler:
         arguments:
             $loginLinkHandler: '@security.authenticator.login_link_handler.main'
+
+    App\Chatbot\Assistant:
+        arguments:
+            $assistantHandlers: !tagged_iterator 'app.chatbot.assistant_handler'
+
+    App\Telegram\UpdateHandler:
+        arguments:
+            $updateHandlers: !tagged_iterator 'app.telegram.update_handler'
diff --git a/config/services/admin.xml b/config/services/admin.xml
index 87c34aff3bd..5fefa8b1deb 100644
--- a/config/services/admin.xml
+++ b/config/services/admin.xml
@@ -996,6 +996,14 @@
             <argument />
         </service>
 
+        <service id="app.admin.openai_assistant" class="App\Admin\OpenAI\AssistantAdmin">
+            <tag name="sonata.admin" manager-type="orm" label="Assistants OpenAI" group="Tech" />
+
+            <argument />
+            <argument>App\Entity\OpenAI\Assistant</argument>
+            <argument />
+        </service>
+
         <!--
         ######################################################
         # Formation
diff --git a/config/services_dev.yaml b/config/services_dev.yaml
index c48d6ed0a98..2a5d7136b4e 100644
--- a/config/services_dev.yaml
+++ b/config/services_dev.yaml
@@ -8,6 +8,7 @@ services:
     public: false
     bind:
       $environment: "%kernel.environment%"
+      $webhookProxyHost: "%env(WEBHOOK_PROXY_HOST)%"
 
   App\DataFixtures\:
     resource: '../src/DataFixtures/'
@@ -26,10 +27,6 @@ services:
 
   App\Ohme\ClientInterface: '@Tests\App\Ohme\DummyClient'
 
-  Tests\App\Chatbot\Provider\DummyProvider: ~
-
-  App\Chatbot\Provider\ProviderInterface: '@Tests\App\Chatbot\Provider\DummyProvider'
-
   App\Mandrill\EmailClient:
     class: 'Tests\App\Test\Mailer\NullEmailClient'
 
@@ -51,3 +48,14 @@ services:
 
   Kreait\Firebase\Contract\DynamicLinks: '@Tests\App\Test\Firebase\DummyDynamicLinks'
   Kreait\Firebase\Contract\Messaging: '@Tests\App\Test\Firebase\DummyMessaging'
+
+  Tests\App\OpenAI\Client\Client: ~
+  App\OpenAI\Client\ClientInterface: '@Tests\App\OpenAI\Client\Client'
+
+  Tests\App\Telegram\Client\ClientFactory: ~
+  App\Telegram\Client\ClientFactoryInterface: '@Tests\App\Telegram\Client\ClientFactory'
+
+  App\Telegram\Webhook\UrlGenerator: ~
+  Tests\App\Telegram\Webhook\ProxyUrlGenerator:
+      decorates: App\Telegram\Webhook\UrlGenerator
+      arguments: ['@.inner']
diff --git a/migrations/Version20240123003828.php b/migrations/Version20240204231024.php
similarity index 92%
rename from migrations/Version20240123003828.php
rename to migrations/Version20240204231024.php
index 25d56622ca2..e5a22282c08 100644
--- a/migrations/Version20240123003828.php
+++ b/migrations/Version20240204231024.php
@@ -5,13 +5,8 @@
 use Doctrine\DBAL\Schema\Schema;
 use Doctrine\Migrations\AbstractMigration;
 
-final class Version20240123003828 extends AbstractMigration
+final class Version20240204231024 extends AbstractMigration
 {
-    public function getDescription(): string
-    {
-        return '';
-    }
-
     public function up(Schema $schema): void
     {
         $this->addSql('CREATE TABLE openai_assistant (
@@ -19,12 +14,12 @@ public function up(Schema $schema): void
           created_by_administrator_id INT DEFAULT NULL,
           updated_by_administrator_id INT DEFAULT NULL,
           name VARCHAR(255) NOT NULL,
-          identifier VARCHAR(255) NOT NULL,
+          open_ai_id VARCHAR(255) NOT NULL,
           uuid CHAR(36) NOT NULL COMMENT \'(DC2Type:uuid)\',
           created_at DATETIME NOT NULL,
           updated_at DATETIME NOT NULL,
           UNIQUE INDEX UNIQ_55C6718E5E237E06 (name),
-          UNIQUE INDEX UNIQ_55C6718E772E836A (identifier),
+          UNIQUE INDEX UNIQ_55C6718EF6E32D4D (open_ai_id),
           UNIQUE INDEX UNIQ_55C6718ED17F50A6 (uuid),
           INDEX IDX_55C6718E9DF5350C (created_by_administrator_id),
           INDEX IDX_55C6718ECF1918FF (updated_by_administrator_id),
@@ -130,7 +125,12 @@ public function up(Schema $schema): void
         SET
           NULL');
         $this->addSql('CREATE INDEX IDX_EDF1E88484E3FEC4 ON chatbot_message (run_id)');
-        $this->addSql('ALTER TABLE chatbot_run CHANGE external_id open_ai_id VARCHAR(255) DEFAULT NULL');
+        $this->addSql('ALTER TABLE
+          chatbot_run
+        ADD
+          open_ai_id VARCHAR(255) DEFAULT NULL,
+        CHANGE
+          external_id open_ai_status VARCHAR(255) DEFAULT NULL');
         $this->addSql('ALTER TABLE chatbot_thread CHANGE external_id open_ai_id VARCHAR(255) DEFAULT NULL');
     }
 
@@ -182,7 +182,14 @@ public function down(Schema $schema): void
           text content LONGTEXT NOT NULL,
         CHANGE
           open_ai_id external_id VARCHAR(255) DEFAULT NULL');
-        $this->addSql('ALTER TABLE chatbot_run CHANGE open_ai_id external_id VARCHAR(255) DEFAULT NULL');
+        $this->addSql('ALTER TABLE
+          chatbot_run
+        ADD
+          external_id VARCHAR(255) DEFAULT NULL,
+        DROP
+          open_ai_status,
+        DROP
+          open_ai_id');
         $this->addSql('ALTER TABLE chatbot_thread CHANGE open_ai_id external_id VARCHAR(255) DEFAULT NULL');
     }
 }
diff --git a/src/Admin/Chatbot/ChatbotAdmin.php b/src/Admin/Chatbot/ChatbotAdmin.php
index 6c9cd7d6e93..f796d9387b0 100644
--- a/src/Admin/Chatbot/ChatbotAdmin.php
+++ b/src/Admin/Chatbot/ChatbotAdmin.php
@@ -41,6 +41,10 @@ protected function configureFormFields(FormMapper $form): void
                 ->add('assistantType', AssistantTypeEnumType::class, [
                     'label' => 'Type d\'assistant',
                 ])
+                ->add('openAiAssistant', ModelType::class, [
+                    'label' => 'Assistant OpenAI',
+                    'required' => false,
+                ])
             ->end()
         ;
     }
diff --git a/src/Admin/OpenAI/AssistantAdmin.php b/src/Admin/OpenAI/AssistantAdmin.php
new file mode 100644
index 00000000000..a1d28181bdf
--- /dev/null
+++ b/src/Admin/OpenAI/AssistantAdmin.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Admin\OpenAI;
+
+use Sonata\AdminBundle\Admin\AbstractAdmin;
+use Sonata\AdminBundle\Datagrid\DatagridMapper;
+use Sonata\AdminBundle\Datagrid\ListMapper;
+use Sonata\AdminBundle\Form\FormMapper;
+use Sonata\AdminBundle\Route\RouteCollectionInterface;
+use Symfony\Component\Form\Extension\Core\Type\TextType;
+
+class AssistantAdmin extends AbstractAdmin
+{
+    protected function configureRoutes(RouteCollectionInterface $collection): void
+    {
+        $collection->remove('show');
+    }
+
+    protected function configureFormFields(FormMapper $form): void
+    {
+        $form
+            ->with('Metadonnées 🧱', ['class' => 'col-md-6'])
+                ->add('name', TextType::class, [
+                    'label' => 'Nom',
+                ])
+                ->add('openAiId', TextType::class, [
+                    'label' => 'ID OpenAI',
+                ])
+            ->end()
+        ;
+    }
+
+    protected function configureDatagridFilters(DatagridMapper $filter): void
+    {
+        $filter
+            ->add('name', null, [
+                'label' => 'Nom',
+                'show_filter' => true,
+            ])
+            ->add('openAiId', null, [
+                'label' => 'ID OpenAI',
+                'show_filter' => true,
+            ])
+        ;
+    }
+
+    protected function configureListFields(ListMapper $list): void
+    {
+        $list
+            ->addIdentifier('name', null, [
+                'label' => 'Code',
+            ])
+            ->add('openAiId', null, [
+                'label' => 'ID OpenAI',
+            ])
+            ->add(ListMapper::NAME_ACTIONS, null, [
+                'virtual_field' => true,
+                'actions' => [
+                    'edit' => [],
+                ],
+            ])
+        ;
+    }
+}
diff --git a/src/Admin/TelegramBotAdmin.php b/src/Admin/TelegramBotAdmin.php
index 6337869a3be..176930ab9b9 100644
--- a/src/Admin/TelegramBotAdmin.php
+++ b/src/Admin/TelegramBotAdmin.php
@@ -2,7 +2,9 @@
 
 namespace App\Admin;
 
+use App\Entity\TelegramBot;
 use App\Form\Admin\StringArrayType;
+use App\Telegram\Webhook\UrlHandler;
 use Sonata\AdminBundle\Admin\AbstractAdmin;
 use Sonata\AdminBundle\Datagrid\DatagridMapper;
 use Sonata\AdminBundle\Datagrid\ListMapper;
@@ -13,6 +15,9 @@
 
 class TelegramBotAdmin extends AbstractAdmin
 {
+    private ?UrlHandler $webhookUrlHandler = null;
+    private ?TelegramBot $beforeUpdate = null;
+
     protected function configureRoutes(RouteCollectionInterface $collection): void
     {
         $collection->remove('show');
@@ -83,4 +88,55 @@ protected function configureListFields(ListMapper $list): void
             ])
         ;
     }
+
+    /**
+     * @param TelegramBot $object
+     */
+    protected function alterObject(object $object): void
+    {
+        if (null === $this->beforeUpdate) {
+            $this->beforeUpdate = clone $object;
+        }
+    }
+
+    /**
+     * @param TelegramBot $object
+     */
+    protected function prePersist(object $object): void
+    {
+        $object->generateSecret();
+
+        $this->webhookUrlHandler->setWebhook($object);
+    }
+
+    /**
+     * @param TelegramBot $object
+     */
+    protected function preUpdate(object $object): void
+    {
+        if (
+            $this->beforeUpdate
+            && ($this->beforeUpdate->getApiToken() !== $object->getApiToken())
+        ) {
+            $object->generateSecret();
+
+            $this->webhookUrlHandler->setWebhook($object);
+        }
+    }
+
+    /**
+     * @param TelegramBot $object
+     */
+    protected function preRemove(object $object): void
+    {
+        $this->webhookUrlHandler->removeWebhook($object);
+    }
+
+    /**
+     * @required
+     */
+    public function setWebhookUrlHandler(UrlHandler $webhookUrlHandler): void
+    {
+        $this->webhookUrlHandler = $webhookUrlHandler;
+    }
 }
diff --git a/src/Chatbot/Enum/RunStatusEnum.php b/src/Chatbot/Enum/RunStatusEnum.php
new file mode 100644
index 00000000000..50562aed2ea
--- /dev/null
+++ b/src/Chatbot/Enum/RunStatusEnum.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Chatbot\Enum;
+
+use App\OpenAI\Enum\RunStatusEnum as OpenAIRunStatusEnum;
+
+enum RunStatusEnum: string
+{
+    case QUEUED = 'queued';
+    case IN_PROGRESS = 'in_progress';
+    case CANCELLED = 'cancelled';
+    case FAILED = 'failed';
+    case COMPLETED = 'completed';
+    case UNKNOWN = 'unknown';
+
+    public const NEED_REFRESH = [
+        self::QUEUED,
+        self::IN_PROGRESS,
+    ];
+
+    public static function fromOpenAI(OpenAIRunStatusEnum $runStatus): self
+    {
+        return match ($runStatus) {
+            OpenAIRunStatusEnum::QUEUED => self::QUEUED,
+            OpenAIRunStatusEnum::IN_PROGRESS => self::IN_PROGRESS,
+            OpenAIRunStatusEnum::COMPLETED => self::COMPLETED,
+            OpenAIRunStatusEnum::CANCELLING, OpenAIRunStatusEnum::CANCELLED => self::CANCELLED,
+            OpenAIRunStatusEnum::REQUIRES_ACTION, OpenAIRunStatusEnum::EXPIRED, OpenAIRunStatusEnum::FAILED => self::FAILED,
+            default => self::UNKNOWN
+        };
+    }
+}
diff --git a/src/Chatbot/EventListener/OpenAIAssistantMessageListener.php b/src/Chatbot/EventListener/OpenAIAssistantMessageListener.php
new file mode 100644
index 00000000000..f1a85b08f43
--- /dev/null
+++ b/src/Chatbot/EventListener/OpenAIAssistantMessageListener.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Chatbot\EventListener;
+
+use App\Chatbot\Event\AssistantMessageEvent;
+use App\Entity\Chatbot\Message;
+use App\OpenAI\Event\AssistantMessageEvent as OpenAIAssistantMessageEvent;
+use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
+use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
+
+#[AsEventListener]
+class OpenAIAssistantMessageListener
+{
+    public function __construct(private readonly EventDispatcherInterface $dispatcher)
+    {
+    }
+
+    public function __invoke(OpenAIAssistantMessageEvent $event): void
+    {
+        $message = $event->message;
+
+        if (!$message instanceof Message) {
+            return;
+        }
+
+        $this->dispatcher->dispatch(new AssistantMessageEvent($message));
+    }
+}
diff --git a/src/Chatbot/EventListener/AssistantMessageListener.php b/src/Chatbot/EventListener/TelegramAssistantMessageListener.php
similarity index 88%
rename from src/Chatbot/EventListener/AssistantMessageListener.php
rename to src/Chatbot/EventListener/TelegramAssistantMessageListener.php
index 819f5e9aca7..e18861dc47c 100755
--- a/src/Chatbot/EventListener/AssistantMessageListener.php
+++ b/src/Chatbot/EventListener/TelegramAssistantMessageListener.php
@@ -5,9 +5,11 @@
 use App\Chatbot\Event\AssistantMessageEvent;
 use App\Telegram\Event\BotMessageEvent;
 use App\Telegram\Message;
+use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
 use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
 
-class AssistantMessageListener
+#[AsEventListener]
+class TelegramAssistantMessageListener
 {
     public function __construct(private readonly EventDispatcherInterface $dispatcher)
     {
diff --git a/src/Chatbot/EventListener/TelegramUserMessageListener.php b/src/Chatbot/EventListener/TelegramUserMessageListener.php
index 3ab0dde5e8b..a95789e9012 100755
--- a/src/Chatbot/EventListener/TelegramUserMessageListener.php
+++ b/src/Chatbot/EventListener/TelegramUserMessageListener.php
@@ -8,8 +8,10 @@
 use App\Repository\Chatbot\ChatbotRepository;
 use App\Repository\Chatbot\ThreadRepository;
 use App\Telegram\Event\UserMessageEvent as TelegramUserMessageEvent;
+use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
 use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
 
+#[AsEventListener]
 class TelegramUserMessageListener
 {
     public function __construct(
diff --git a/src/Chatbot/EventListener/UserMessageListener.php b/src/Chatbot/EventListener/UserMessageListener.php
index 81dce95dbd3..541b490fe55 100644
--- a/src/Chatbot/EventListener/UserMessageListener.php
+++ b/src/Chatbot/EventListener/UserMessageListener.php
@@ -4,7 +4,9 @@
 
 use App\Chatbot\Assistant;
 use App\Chatbot\Event\UserMessageEvent;
+use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
 
+#[AsEventListener]
 class UserMessageListener
 {
     public function __construct(private readonly Assistant $assistant)
diff --git a/src/Chatbot/ThreadFactory.php b/src/Chatbot/ThreadFactory.php
index a44e8965a6f..1bec9e0a31e 100755
--- a/src/Chatbot/ThreadFactory.php
+++ b/src/Chatbot/ThreadFactory.php
@@ -5,7 +5,6 @@
 use App\Chatbot\Enum\MessageRoleEnum;
 use App\Entity\Chatbot\Chatbot;
 use App\Entity\Chatbot\Message;
-use App\Entity\Chatbot\Run;
 use App\Entity\Chatbot\Thread;
 
 class ThreadFactory
@@ -27,28 +26,6 @@ public function createUserMessage(
         return $this->createMessage($thread, MessageRoleEnum::USER, $text, $entities, $date);
     }
 
-    public function createAssistantMessage(
-        Thread $thread,
-        string $text,
-        array $entities,
-        \DateTimeInterface $date
-    ): Message {
-        return $this->createMessage($thread, MessageRoleEnum::ASSISTANT, $text, $entities, $date);
-    }
-
-    public function createOpenAIAssistantMessage(
-        Thread $thread,
-        string $text,
-        array $annotations,
-        \DateTimeInterface $date,
-        Run $run
-    ): Message {
-        $message = $this->createMessage($thread, MessageRoleEnum::ASSISTANT, $text, $annotations, $date);
-        $message->run = $run;
-
-        return $message;
-    }
-
     private function createThread(Chatbot $chatbot): Thread
     {
         $thread = new Thread();
diff --git a/src/Controller/Webhook/TelegramBotController.php b/src/Controller/Webhook/TelegramBotController.php
index c7f6c0f43e7..0b707d58802 100755
--- a/src/Controller/Webhook/TelegramBotController.php
+++ b/src/Controller/Webhook/TelegramBotController.php
@@ -2,25 +2,23 @@
 
 namespace App\Controller\Webhook;
 
-use App\Entity\TelegramBot;
 use App\Telegram\WebhookRequestHandler;
-use Sensio\Bundle\FrameworkExtraBundle\Configuration\Entity;
 use Symfony\Component\HttpFoundation\JsonResponse;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\Routing\Annotation\Route;
 
-#[Route('/telegram/{secret}', name: self::ROUTE_NAME, methods: ['POST'])]
-#[Entity('telegramBot', expr: 'repository.findOneEnabledBySecret(secret)')]
+#[Route(self::ROUTE_PATH, name: self::ROUTE_NAME, methods: ['POST'])]
 class TelegramBotController
 {
     public const ROUTE_NAME = 'webhook_telegram_bot';
+    public const ROUTE_PATH = '/telegram';
 
     public function __construct(private readonly WebhookRequestHandler $requestHandler)
     {
     }
 
-    public function __invoke(TelegramBot $telegramBot, Request $request): JsonResponse
+    public function __invoke(Request $request): JsonResponse
     {
-        return $this->requestHandler->handle($telegramBot, $request);
+        return $this->requestHandler->handle($request);
     }
 }
diff --git a/src/DataFixtures/ORM/LoadAdministratorRoleData.php b/src/DataFixtures/ORM/LoadAdministratorRoleData.php
index fcb8fe9ace6..be30eaaa7ab 100644
--- a/src/DataFixtures/ORM/LoadAdministratorRoleData.php
+++ b/src/DataFixtures/ORM/LoadAdministratorRoleData.php
@@ -571,6 +571,16 @@ private function getRoles(): \Generator
             'Administrateur des scopes',
             AdministratorRoleGroupEnum::TECH
         );
+        yield $this->createRole(
+            'ROLE_ADMIN_TECH_TELEGRAM_BOTS',
+            'Administrateur des Bots Telegram',
+            AdministratorRoleGroupEnum::TECH
+        );
+        yield $this->createRole(
+            'ROLE_ADMIN_TECH_OPENAI_ASSISTANTS',
+            'Administrateur des Assistants OpenAI',
+            AdministratorRoleGroupEnum::TECH
+        );
         // Idées
         yield $this->createRole(
             'ROLE_ADMIN_IDEES_OLDOLF',
diff --git a/src/DataFixtures/ORM/LoadChatbotData.php b/src/DataFixtures/ORM/LoadChatbotData.php
index c300110f403..d4c4156755f 100644
--- a/src/DataFixtures/ORM/LoadChatbotData.php
+++ b/src/DataFixtures/ORM/LoadChatbotData.php
@@ -42,8 +42,8 @@ private function createChatbot(
         string $code,
         ChatbotTypeEnum $type,
         AssistantTypeEnum $assistantType,
-        TelegramBot $telegramBot = null,
-        OpenAIAssistant $openAiAssistant = null
+        ?TelegramBot $telegramBot = null,
+        ?OpenAIAssistant $openAiAssistant = null
     ): Chatbot {
         $chatbot = new Chatbot();
         $chatbot->name = $code;
diff --git a/src/DataFixtures/ORM/LoadOpenAIAssistantData.php b/src/DataFixtures/ORM/LoadOpenAIAssistantData.php
index 5d08f27b654..145bd848510 100644
--- a/src/DataFixtures/ORM/LoadOpenAIAssistantData.php
+++ b/src/DataFixtures/ORM/LoadOpenAIAssistantData.php
@@ -13,7 +13,7 @@ public function load(ObjectManager $manager)
         foreach ($this->getAssistants() as $key => $data) {
             $assistant = $this->createAssistant(
                 $data['name'],
-                $data['identifier']
+                $data['openAiId']
             );
 
             $manager->persist($assistant);
@@ -26,11 +26,11 @@ public function load(ObjectManager $manager)
 
     private function createAssistant(
         string $name,
-        string $identifier
+        string $openAiId
     ): Assistant {
         $assistant = new Assistant();
         $assistant->name = $name;
-        $assistant->identifier = $identifier;
+        $assistant->openAiId = $openAiId;
 
         return $assistant;
     }
@@ -39,12 +39,12 @@ private function getAssistants(): \Generator
     {
         yield 'openai-assistant-1' => [
             'name' => 'Assistant #1',
-            'identifier' => 'assistant-1-identifier',
+            'openAiId' => 'assistant-1-identifier',
         ];
 
         yield 'openai-assistant-2' => [
             'name' => 'Assistant #2',
-            'identifier' => 'assistant-2-identifier',
+            'openAiId' => 'assistant-2-identifier',
         ];
     }
 }
diff --git a/src/Entity/Chatbot/Chatbot.php b/src/Entity/Chatbot/Chatbot.php
index 6932e462636..2be540849f1 100644
--- a/src/Entity/Chatbot/Chatbot.php
+++ b/src/Entity/Chatbot/Chatbot.php
@@ -80,6 +80,11 @@ public function isOpenAIAssistant(): bool
         return AssistantTypeEnum::OPENAI === $this->assistantType;
     }
 
+    public function getOpenAiAssistant(): ?OpenAIAssistant
+    {
+        return $this->openAiAssistant;
+    }
+
     public function isTelegramBot(): bool
     {
         return ChatbotTypeEnum::TELEGRAM === $this->type;
diff --git a/src/Entity/Chatbot/Message.php b/src/Entity/Chatbot/Message.php
index 91b6c2298ec..3c7eb9fa2e6 100644
--- a/src/Entity/Chatbot/Message.php
+++ b/src/Entity/Chatbot/Message.php
@@ -6,6 +6,8 @@
 use App\Entity\EntityIdentityTrait;
 use App\Entity\EntityTimestampableTrait;
 use App\Entity\OpenAI\OpenAIResourceTrait;
+use App\OpenAI\Model\MessageInterface;
+use App\OpenAI\Model\ThreadInterface;
 use Doctrine\ORM\Mapping as ORM;
 use Ramsey\Uuid\Uuid;
 use Ramsey\Uuid\UuidInterface;
@@ -15,7 +17,7 @@
  * @ORM\Entity(repositoryClass="App\Repository\Chatbot\MessageRepository")
  * @ORM\Table(name="chatbot_message")
  */
-class Message
+class Message implements MessageInterface
 {
     use EntityIdentityTrait;
     use EntityTimestampableTrait;
@@ -61,7 +63,7 @@ class Message
      */
     public ?Run $run = null;
 
-    public function __construct(UuidInterface $uuid = null)
+    public function __construct(?UuidInterface $uuid = null)
     {
         $this->uuid = $uuid ?? Uuid::uuid4();
     }
@@ -70,4 +72,14 @@ public function isUserMessage(): bool
     {
         return MessageRoleEnum::USER === $this->role;
     }
+
+    public function getThread(): ThreadInterface
+    {
+        return $this->thread;
+    }
+
+    public function getText(): string
+    {
+        return $this->text;
+    }
 }
diff --git a/src/Entity/Chatbot/Run.php b/src/Entity/Chatbot/Run.php
index 0942fc715f6..594fe8a536f 100644
--- a/src/Entity/Chatbot/Run.php
+++ b/src/Entity/Chatbot/Run.php
@@ -2,19 +2,22 @@
 
 namespace App\Entity\Chatbot;
 
+use App\Chatbot\Enum\RunStatusEnum;
 use App\Entity\EntityIdentityTrait;
 use App\Entity\EntityTimestampableTrait;
 use App\Entity\OpenAI\OpenAIResourceTrait;
-use App\OpenAI\Enum\RunStatusEnum;
+use App\OpenAI\Enum\RunStatusEnum as OpenAIRunStatusEnum;
+use App\OpenAI\Model\RunInterface;
+use App\OpenAI\Model\ThreadInterface;
 use Doctrine\ORM\Mapping as ORM;
 use Ramsey\Uuid\Uuid;
 use Ramsey\Uuid\UuidInterface;
 
 /**
- * @ORM\Entity
+ * @ORM\Entity(repositoryClass="App\Repository\Chatbot\RunRepository")
  * @ORM\Table(name="chatbot_run")
  */
-class Run
+class Run implements RunInterface
 {
     use EntityIdentityTrait;
     use EntityTimestampableTrait;
@@ -29,13 +32,24 @@ class Run
     /**
      * @ORM\Column(enumType=RunStatusEnum::class)
      */
-    public ?RunStatusEnum $status = RunStatusEnum::QUEUED;
+    public RunStatusEnum $status = RunStatusEnum::QUEUED;
+
+    /**
+     * @ORM\Column(enumType=OpenAIRunStatusEnum::class, nullable=true)
+     */
+    public ?OpenAIRunStatusEnum $openAiStatus = null;
 
     public function __construct(?UuidInterface $uuid = null)
     {
         $this->uuid = $uuid ?? Uuid::uuid4();
     }
 
+    public function updateOpenAiStatus(OpenAIRunStatusEnum $openAiStatus): void
+    {
+        $this->status = RunStatusEnum::fromOpenAI($openAiStatus);
+        $this->openAiStatus = $openAiStatus;
+    }
+
     public function needRefresh(): bool
     {
         return \in_array($this->status, RunStatusEnum::NEED_REFRESH, true);
@@ -54,5 +68,11 @@ public function isCompleted(): bool
     public function cancel(): void
     {
         $this->status = RunStatusEnum::CANCELLED;
+        $this->openAiStatus = null;
+    }
+
+    public function getThread(): ThreadInterface
+    {
+        return $this->thread;
     }
 }
diff --git a/src/Entity/Chatbot/Thread.php b/src/Entity/Chatbot/Thread.php
index 305f120089a..95444792c66 100644
--- a/src/Entity/Chatbot/Thread.php
+++ b/src/Entity/Chatbot/Thread.php
@@ -6,6 +6,8 @@
 use App\Entity\EntityIdentityTrait;
 use App\Entity\EntityTimestampableTrait;
 use App\Entity\OpenAI\OpenAIResourceTrait;
+use App\OpenAI\Model\RunInterface;
+use App\OpenAI\Model\ThreadInterface;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
@@ -17,7 +19,7 @@
  * @ORM\Entity(repositoryClass="App\Repository\Chatbot\ThreadRepository")
  * @ORM\Table(name="chatbot_thread")
  */
-class Thread
+class Thread implements ThreadInterface
 {
     use EntityIdentityTrait;
     use EntityTimestampableTrait;
@@ -67,11 +69,17 @@ public function __construct(?UuidInterface $uuid = null)
         $this->messages = new ArrayCollection();
     }
 
+    public function getIdentifier(): string
+    {
+        return $this->uuid->toString();
+    }
+
     public function getMessagesToInitializeOnOpenAi(): Collection
     {
         return $this->messages->filter(
             static function (Message $message): bool {
-                return null !== $message->openAiId;
+                return $message->isUserMessage()
+                    && null === $message->openAiId;
             }
         );
     }
@@ -79,7 +87,7 @@ static function (Message $message): bool {
     public function hasMessageWithOpenAiId(string $openAiId): bool
     {
         return null !== $this->messages->findFirst(
-            static function (Message $message) use ($openAiId): bool {
+            static function (int $key, Message $message) use ($openAiId): bool {
                 return $openAiId === $message->openAiId;
             }
         );
@@ -89,4 +97,22 @@ public function hasCurrentRun(): bool
     {
         return null !== $this->currentRun;
     }
+
+    public function removeCurrentRun(): void
+    {
+        $this->currentRun = null;
+    }
+
+    public function createCurrentRun(): void
+    {
+        $run = new Run();
+        $run->thread = $this;
+
+        $this->currentRun = $run;
+    }
+
+    public function getCurrentRun(): ?RunInterface
+    {
+        return $this->currentRun;
+    }
 }
diff --git a/src/Entity/OpenAI/Assistant.php b/src/Entity/OpenAI/Assistant.php
index 8ee702c98d2..0fd3347c541 100644
--- a/src/Entity/OpenAI/Assistant.php
+++ b/src/Entity/OpenAI/Assistant.php
@@ -5,7 +5,7 @@
 use App\Entity\EntityAdministratorBlameableTrait;
 use App\Entity\EntityIdentityTrait;
 use App\Entity\EntityTimestampableTrait;
-use App\OpenAI\AssistantInterface;
+use App\OpenAI\Model\AssistantInterface;
 use Doctrine\ORM\Mapping as ORM;
 use Ramsey\Uuid\Uuid;
 use Ramsey\Uuid\UuidInterface;
@@ -17,7 +17,6 @@
  * @ORM\Table(name="openai_assistant")
  *
  * @UniqueEntity(fields={"name"})
- * @UniqueEntity(fields={"identifier"})
  */
 class Assistant implements AssistantInterface
 {
@@ -37,9 +36,9 @@ class Assistant implements AssistantInterface
      *
      * @Assert\NotBlank
      */
-    public ?string $identifier = null;
+    public ?string $openAiId = null;
 
-    public function __construct(UuidInterface $uuid = null)
+    public function __construct(?UuidInterface $uuid = null)
     {
         $this->uuid = $uuid ?? Uuid::uuid4();
     }
@@ -51,6 +50,11 @@ public function __toString(): string
 
     public function getIdentifier(): string
     {
-        return $this->identifier;
+        return $this->uuid->toString();
+    }
+
+    public function getOpenAiId(): string
+    {
+        return $this->openAiId;
     }
 }
diff --git a/src/Entity/OpenAI/OpenAIResourceTrait.php b/src/Entity/OpenAI/OpenAIResourceTrait.php
index f99328ff99d..5bf4079cc60 100755
--- a/src/Entity/OpenAI/OpenAIResourceTrait.php
+++ b/src/Entity/OpenAI/OpenAIResourceTrait.php
@@ -10,4 +10,19 @@ trait OpenAIResourceTrait
      * @ORM\Column(nullable=true)
      */
     public ?string $openAiId = null;
+
+    public function setOpenAiId(string $openAiId): void
+    {
+        $this->openAiId = $openAiId;
+    }
+
+    public function hasOpenAiId(): bool
+    {
+        return null !== $this->openAiId;
+    }
+
+    public function getOpenAiId(): ?string
+    {
+        return $this->openAiId;
+    }
 }
diff --git a/src/Entity/TelegramBot.php b/src/Entity/TelegramBot.php
index af5d91e90b5..ba11c49784b 100644
--- a/src/Entity/TelegramBot.php
+++ b/src/Entity/TelegramBot.php
@@ -69,10 +69,9 @@ class TelegramBot implements BotInterface
      */
     public array $whitelistedIds = [];
 
-    public function __construct(UuidInterface $uuid = null)
+    public function __construct(?UuidInterface $uuid = null)
     {
         $this->uuid = $uuid ?? Uuid::uuid4();
-        $this->secret = Uuid::uuid4();
     }
 
     public function __toString(): string
@@ -109,4 +108,9 @@ public function getWhitelistedChatIds(): array
     {
         return $this->whitelistedIds;
     }
+
+    public function generateSecret(): void
+    {
+        $this->secret = Uuid::uuid4();
+    }
 }
diff --git a/src/OpenAI/AssistantProviderInterface.php b/src/OpenAI/AssistantProviderInterface.php
deleted file mode 100644
index c61cb456afe..00000000000
--- a/src/OpenAI/AssistantProviderInterface.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php
-
-namespace App\OpenAI;
-
-interface AssistantProviderInterface
-{
-    public function loadByIdentifier(string $identifier): ?AssistantInterface;
-}
diff --git a/src/OpenAI/Client/Client.php b/src/OpenAI/Client/Client.php
index 4b6defd50be..fb076416a8e 100755
--- a/src/OpenAI/Client/Client.php
+++ b/src/OpenAI/Client/Client.php
@@ -46,7 +46,7 @@ public function getRunStatus(string $threadId, string $runId): RunStatusEnum
     {
         $runResponse = $this->openAI->threads()->runs()->retrieve($threadId, $runId);
 
-        return RunStatusEnum::tryFrom($runResponse->status) ?? RunStatusEnum::ERROR;
+        return RunStatusEnum::tryFrom($runResponse->status) ?? RunStatusEnum::UNKNOWN;
     }
 
     public function cancelRun(string $threadId, string $runId): void
diff --git a/src/OpenAI/Enum/RunStatusEnum.php b/src/OpenAI/Enum/RunStatusEnum.php
index 99efb896d7f..75ef2c87768 100755
--- a/src/OpenAI/Enum/RunStatusEnum.php
+++ b/src/OpenAI/Enum/RunStatusEnum.php
@@ -12,10 +12,5 @@ enum RunStatusEnum: string
     case FAILED = 'failed';
     case COMPLETED = 'completed';
     case EXPIRED = 'expired';
-    case ERROR = 'error';
-
-    public const NEED_REFRESH = [
-        self::QUEUED,
-        self::IN_PROGRESS,
-    ];
+    case UNKNOWN = 'unknown';
 }
diff --git a/src/OpenAI/Event/AssistantMessageEvent.php b/src/OpenAI/Event/AssistantMessageEvent.php
new file mode 100644
index 00000000000..a206c5324dc
--- /dev/null
+++ b/src/OpenAI/Event/AssistantMessageEvent.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\OpenAI\Event;
+
+use App\OpenAI\Model\MessageInterface;
+
+class AssistantMessageEvent
+{
+    public function __construct(public readonly MessageInterface $message)
+    {
+    }
+}
diff --git a/src/OpenAI/Event/ThreadEvent.php b/src/OpenAI/Event/ThreadEvent.php
index 95713357689..6daf0fa70b3 100644
--- a/src/OpenAI/Event/ThreadEvent.php
+++ b/src/OpenAI/Event/ThreadEvent.php
@@ -2,13 +2,13 @@
 
 namespace App\OpenAI\Event;
 
-use App\Entity\Chatbot\Thread;
-use App\OpenAI\AssistantInterface;
+use App\OpenAI\Model\AssistantInterface;
+use App\OpenAI\Model\ThreadInterface;
 
 class ThreadEvent
 {
     public function __construct(
-        public readonly Thread $thread,
+        public readonly ThreadInterface $thread,
         public readonly AssistantInterface $assistant
     ) {
     }
diff --git a/src/OpenAI/EventListener/ThreadListener.php b/src/OpenAI/EventListener/ThreadListener.php
index 9a98f94c6b8..83f3804e6d2 100644
--- a/src/OpenAI/EventListener/ThreadListener.php
+++ b/src/OpenAI/EventListener/ThreadListener.php
@@ -4,8 +4,10 @@
 
 use App\OpenAI\Command\RunThreadCommand;
 use App\OpenAI\Event\ThreadEvent;
+use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
 use Symfony\Component\Messenger\MessageBusInterface;
 
+#[AsEventListener]
 class ThreadListener
 {
     public function __construct(private readonly MessageBusInterface $bus)
diff --git a/src/OpenAI/Handler/RunThreadCommandHandler.php b/src/OpenAI/Handler/RunThreadCommandHandler.php
index 715d5955058..03654b9dc86 100644
--- a/src/OpenAI/Handler/RunThreadCommandHandler.php
+++ b/src/OpenAI/Handler/RunThreadCommandHandler.php
@@ -6,34 +6,37 @@
 use App\OpenAI\Exception\RunNeedRefreshException;
 use App\OpenAI\Logger;
 use App\OpenAI\OpenAI;
-use App\Repository\Chatbot\ThreadRepository;
-use App\Repository\OpenAI\AssistantRepository;
+use App\OpenAI\Provider\AssistantProviderInterface;
+use App\OpenAI\Provider\ThreadProviderInterface;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
 
+#[AsMessageHandler]
 class RunThreadCommandHandler
 {
     public function __construct(
-        public readonly ThreadRepository $threadRepository,
-        public readonly AssistantRepository $assistantRepository,
-        public readonly OpenAI $openAI,
-        public readonly Logger $logger
+        private readonly ThreadProviderInterface $threadProvider,
+        private readonly AssistantProviderInterface $assistantProvider,
+        private readonly OpenAI $openAI,
+        private readonly Logger $logger
     ) {
     }
 
     public function __invoke(RunThreadCommand $command): void
     {
-        $thread = $this->threadRepository->findOneByUuid($command->threadIdentifier);
+        $thread = $this->threadProvider->findOneByIdentifier($command->threadIdentifier);
 
         if (!$thread) {
             return;
         }
 
-        $assistant = $this->assistantRepository->loadByIdentifier($command->assistantIdentifier);
+        $assistant = $this->assistantProvider->loadByIdentifier($command->assistantIdentifier);
 
         if (!$assistant) {
             return;
         }
 
-        $this->threadRepository->refresh($thread);
+        $this->threadProvider->refresh($thread);
+        $this->assistantProvider->refresh($assistant);
 
         $this->logger->log($thread, 'Starting handler.');
 
diff --git a/src/OpenAI/Logger.php b/src/OpenAI/Logger.php
index bd752e180f5..78675986bf3 100644
--- a/src/OpenAI/Logger.php
+++ b/src/OpenAI/Logger.php
@@ -2,7 +2,7 @@
 
 namespace App\OpenAI;
 
-use App\Entity\Chatbot\Thread;
+use App\OpenAI\Model\ThreadInterface;
 use Psr\Log\LoggerAwareInterface;
 use Psr\Log\LoggerAwareTrait;
 use Psr\Log\LoggerInterface;
@@ -16,12 +16,12 @@ public function __construct(LoggerInterface $logger)
         $this->logger = $logger;
     }
 
-    public function log(Thread $thread, string $message): void
+    public function log(ThreadInterface $thread, string $message): void
     {
         $this->logger->info(
             sprintf(
                 '[OpenAI][Thread:%s] %s',
-                $thread->getUuid()->toString(),
+                $thread->getIdentifier(),
                 $message
             )
         );
diff --git a/src/OpenAI/AssistantInterface.php b/src/OpenAI/Model/AssistantInterface.php
similarity index 54%
rename from src/OpenAI/AssistantInterface.php
rename to src/OpenAI/Model/AssistantInterface.php
index 3206be198fb..d1663c8bcd5 100644
--- a/src/OpenAI/AssistantInterface.php
+++ b/src/OpenAI/Model/AssistantInterface.php
@@ -1,8 +1,10 @@
 <?php
 
-namespace App\OpenAI;
+namespace App\OpenAI\Model;
 
 interface AssistantInterface
 {
     public function getIdentifier(): string;
+
+    public function getOpenAiId(): string;
 }
diff --git a/src/OpenAI/Model/MessageInterface.php b/src/OpenAI/Model/MessageInterface.php
new file mode 100644
index 00000000000..d3a76430408
--- /dev/null
+++ b/src/OpenAI/Model/MessageInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace App\OpenAI\Model;
+
+interface MessageInterface extends OpenAIResourceInterface
+{
+    public function getThread(): ThreadInterface;
+
+    public function getText(): string;
+}
diff --git a/src/OpenAI/Model/OpenAIResourceInterface.php b/src/OpenAI/Model/OpenAIResourceInterface.php
new file mode 100644
index 00000000000..bbab5820249
--- /dev/null
+++ b/src/OpenAI/Model/OpenAIResourceInterface.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\OpenAI\Model;
+
+interface OpenAIResourceInterface
+{
+    public function setOpenAiId(string $openAiId): void;
+
+    public function hasOpenAiId(): bool;
+
+    public function getOpenAiId(): ?string;
+}
diff --git a/src/OpenAI/Model/RunInterface.php b/src/OpenAI/Model/RunInterface.php
new file mode 100644
index 00000000000..8b0efad9aab
--- /dev/null
+++ b/src/OpenAI/Model/RunInterface.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\OpenAI\Model;
+
+use App\OpenAI\Enum\RunStatusEnum;
+
+interface RunInterface extends OpenAIResourceInterface
+{
+    public function getThread(): ThreadInterface;
+
+    public function needRefresh(): bool;
+
+    public function isInProgress(): bool;
+
+    public function isCompleted(): bool;
+
+    public function cancel(): void;
+
+    public function updateOpenAiStatus(RunStatusEnum $openAiStatus): void;
+}
diff --git a/src/OpenAI/Model/ThreadInterface.php b/src/OpenAI/Model/ThreadInterface.php
new file mode 100644
index 00000000000..7a67651e2cb
--- /dev/null
+++ b/src/OpenAI/Model/ThreadInterface.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\OpenAI\Model;
+
+use Doctrine\Common\Collections\Collection;
+
+interface ThreadInterface extends OpenAIResourceInterface
+{
+    public function getIdentifier(): string;
+
+    public function hasCurrentRun(): bool;
+
+    public function removeCurrentRun(): void;
+
+    public function createCurrentRun(): void;
+
+    public function getCurrentRun(): ?RunInterface;
+
+    public function getMessagesToInitializeOnOpenAi(): Collection;
+
+    public function hasMessageWithOpenAiId(string $openAiId): bool;
+}
diff --git a/src/OpenAI/OpenAI.php b/src/OpenAI/OpenAI.php
index 92a97d56ebb..a8fccc6ed42 100755
--- a/src/OpenAI/OpenAI.php
+++ b/src/OpenAI/OpenAI.php
@@ -2,180 +2,178 @@
 
 namespace App\OpenAI;
 
-use App\Chatbot\Event\AssistantMessageEvent;
-use App\Chatbot\ThreadFactory;
-use App\Entity\Chatbot\Message;
-use App\Entity\Chatbot\Run;
-use App\Entity\Chatbot\Thread;
 use App\OpenAI\Client\ClientInterface;
+use App\OpenAI\Event\AssistantMessageEvent;
 use App\OpenAI\Exception\RunNotInitializedException;
 use App\OpenAI\Exception\ThreadNotInitializedException;
-use App\Repository\Chatbot\MessageRepository;
-use App\Repository\Chatbot\RunRepository;
-use App\Repository\Chatbot\ThreadRepository;
+use App\OpenAI\Model\AssistantInterface;
+use App\OpenAI\Model\MessageInterface;
+use App\OpenAI\Model\RunInterface;
+use App\OpenAI\Model\ThreadInterface;
+use App\OpenAI\Provider\MessageProviderInterface;
+use App\OpenAI\Provider\RunProviderInterface;
+use App\OpenAI\Provider\ThreadProviderInterface;
 use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
 
 class OpenAI
 {
     public function __construct(
         private readonly ClientInterface $client,
-        private readonly ThreadFactory $threadFactory,
-        private readonly ThreadRepository $threadRepository,
-        private readonly MessageRepository $messageRepository,
-        private readonly RunRepository $runRepository,
+        private readonly ThreadProviderInterface $threadProvider,
+        private readonly MessageProviderInterface $messageProvider,
+        private readonly RunProviderInterface $runProvider,
         private readonly EventDispatcherInterface $dispatcher
     ) {
     }
 
-    public function cancelCurrentRun(Thread $thread): void
+    public function cancelCurrentRun(ThreadInterface $thread): void
     {
-        if (!$run = $thread->currentRun) {
+        if (!$run = $thread->getCurrentRun()) {
             return;
         }
 
-        $thread->currentRun = null;
+        $thread->removeCurrentRun();
 
-        $this->threadRepository->save($thread);
+        $this->threadProvider->save($thread);
 
         $this->cancelRun($run);
     }
 
-    public function createRun(Thread $thread, AssistantInterface $assistant): void
+    public function createRun(ThreadInterface $thread, AssistantInterface $assistant): void
     {
         $this->assertThreadInitialized($thread);
 
-        $run = new Run();
-        $run->thread = $thread;
+        $thread->createCurrentRun();
 
-        $this->runRepository->save($run);
+        $this->threadProvider->save($thread);
 
-        $thread->currentRun = $run;
-
-        $this->threadRepository->save($thread);
-
-        $this->initializeRun($run, $assistant);
+        $this->initializeRun($thread->getCurrentRun(), $assistant);
     }
 
-    public function createUserMessage(Message $message): void
+    public function createUserMessage(MessageInterface $message): void
     {
-        $thread = $message->thread;
+        $thread = $message->getThread();
 
-        if (!$thread->openAiId) {
+        if (!$thread->hasOpenAiId()) {
             $this->initializeThread($thread);
         }
 
         $this->initializeMessage($message);
     }
 
-    public function refreshRun(Thread $thread): void
+    public function refreshRun(ThreadInterface $thread): void
     {
-        if (!$run = $thread->currentRun) {
+        if (!$run = $thread->getCurrentRun()) {
             return;
         }
 
         $this->refreshRunStatus($run);
 
         if (!$run->needRefresh()) {
-            $thread->currentRun = null;
+            $thread->removeCurrentRun();
 
-            $this->threadRepository->save($thread);
+            $this->threadProvider->save($thread);
         }
     }
 
-    public function refreshRunStatus(Run $run): void
+    public function refreshRunStatus(RunInterface $run): void
     {
         $this->assertRunInitialized($run);
 
-        $runStatus = $this->client->getRunStatus(
+        $openAiRunStatus = $this->client->getRunStatus(
             $run->thread->openAiId,
             $run->openAiId
         );
 
-        $run->status = $runStatus;
+        $run->updateOpenAiStatus($openAiRunStatus);
 
-        $this->runRepository->save($run);
+        $this->runProvider->save($run);
     }
 
-    public function retrieveAssistantMessages(Thread $thread): void
+    public function retrieveAssistantMessages(ThreadInterface $thread): void
     {
         $this->assertThreadInitialized($thread);
 
-        $newMessages = $this->client->getMessages($thread->openAiId);
+        $newMessages = $this->client->getMessages($thread->getOpenAiId());
 
-        foreach ($newMessages as $message) {
-            if ($message->isUserMessage()) {
+        foreach ($newMessages as $messageResponse) {
+            if ($messageResponse->isUserMessage()) {
                 continue;
             }
 
-            if ($thread->hasMessageWithOpenAiId($message->id)) {
+            if ($thread->hasMessageWithOpenAiId($messageResponse->id)) {
                 continue;
             }
 
-            $message = $this->threadFactory->createOpenAIAssistantMessage(
+            $message = $this->messageProvider->createAssistantMessage(
                 $thread,
-                $message->text,
-                $message->annotations,
-                $message->date,
-                $message->runId ? $this->runRepository->findOneByOpenAiId($message->runId) : null
+                $messageResponse->id,
+                $messageResponse->text,
+                $messageResponse->annotations,
+                $messageResponse->date,
+                $messageResponse->runId ? $this->runProvider->findOneByOpenAiId($messageResponse->runId) : null
             );
 
-            $this->messageRepository->save($message);
+            $this->messageProvider->save($message);
 
             $this->dispatcher->dispatch(new AssistantMessageEvent($message));
         }
     }
 
-    private function assertThreadInitialized(Thread $thread): void
+    private function assertThreadInitialized(ThreadInterface $thread): void
     {
-        if (!$thread->openAiId) {
+        if (!$thread->hasOpenAiId()) {
             throw new ThreadNotInitializedException();
         }
     }
 
-    private function assertRunInitialized(Run $run): void
+    private function assertRunInitialized(RunInterface $run): void
     {
-        $this->assertThreadInitialized($run->thread);
+        $this->assertThreadInitialized($run->getThread());
 
-        if (!$run->openAiId) {
+        if (!$run->hasOpenAiId()) {
             throw new RunNotInitializedException();
         }
     }
 
-    private function initializeThread(Thread $thread): void
+    private function initializeThread(ThreadInterface $thread): void
     {
-        $thread->openAiId = $this->client->createThread();
+        $thread->setOpenAiId($this->client->createThread());
 
-        $this->threadRepository->save($thread);
+        $this->threadProvider->save($thread);
     }
 
-    private function initializeMessage(Message $message): void
+    private function initializeMessage(MessageInterface $message): void
     {
-        $message->openAiId = $this->client->createUserMessage($message->thread->openAiId, $message->text);
+        $message->openAiId = $this->client->createUserMessage(
+            $message->getThread()->getOpenAiId(),
+            $message->getText()
+        );
 
-        $this->messageRepository->save($message);
+        $this->messageProvider->save($message);
     }
 
-    private function initializeRun(Run $run, AssistantInterface $assistant): void
+    private function initializeRun(RunInterface $run, AssistantInterface $assistant): void
     {
-        $run->openAiId = $this->client->createRun($run->thread->openAiId, $assistant->getIdentifier());
+        $run->openAiId = $this->client->createRun($run->getThread()->getOpenAiId(), $assistant->getOpenAiId());
 
-        $this->runRepository->save($run);
+        $this->runProvider->save($run);
     }
 
-    private function cancelRun(Run $run): void
+    private function cancelRun(RunInterface $run): void
     {
-        $thread = $run->thread;
+        $thread = $run->getThread();
 
         if (
-            $thread->openAiId
-            && $run->openAiId
+            $thread->hasOpenAiId()
+            && $run->hasOpenAiId()
             && $run->isInProgress()
         ) {
-            $this->client->cancelRun($thread->openAiId, $run->openAiId);
+            $this->client->cancelRun($thread->getOpenAiId(), $run->getOpenAiId());
         }
 
         $run->cancel();
 
-        $this->runRepository->save($run);
+        $this->runProvider->save($run);
     }
 }
diff --git a/src/OpenAI/Provider/AssistantProviderInterface.php b/src/OpenAI/Provider/AssistantProviderInterface.php
new file mode 100644
index 00000000000..0ffcad558eb
--- /dev/null
+++ b/src/OpenAI/Provider/AssistantProviderInterface.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\OpenAI\Provider;
+
+use App\OpenAI\Model\AssistantInterface;
+
+interface AssistantProviderInterface
+{
+    public function loadByIdentifier(string $identifier): ?AssistantInterface;
+
+    public function refresh(AssistantInterface $assistant): void;
+}
diff --git a/src/OpenAI/Provider/MessageProviderInterface.php b/src/OpenAI/Provider/MessageProviderInterface.php
new file mode 100644
index 00000000000..46fbfa4b24a
--- /dev/null
+++ b/src/OpenAI/Provider/MessageProviderInterface.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\OpenAI\Provider;
+
+use App\OpenAI\Model\MessageInterface;
+use App\OpenAI\Model\RunInterface;
+use App\OpenAI\Model\ThreadInterface;
+
+interface MessageProviderInterface
+{
+    public function save(MessageInterface $message): void;
+
+    public function createAssistantMessage(
+        ThreadInterface $thread,
+        string $openAiId,
+        string $text,
+        array $annotations,
+        \DateTimeInterface $date,
+        ?RunInterface $run
+    ): MessageInterface;
+}
diff --git a/src/OpenAI/Provider/RunProviderInterface.php b/src/OpenAI/Provider/RunProviderInterface.php
new file mode 100644
index 00000000000..795da8067e3
--- /dev/null
+++ b/src/OpenAI/Provider/RunProviderInterface.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\OpenAI\Provider;
+
+use App\OpenAI\Model\RunInterface;
+
+interface RunProviderInterface
+{
+    public function save(RunInterface $run): void;
+
+    public function findOneByOpenAiId(string $openAiId): ?RunInterface;
+}
diff --git a/src/OpenAI/Provider/ThreadProviderInterface.php b/src/OpenAI/Provider/ThreadProviderInterface.php
new file mode 100644
index 00000000000..70cbca44838
--- /dev/null
+++ b/src/OpenAI/Provider/ThreadProviderInterface.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\OpenAI\Provider;
+
+use App\OpenAI\Model\ThreadInterface;
+
+interface ThreadProviderInterface
+{
+    public function findOneByIdentifier(string $identifier): ?ThreadInterface;
+
+    public function refresh(ThreadInterface $thread): void;
+
+    public function save(ThreadInterface $thread): void;
+}
diff --git a/src/Repository/Chatbot/MessageRepository.php b/src/Repository/Chatbot/MessageRepository.php
index a6301603aa6..1acfa39459f 100644
--- a/src/Repository/Chatbot/MessageRepository.php
+++ b/src/Repository/Chatbot/MessageRepository.php
@@ -2,20 +2,45 @@
 
 namespace App\Repository\Chatbot;
 
+use App\Chatbot\Enum\MessageRoleEnum;
 use App\Entity\Chatbot\Message;
+use App\OpenAI\Model\MessageInterface;
+use App\OpenAI\Model\RunInterface;
+use App\OpenAI\Model\ThreadInterface;
+use App\OpenAI\Provider\MessageProviderInterface;
 use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
 use Doctrine\Persistence\ManagerRegistry;
 
-class MessageRepository extends ServiceEntityRepository
+class MessageRepository extends ServiceEntityRepository implements MessageProviderInterface
 {
     public function __construct(ManagerRegistry $registry)
     {
         parent::__construct($registry, Message::class);
     }
 
-    public function save(Message $message): void
+    public function save(MessageInterface $message): void
     {
         $this->_em->persist($message);
         $this->_em->flush();
     }
+
+    public function createAssistantMessage(
+        ThreadInterface $thread,
+        string $openAiId,
+        string $text,
+        array $annotations,
+        \DateTimeInterface $date,
+        ?RunInterface $run
+    ): MessageInterface {
+        $message = new Message();
+        $message->thread = $thread;
+        $message->role = MessageRoleEnum::ASSISTANT;
+        $message->openAiId = $openAiId;
+        $message->text = $text;
+        $message->entities = $annotations;
+        $message->date = $date;
+        $message->run = $run;
+
+        return $message;
+    }
 }
diff --git a/src/Repository/Chatbot/RunRepository.php b/src/Repository/Chatbot/RunRepository.php
index 00f4cde2fe7..80e412e499a 100644
--- a/src/Repository/Chatbot/RunRepository.php
+++ b/src/Repository/Chatbot/RunRepository.php
@@ -3,22 +3,24 @@
 namespace App\Repository\Chatbot;
 
 use App\Entity\Chatbot\Run;
+use App\OpenAI\Model\RunInterface;
+use App\OpenAI\Provider\RunProviderInterface;
 use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
 use Doctrine\Persistence\ManagerRegistry;
 
-class RunRepository extends ServiceEntityRepository
+class RunRepository extends ServiceEntityRepository implements RunProviderInterface
 {
     public function __construct(ManagerRegistry $registry)
     {
         parent::__construct($registry, Run::class);
     }
 
-    public function findOneByOpenAiId(string $openAiId): ?Run
+    public function findOneByOpenAiId(string $openAiId): ?RunInterface
     {
         return $this->findOneBy(['openAiId' => $openAiId]);
     }
 
-    public function save(Run $run): void
+    public function save(RunInterface $run): void
     {
         $this->_em->persist($run);
         $this->_em->flush();
diff --git a/src/Repository/Chatbot/ThreadRepository.php b/src/Repository/Chatbot/ThreadRepository.php
index f4f7d058d6a..abda238f2d8 100644
--- a/src/Repository/Chatbot/ThreadRepository.php
+++ b/src/Repository/Chatbot/ThreadRepository.php
@@ -4,10 +4,12 @@
 
 use App\Entity\Chatbot\Chatbot;
 use App\Entity\Chatbot\Thread;
+use App\OpenAI\Model\ThreadInterface;
+use App\OpenAI\Provider\ThreadProviderInterface;
 use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
 use Doctrine\Persistence\ManagerRegistry;
 
-class ThreadRepository extends ServiceEntityRepository
+class ThreadRepository extends ServiceEntityRepository implements ThreadProviderInterface
 {
     public function __construct(ManagerRegistry $registry)
     {
@@ -32,12 +34,17 @@ public function findOneForTelegram(Chatbot $chatbot, string $telegramChatId): ?T
         ;
     }
 
-    public function refresh(Thread $thread): void
+    public function findOneByIdentifier(string $identifier): ?ThreadInterface
+    {
+        return $this->findOneByUuid($identifier);
+    }
+
+    public function refresh(ThreadInterface $thread): void
     {
         $this->_em->refresh($thread);
     }
 
-    public function save(Thread $thread): void
+    public function save(ThreadInterface $thread): void
     {
         $this->_em->persist($thread);
         $this->_em->flush($thread);
diff --git a/src/Repository/OpenAI/AssistantRepository.php b/src/Repository/OpenAI/AssistantRepository.php
index 197ca46c6f7..ea58837c1e8 100644
--- a/src/Repository/OpenAI/AssistantRepository.php
+++ b/src/Repository/OpenAI/AssistantRepository.php
@@ -3,8 +3,8 @@
 namespace App\Repository\OpenAI;
 
 use App\Entity\OpenAI\Assistant;
-use App\OpenAI\AssistantInterface;
-use App\OpenAI\AssistantProviderInterface;
+use App\OpenAI\Model\AssistantInterface;
+use App\OpenAI\Provider\AssistantProviderInterface;
 use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
 use Doctrine\Persistence\ManagerRegistry;
 
@@ -24,4 +24,9 @@ public function loadByIdentifier(string $identifier): ?AssistantInterface
     {
         return $this->findOneByUuid($identifier);
     }
+
+    public function refresh(AssistantInterface $assistant): void
+    {
+        $this->_em->refresh($assistant);
+    }
 }
diff --git a/src/Repository/TelegramBotRepository.php b/src/Repository/TelegramBotRepository.php
index 0f989452c89..b8529c1e03a 100644
--- a/src/Repository/TelegramBotRepository.php
+++ b/src/Repository/TelegramBotRepository.php
@@ -25,7 +25,7 @@ public function loadByIdentifier(string $identifier): ?BotInterface
         return $this->findOneByUuid($identifier);
     }
 
-    public function findOneEnabledBySecret(string $secret): ?TelegramBot
+    public function findOneEnabledBySecret(string $secret): ?BotInterface
     {
         return $this->createQueryBuilder('telegram_bot')
             ->where('telegram_bot.enabled = :enabled')
diff --git a/src/Telegram/BotProviderInterface.php b/src/Telegram/BotProviderInterface.php
index 4152573c1b9..2ef1e3bff91 100644
--- a/src/Telegram/BotProviderInterface.php
+++ b/src/Telegram/BotProviderInterface.php
@@ -5,4 +5,6 @@
 interface BotProviderInterface
 {
     public function loadByIdentifier(string $identifier): ?BotInterface;
+
+    public function findOneEnabledBySecret(string $secret): ?BotInterface;
 }
diff --git a/src/Telegram/Client/Client.php b/src/Telegram/Client/Client.php
index 11f8d114ffb..a9eb4fbee74 100755
--- a/src/Telegram/Client/Client.php
+++ b/src/Telegram/Client/Client.php
@@ -15,9 +15,9 @@ public function sendMessage(string $chatId, string $text, array $entities = []):
         $this->botApi->sendMessage($chatId, $text);
     }
 
-    public function setWebhook(string $url): void
+    public function setWebhook(string $url, string $secret): void
     {
-        $this->botApi->setWebhook($url);
+        $this->botApi->setWebhook($url, null, null, 40, null, false, $secret);
     }
 
     public function deleteWebhook(): void
diff --git a/src/Telegram/Client/ClientFactory.php b/src/Telegram/Client/ClientFactory.php
index 4ae5b4cd800..43fb6676dd5 100755
--- a/src/Telegram/Client/ClientFactory.php
+++ b/src/Telegram/Client/ClientFactory.php
@@ -5,7 +5,7 @@
 use App\Telegram\BotInterface;
 use TelegramBot\Api\BotApi;
 
-class ClientFactory
+class ClientFactory implements ClientFactoryInterface
 {
     public function createClient(BotInterface $bot): ClientInterface
     {
diff --git a/src/Telegram/Client/ClientInterface.php b/src/Telegram/Client/ClientInterface.php
index 4048ac9d658..89d080c7e41 100755
--- a/src/Telegram/Client/ClientInterface.php
+++ b/src/Telegram/Client/ClientInterface.php
@@ -6,7 +6,7 @@ interface ClientInterface
 {
     public function sendMessage(string $chatId, string $text, array $entities = []): void;
 
-    public function setWebhook(string $url): void;
+    public function setWebhook(string $url, string $secret): void;
 
     public function deleteWebhook(): void;
 }
diff --git a/src/Telegram/Listener/BotMessageListener.php b/src/Telegram/EventListener/BotMessageListener.php
similarity index 81%
rename from src/Telegram/Listener/BotMessageListener.php
rename to src/Telegram/EventListener/BotMessageListener.php
index ae5bf5ff436..2d4659086f1 100755
--- a/src/Telegram/Listener/BotMessageListener.php
+++ b/src/Telegram/EventListener/BotMessageListener.php
@@ -1,11 +1,13 @@
 <?php
 
-namespace App\Telegram\Listener;
+namespace App\Telegram\EventListener;
 
 use App\Telegram\Command\SendBotMessageCommand;
 use App\Telegram\Event\BotMessageEvent;
+use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
 use Symfony\Component\Messenger\MessageBusInterface;
 
+#[AsEventListener]
 class BotMessageListener
 {
     public function __construct(private readonly MessageBusInterface $bus)
diff --git a/src/Telegram/Handler/SendBotMessageCommandHandler.php b/src/Telegram/Handler/SendBotMessageCommandHandler.php
index 2b8e5a98e4b..88b06545beb 100644
--- a/src/Telegram/Handler/SendBotMessageCommandHandler.php
+++ b/src/Telegram/Handler/SendBotMessageCommandHandler.php
@@ -6,7 +6,9 @@
 use App\Telegram\Client\ClientFactoryInterface;
 use App\Telegram\Command\SendBotMessageCommand;
 use App\Telegram\Logger;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
 
+#[AsMessageHandler]
 class SendBotMessageCommandHandler
 {
     public function __construct(
diff --git a/src/Telegram/Update/AbstractMessageHandler.php b/src/Telegram/Update/AbstractMessageHandler.php
index 402f4681cb6..784b4ab9cf9 100755
--- a/src/Telegram/Update/AbstractMessageHandler.php
+++ b/src/Telegram/Update/AbstractMessageHandler.php
@@ -27,7 +27,7 @@ abstract protected function isHandledMessage(Message $message): bool;
 
     private function isHandledChatType(Chat $chat): bool
     {
-        return \in_array($chat->getType(), self::HANDLED_CHAT_TYPES, true);
+        return \in_array(ChatTypeEnum::tryFrom($chat->getType()), self::HANDLED_CHAT_TYPES, true);
     }
 
     private function isMessageGranted(BotInterface $bot, Message $message): bool
diff --git a/src/Telegram/Webhook/UrlGenerator.php b/src/Telegram/Webhook/UrlGenerator.php
new file mode 100644
index 00000000000..aba45ba0938
--- /dev/null
+++ b/src/Telegram/Webhook/UrlGenerator.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Telegram\Webhook;
+
+use App\Controller\Webhook\TelegramBotController;
+use App\Telegram\BotInterface;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface as SymfonyUrlGenerator;
+
+class UrlGenerator implements UrlGeneratorInterface
+{
+    public function __construct(private readonly SymfonyUrlGenerator $urlGenerator)
+    {
+    }
+
+    public function generateUrl(BotInterface $bot): string
+    {
+        return $this->urlGenerator->generate(
+            TelegramBotController::ROUTE_NAME,
+            [],
+            SymfonyUrlGenerator::ABSOLUTE_URL
+        );
+    }
+}
diff --git a/src/Telegram/Webhook/UrlGeneratorInterface.php b/src/Telegram/Webhook/UrlGeneratorInterface.php
new file mode 100644
index 00000000000..6044a10451a
--- /dev/null
+++ b/src/Telegram/Webhook/UrlGeneratorInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Telegram\Webhook;
+
+use App\Telegram\BotInterface;
+
+interface UrlGeneratorInterface
+{
+    public function generateUrl(BotInterface $bot): string;
+}
diff --git a/src/Telegram/Webhook/UrlHandler.php b/src/Telegram/Webhook/UrlHandler.php
new file mode 100644
index 00000000000..6903f571aaf
--- /dev/null
+++ b/src/Telegram/Webhook/UrlHandler.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Telegram\Webhook;
+
+use App\Telegram\BotInterface;
+use App\Telegram\Client\ClientFactoryInterface;
+use App\Telegram\Client\ClientInterface;
+
+class UrlHandler
+{
+    public function __construct(
+        private readonly ClientFactoryInterface $clientFactory,
+        private readonly UrlGeneratorInterface $urlGenerator
+    ) {
+    }
+
+    public function setWebhook(BotInterface $bot): void
+    {
+        $webhookUrl = $this->urlGenerator->generateUrl($bot);
+
+        dd($webhookUrl);
+        $this
+            ->createClient($bot)
+            ->setWebhook($webhookUrl, $bot->getSecret())
+        ;
+    }
+
+    public function removeWebhook(BotInterface $bot): void
+    {
+        $this
+            ->createClient($bot)
+            ->deleteWebhook()
+        ;
+    }
+
+    private function createClient(BotInterface $bot): ClientInterface
+    {
+        return $this->clientFactory->createClient($bot);
+    }
+}
diff --git a/src/Telegram/WebhookRequestHandler.php b/src/Telegram/WebhookRequestHandler.php
index 7d6ea2bc4a9..7927cc16918 100755
--- a/src/Telegram/WebhookRequestHandler.php
+++ b/src/Telegram/WebhookRequestHandler.php
@@ -12,14 +12,25 @@
 
 class WebhookRequestHandler
 {
+    private const SECRET_TOKEN_HEADER = 'X-Telegram-Bot-Api-Secret-Token';
+
     public function __construct(
+        private readonly BotProviderInterface $botProvider,
         private readonly UpdateHandler $updateHandler,
         private readonly Logger $logger
     ) {
     }
 
-    public function handle(BotInterface $bot, Request $request): JsonResponse
+    public function handle(Request $request): JsonResponse
     {
+        if (!$secret = $request->headers->get(self::SECRET_TOKEN_HEADER)) {
+            throw new BadRequestHttpException('The request has no secret token header.');
+        }
+
+        if (!$bot = $this->botProvider->findOneEnabledBySecret($secret)) {
+            throw new BadRequestHttpException('No bot found for given secret token.');
+        }
+
         $this->logger->log($bot, 'Received webhook request.');
 
         if (!$content = $request->getContent()) {
@@ -28,9 +39,13 @@ public function handle(BotInterface $bot, Request $request): JsonResponse
 
         try {
             $data = BotApi::jsonValidate($content, true);
+        } catch (InvalidJsonException $e) {
+            throw new BadRequestHttpException('The request content is not a valid JSON payload.');
+        }
 
+        try {
             $update = Update::fromResponse($data);
-        } catch (InvalidArgumentException|InvalidJsonException $e) {
+        } catch (InvalidArgumentException $e) {
             throw new BadRequestHttpException('The request content is not a valid Telegram webhook.');
         }
 
diff --git a/tests/AbstractWebTestCase.php b/tests/AbstractWebTestCase.php
index 4066038e898..f95c730e4eb 100644
--- a/tests/AbstractWebTestCase.php
+++ b/tests/AbstractWebTestCase.php
@@ -44,4 +44,9 @@ protected function makeRenaissanceClient(): void
     {
         $this->client->setServerParameter('HTTP_HOST', static::getContainer()->getParameter('app_renaissance_host'));
     }
+
+    protected function makeWebhookClient(): void
+    {
+        $this->client->setServerParameter('HTTP_HOST', static::getContainer()->getParameter('webhook_renaissance_host'));
+    }
 }
diff --git a/tests/Chatbot/Provider/DummyProvider.php b/tests/Chatbot/Provider/DummyProvider.php
deleted file mode 100644
index cc7a404ee50..00000000000
--- a/tests/Chatbot/Provider/DummyProvider.php
+++ /dev/null
@@ -1,54 +0,0 @@
-<?php
-
-namespace Tests\App\Chatbot\Provider;
-
-use App\Chatbot\Provider\ProviderInterface;
-use App\Chatbot\Provider\Resources\Message;
-use Faker\Factory;
-use Faker\Generator;
-
-class DummyProvider implements ProviderInterface
-{
-    private Generator $faker;
-
-    public function __construct()
-    {
-        $this->faker = Factory::create('fr_FR');
-    }
-
-    public function createThread(): string
-    {
-        return uniqid('thread_');
-    }
-
-    public function createMessage(string $threadId, string $role, string $content): string
-    {
-        return uniqid('message_');
-    }
-
-    public function createRun(string $threadId, string $assistantId): string
-    {
-        return uniqid('run_');
-    }
-
-    public function cancelRun(string $threadId, string $runId): void
-    {
-    }
-
-    public function getRunStatus(string $threadId, string $runId): string
-    {
-        return 'completed';
-    }
-
-    public function retrieveMessages(string $threadId, int $limit = 10): array
-    {
-        return [
-            new Message(
-                uniqid('message_'),
-                'assistant',
-                $this->faker->text('100'),
-                new \DateTimeImmutable()
-            ),
-        ];
-    }
-}
diff --git a/tests/Controller/Webhook/AbstractWebhookTestCase.php b/tests/Controller/Webhook/AbstractWebhookTestCase.php
new file mode 100644
index 00000000000..98ae3f21953
--- /dev/null
+++ b/tests/Controller/Webhook/AbstractWebhookTestCase.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Tests\App\Controller\Webhook;
+
+use Tests\App\AbstractWebTestCase;
+
+abstract class AbstractWebhookTestCase extends AbstractWebTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->makeWebhookClient();
+    }
+}
diff --git a/tests/Controller/Webhook/TelegramBotControllerTest.php b/tests/Controller/Webhook/TelegramBotControllerTest.php
new file mode 100644
index 00000000000..c595c3ac88f
--- /dev/null
+++ b/tests/Controller/Webhook/TelegramBotControllerTest.php
@@ -0,0 +1,107 @@
+<?php
+
+namespace Tests\App\Controller\Webhook;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Group;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Tests\App\Controller\ControllerTestTrait;
+
+#[Group('functional')]
+#[Group('webhook')]
+class TelegramBotControllerTest extends AbstractWebhookTestCase
+{
+    use ControllerTestTrait;
+
+    #[DataProvider('provideBadRequestContent')]
+    public function testBadRequest(?string $jsonContent): void
+    {
+        $this->client->request(
+            Request::METHOD_POST,
+            '/telegram',
+            [],
+            [],
+            [
+                'Content-Type' => 'application/json',
+                'HTTP_X-Telegram-Bot-Api-Secret-Token' => 'bot-1-secret',
+            ],
+            $jsonContent
+        );
+
+        $this->assertStatusCode(Response::HTTP_BAD_REQUEST, $this->client);
+    }
+
+    public static function provideBadRequestContent(): \Generator
+    {
+        yield 'Empty content' => [null];
+        yield 'Invalid JSON content' => ['[Invalid JSON'];
+        yield 'Content with missing required parameter "update_id"' => [
+            json_encode(
+                [
+                    'message' => [
+                        'message_id' => 455,
+                        'from' => [
+                            'id' => 789,
+                            'is_bot' => false,
+                            'first_name' => 'John',
+                            'last_name' => 'Doe',
+                            'username' => 'johnd',
+                            'language_code' => 'en',
+                        ],
+                        'chat' => [
+                            'id' => 1011,
+                            'first_name' => 'John',
+                            'last_name' => 'Doe',
+                            'username' => 'johnd',
+                            'type' => 'private',
+                        ],
+                        'date' => 1707065709,
+                        'text' => 'Lorem ipsum dolor sit amet.',
+                    ],
+                ]
+            ),
+        ];
+    }
+
+    public function testRequestSuccess(): void
+    {
+        $this->client->request(
+            Request::METHOD_POST,
+            '/telegram',
+            [],
+            [],
+            [
+                'Content-Type' => 'application/json',
+                'HTTP_X-Telegram-Bot-Api-Secret-Token' => 'bot-1-secret',
+            ],
+            json_encode(
+                [
+                    'update_id' => 123,
+                    'message' => [
+                        'message_id' => 455,
+                        'from' => [
+                            'id' => 789,
+                            'is_bot' => false,
+                            'first_name' => 'John',
+                            'last_name' => 'Doe',
+                            'username' => 'johnd',
+                            'language_code' => 'en',
+                        ],
+                        'chat' => [
+                            'id' => 1011,
+                            'first_name' => 'John',
+                            'last_name' => 'Doe',
+                            'username' => 'johnd',
+                            'type' => 'private',
+                        ],
+                        'date' => 1707065709,
+                        'text' => 'Lorem ipsum dolor sit amet.',
+                    ],
+                ]
+            )
+        );
+
+        $this->assertStatusCode(Response::HTTP_OK, $this->client);
+    }
+}
diff --git a/tests/OpenAI/Client/Client.php b/tests/OpenAI/Client/Client.php
new file mode 100644
index 00000000000..efea3b23c01
--- /dev/null
+++ b/tests/OpenAI/Client/Client.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace Tests\App\OpenAI\Client;
+
+use App\OpenAI\Client\ClientInterface;
+use App\OpenAI\Client\Resource\Message;
+use App\OpenAI\Enum\MessageRoleEnum;
+use App\OpenAI\Enum\RunStatusEnum;
+use Faker\Factory;
+use Faker\Generator;
+
+class Client implements ClientInterface
+{
+    private Generator $faker;
+    private ?string $lastRunId = null;
+
+    public function __construct()
+    {
+        $this->faker = Factory::create('fr_FR');
+    }
+
+    public function createThread(): string
+    {
+        return uniqid('thread_');
+    }
+
+    public function createUserMessage(string $threadId, string $content): string
+    {
+        return uniqid('msg_');
+    }
+
+    public function createRun(string $threadId, string $assistantId): string
+    {
+        $this->lastRunId = uniqid('run_');
+
+        return $this->lastRunId;
+    }
+
+    public function getRunStatus(string $threadId, string $runId): RunStatusEnum
+    {
+        return RunStatusEnum::COMPLETED;
+    }
+
+    public function cancelRun(string $threadId, string $runId): void
+    {
+        $this->lastRunId = null;
+    }
+
+    /**
+     * @return Message[]|array
+     */
+    public function getMessages(string $threadId, int $limit = 10): array
+    {
+        return [
+            new Message(
+                $threadId,
+                MessageRoleEnum::ASSISTANT,
+                $this->faker->text('128'),
+                [],
+                new \DateTimeImmutable('now'),
+                uniqid('msg_'),
+                $this->lastRunId
+            ),
+        ];
+    }
+}
diff --git a/tests/Telegram/Client/Client.php b/tests/Telegram/Client/Client.php
index 850304f6081..2bf9ea6ea03 100644
--- a/tests/Telegram/Client/Client.php
+++ b/tests/Telegram/Client/Client.php
@@ -6,11 +6,11 @@
 
 class Client implements ClientInterface
 {
-    public function sendMessage(string $chatId, string $text): void
+    public function sendMessage(string $chatId, string $text, array $entities = []): void
     {
     }
 
-    public function setWebhook(string $url): void
+    public function setWebhook(string $url, string $secret): void
     {
     }
 
diff --git a/tests/Telegram/Client/ClientFactory.php b/tests/Telegram/Client/ClientFactory.php
index 7e6eb78e3dc..1e62cfa0cf7 100644
--- a/tests/Telegram/Client/ClientFactory.php
+++ b/tests/Telegram/Client/ClientFactory.php
@@ -2,13 +2,13 @@
 
 namespace Tests\App\Telegram\Client;
 
-use App\Entity\Chatbot\Chatbot;
+use App\Telegram\BotInterface;
 use App\Telegram\Client\ClientFactoryInterface;
 use App\Telegram\Client\ClientInterface;
 
 class ClientFactory implements ClientFactoryInterface
 {
-    public function createClient(Chatbot $chatbot): ClientInterface
+    public function createClient(BotInterface $bot): ClientInterface
     {
         return new Client();
     }
diff --git a/tests/Telegram/Webhook/ProxyUrlGenerator.php b/tests/Telegram/Webhook/ProxyUrlGenerator.php
new file mode 100644
index 00000000000..6867660cf0c
--- /dev/null
+++ b/tests/Telegram/Webhook/ProxyUrlGenerator.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Tests\App\Telegram\Webhook;
+
+use App\Controller\Webhook\TelegramBotController;
+use App\Telegram\BotInterface;
+use App\Telegram\Webhook\UrlGeneratorInterface;
+
+class ProxyUrlGenerator implements UrlGeneratorInterface
+{
+    public function __construct(
+        private readonly UrlGeneratorInterface $urlGenerator,
+        private readonly ?string $webhookProxyHost = null
+    ) {
+    }
+
+    public function generateUrl(BotInterface $bot): string
+    {
+        if (!empty($this->webhookProxyHost)) {
+            return sprintf(
+                '%s%s',
+                $this->webhookProxyHost,
+                TelegramBotController::ROUTE_PATH
+            );
+        }
+
+        return $this->urlGenerator->generateUrl($bot);
+    }
+}