lfx-telegram 0.1.0__py3-none-any.whl

lfx_telegram/__init__.py

@@ -0,0 +1,17 @@
+"""Connection-backed Telegram triggers and bot actions."""
+
+from lfx_telegram.components.telegram import (
+    TelegramNotifyComponent,
+    TelegramOnCommandTriggerComponent,
+    TelegramOnMessageTriggerComponent,
+    TelegramReplyComponent,
+    TelegramSendMessageComponent,
+)
+
+__all__ = [
+    "TelegramNotifyComponent",
+    "TelegramOnCommandTriggerComponent",
+    "TelegramOnMessageTriggerComponent",
+    "TelegramReplyComponent",
+    "TelegramSendMessageComponent",
+]

lfx_telegram/_base.py

@@ -0,0 +1,72 @@
+"""Connection and action execution shared by Telegram components."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from lfx.custom import Component
+from lfx.integrations.telemetry import integration_action
+from lfx.io import ConnectionRefInput
+from lfx.schema.data import Data
+
+from lfx_telegram._client import TelegramClient, redact
+
+AUTH_PROFILE = "telegram-bot-token"
+
+
+def connection_input(*, capabilities: list[str], required: bool = True) -> ConnectionRefInput:
+    """Request only the bot connection owned by this flow's user."""
+    return ConnectionRefInput(
+        name="connection",
+        display_name="Telegram Connection",
+        provider="telegram",
+        auth_profile_id=AUTH_PROFILE,
+        identity_kind="instance",
+        ownership_mode="user",
+        required_scopes=[],
+        capabilities=capabilities,
+        required=required,
+        info="A BotFather bot token stored in your connection. Triggers also require background-run consent.",
+    )
+
+
+class TelegramActionComponent(Component):
+    """Resolve and govern each action through the common connection service."""
+
+    icon = "Telegram"
+    capability_id: ClassVar[str] = ""
+
+    async def send(self, payload: dict, *, expected_bot_id: str | None = None) -> Data:
+        lease = self.resolve_connection("connection")
+        credential = await lease.get_credential()
+        async with (
+            integration_action(
+                self, provider="telegram", capability=self.capability_id, owner_kind=credential.owner_kind
+            ),
+            TelegramClient(lease) as client,
+        ):
+            bot = await client.identity()
+            if expected_bot_id is not None and expected_bot_id != bot["id"]:
+                from lfx.integrations.errors import ConnectionNotAuthorizedError
+
+                raise ConnectionNotAuthorizedError(
+                    provider="telegram", hint="Reply with the bot that received this event."
+                )
+            result = await client.call("sendMessage", **payload)
+        if not isinstance(result, dict) or type(result.get("message_id")) is not int:
+            from lfx.integrations.errors import ProviderUnavailableError
+
+            raise ProviderUnavailableError(provider="telegram")
+        self.status = "Telegram message sent."
+        return Data(
+            data=redact(
+                {
+                    "provider": "telegram",
+                    "bot_id": bot["id"],
+                    "chat_id": payload["chat_id"],
+                    "message_id": result["message_id"],
+                    "thread_id": result.get("message_thread_id"),
+                    "text": result.get("text", ""),
+                }
+            )
+        )

lfx_telegram/_client.py

@@ -0,0 +1,127 @@
+"""Fixed-origin Telegram Bot API transport with credential-free failures."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any
+
+import httpx
+from lfx.integrations.errors import (
+    AuthExpiredError,
+    ConnectionNotAuthorizedError,
+    InvalidRequestError,
+    ProviderUnavailableError,
+    RateLimitedError,
+)
+
+if TYPE_CHECKING:
+    from lfx.integrations.models import CredentialLease
+
+API_ORIGIN = "https://api.telegram.org"
+TOKEN_PATTERN = re.compile(r"[1-9][0-9]{4,15}:[A-Za-z0-9_-]{30,128}")
+MAX_RETRY_AFTER_SECONDS = 86400
+METHODS = frozenset({"getMe", "getUpdates", "getWebhookInfo", "setWebhook", "deleteWebhook", "sendMessage"})
+
+
+def redact(value: Any) -> Any:
+    """Remove Telegram credentials even when a user posts one as message text."""
+    if isinstance(value, str):
+        return TOKEN_PATTERN.sub("[redacted bot token]", value)
+    if isinstance(value, list):
+        return [redact(item) for item in value]
+    if isinstance(value, dict):
+        return {key: redact(item) for key, item in value.items()}
+    return value
+
+
+class TelegramClient:
+    """Keep token-bearing URLs below httpx's request-logging client layer."""
+
+    def __init__(self, lease: CredentialLease, *, transport: httpx.AsyncBaseTransport | None = None) -> None:
+        self._lease = lease
+        self._transport = transport if transport is not None else httpx.AsyncHTTPTransport(retries=0)
+
+    async def __aenter__(self):
+        await self._transport.__aenter__()
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self._transport.__aexit__(*args)
+
+    async def _request(self, method: str, payload: dict[str, Any]) -> Any:
+        credential = await self._lease.get_credential()
+        token = credential.access_token.get_secret_value()
+        if credential.provider not in {"", "telegram"} or credential.identity not in {None, "bot"}:
+            raise ConnectionNotAuthorizedError(provider="telegram")
+        if not TOKEN_PATTERN.fullmatch(token):
+            msg = "Use a Telegram bot token issued by BotFather."
+            raise InvalidRequestError(msg, provider="telegram")
+        bot_id = token.split(":", 1)[0]
+        if credential.account is not None and credential.account.id != bot_id:
+            raise ConnectionNotAuthorizedError(provider="telegram")
+        request = httpx.Request(
+            "POST",
+            f"{API_ORIGIN}/bot{token}/{method}",
+            json=payload,
+            extensions={"timeout": {"connect": 10.0, "read": 35.0, "write": 10.0, "pool": 10.0}},
+        )
+        try:
+            response = await self._transport.handle_async_request(request)
+            try:
+                await response.aread()
+                body = response.json()
+                status = response.status_code
+            finally:
+                await response.aclose()
+        except (httpx.HTTPError, ValueError, TypeError):
+            raise ProviderUnavailableError(provider="telegram") from None
+        if not isinstance(body, dict):
+            raise ProviderUnavailableError(provider="telegram")
+        code = body.get("error_code", status)
+        code = code if type(code) is int else status
+        if status >= httpx.codes.INTERNAL_SERVER_ERROR:
+            raise ProviderUnavailableError(provider="telegram", http_status=status)
+        if code == httpx.codes.UNAUTHORIZED:
+            raise AuthExpiredError(provider="telegram")
+        if code == httpx.codes.TOO_MANY_REQUESTS:
+            parameters = body.get("parameters")
+            retry = parameters.get("retry_after") if isinstance(parameters, dict) else None
+            retry = float(retry) if type(retry) is int and 0 <= retry <= MAX_RETRY_AFTER_SECONDS else None
+            raise RateLimitedError(provider="telegram", retry_after=retry)
+        if code == httpx.codes.FORBIDDEN:
+            raise ConnectionNotAuthorizedError(provider="telegram", reason="provider")
+        if code in {400, 404, 409}:
+            message = "Telegram rejected the request. Check the target and bot receiver configuration."
+            raise InvalidRequestError(message, provider="telegram", http_status=code)
+        if body.get("ok") is not True or status != httpx.codes.OK:
+            raise ProviderUnavailableError(provider="telegram")
+        return body.get("result")
+
+    async def call(self, method: str, **payload: Any) -> Any:
+        """Call only declared methods, with one credential re-resolution on rejection."""
+        if method not in METHODS:
+            msg = "This Telegram method is unsupported."
+            raise InvalidRequestError(msg, provider="telegram")
+        try:
+            return await self._request(method, payload)
+        except AuthExpiredError as error:
+            await self._lease.get_token_after_auth_error(error)
+            return await self._request(method, payload)
+
+    async def identity(self) -> dict[str, Any]:
+        """Establish the bot identity from Telegram, never from caller metadata."""
+        result = await self.call("getMe")
+        credential = await self._lease.get_credential()
+        token_id = credential.access_token.get_secret_value().split(":", 1)[0]
+        if (
+            not isinstance(result, dict)
+            or result.get("is_bot") is not True
+            or type(result.get("id")) is not int
+            or str(result["id"]) != token_id
+            or not isinstance(result.get("username"), str)
+            or not re.fullmatch(r"[A-Za-z0-9_]{5,32}", result["username"])
+        ):
+            raise ConnectionNotAuthorizedError(
+                provider="telegram", hint="Use a token whose Telegram bot identity can be verified."
+            )
+        return {"id": str(result["id"]), "username": result["username"]}

lfx_telegram/_triggers.py

@@ -0,0 +1,79 @@
+"""Telegram trigger declarations have no transport or credential material."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from lfx.base.triggers.base import BaseTriggerComponent
+from lfx.io import DropdownInput, Output, StrInput
+from lfx.schema.message import Message
+
+from lfx_telegram._base import connection_input
+
+
+def trigger_inputs(event: str) -> list:
+    return [
+        connection_input(
+            capabilities=[f"telegram.trigger.{event}.webhook", f"telegram.trigger.{event}.poll"], required=False
+        ),
+        StrInput(
+            name="allowed_chats",
+            display_name="Allowed Chat IDs",
+            is_list=True,
+            value=[],
+            required=True,
+            info="An explicit list of numeric chat IDs this flow may receive. Empty lists cannot be armed.",
+        ),
+        StrInput(
+            name="allowed_senders",
+            display_name="Allowed Sender IDs",
+            is_list=True,
+            value=[],
+            advanced=True,
+            info="Optional numeric user IDs. Anonymous messages fail this filter.",
+        ),
+        DropdownInput(
+            name="session_scope",
+            display_name="Conversation Session",
+            options=["thread", "sender", "chat"],
+            value="thread",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="delivery_mode",
+            display_name="Delivery",
+            options=["auto", "push", "poll"],
+            value="auto",
+            advanced=True,
+            info="Polling refuses a bot that already has a webhook. Transport changes retain pending updates.",
+        ),
+    ]
+
+
+class TelegramTriggerComponent(BaseTriggerComponent):
+    """Hand the server-verified event to the downstream flow."""
+
+    provider = "telegram"
+    icon = "Telegram"
+    needs_connection = True
+    config_fields: ClassVar[tuple[str, ...]] = (
+        "connection",
+        "allowed_chats",
+        "allowed_senders",
+        "session_scope",
+        "delivery_mode",
+    )
+    outputs = [
+        Output(display_name="Event", name="trigger_event", method="build_event"),
+        Output(display_name="Message", name="message", method="build_message"),
+    ]
+
+    def trigger_config(self) -> dict:
+        return {name: getattr(self, name, None) for name in self.config_fields}
+
+    def build_message(self) -> Message:
+        event, _problem = self._firing_event()
+        payload = event.get("payload")
+        payload = payload if isinstance(payload, dict) else {}
+        payload = payload.get("data", payload.get("delivery", payload))
+        return Message(text=payload.get("text") or "", session_id=payload.get("session_key") or "")

lfx_telegram/_validation.py

@@ -0,0 +1,51 @@
+"""Validate the bounded Telegram target and message inputs."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from lfx.integrations.errors import InvalidRequestError
+
+MAX_MESSAGE_UNITS = 4096
+MAX_TELEGRAM_ID = (1 << 52) - 1
+
+
+def numeric_id(value: Any, *, positive: bool = False) -> int:
+    """Accept exact numeric identifiers without float rounding or coercion."""
+    if type(value) is int:
+        result = value
+    elif isinstance(value, str) and re.fullmatch(r"-?[1-9][0-9]{0,15}", value):
+        result = int(value)
+    else:
+        msg = "Use a numeric Telegram ID."
+        raise InvalidRequestError(msg, provider="telegram")
+    if result == 0 or abs(result) > MAX_TELEGRAM_ID or (positive and result < 0):
+        msg = "The Telegram ID is outside the supported range."
+        raise InvalidRequestError(msg, provider="telegram")
+    return result
+
+
+def message_payload(
+    *, chat_id: Any, text: Any, thread_id: Any = None, reply_id: Any = None, silent: bool = False
+) -> dict[str, Any]:
+    """Build one plain-text send without an arbitrary API destination."""
+    if (
+        not isinstance(text, str)
+        or not text.strip()
+        or len(text.encode("utf-16-le", errors="surrogatepass")) // 2 > MAX_MESSAGE_UNITS
+    ):
+        msg = "Telegram messages need 1 to 4096 UTF-16 characters."
+        raise InvalidRequestError(msg, provider="telegram")
+    if type(silent) is not bool:
+        msg = "The notification setting must be a boolean."
+        raise InvalidRequestError(msg, provider="telegram")
+    payload: dict[str, Any] = {"chat_id": numeric_id(chat_id), "text": text, "disable_notification": silent}
+    if thread_id is not None and thread_id != "":
+        payload["message_thread_id"] = numeric_id(thread_id, positive=True)
+    if reply_id is not None and reply_id != "":
+        payload["reply_parameters"] = {
+            "message_id": numeric_id(reply_id, positive=True),
+            "allow_sending_without_reply": False,
+        }
+    return payload

lfx_telegram/components/__init__.py

@@ -0,0 +1 @@
+"""Telegram component namespace."""

lfx_telegram/components/telegram/__init__.py

@@ -0,0 +1,15 @@
+"""Telegram bundle components."""
+
+from .telegram_notify import TelegramNotifyComponent
+from .telegram_on_command import TelegramOnCommandTriggerComponent
+from .telegram_on_message import TelegramOnMessageTriggerComponent
+from .telegram_reply import TelegramReplyComponent
+from .telegram_send_message import TelegramSendMessageComponent
+
+__all__ = [
+    "TelegramNotifyComponent",
+    "TelegramOnCommandTriggerComponent",
+    "TelegramOnMessageTriggerComponent",
+    "TelegramReplyComponent",
+    "TelegramSendMessageComponent",
+]

lfx_telegram/components/telegram/capabilities.v1.json

@@ -0,0 +1,163 @@
+{
+  "schema_version": 1,
+  "provider_id": "telegram",
+  "display_name": "Telegram",
+  "icon": "Telegram",
+  "docs_url": "https://docs.langflow.org/next/bundles-telegram",
+  "auth_profiles": [
+    {
+      "id": "telegram-bot-token",
+      "kind": "api_key",
+      "identity": "bot",
+      "supports_pkce": false,
+      "supports_refresh": false,
+      "default_scopes": [],
+      "client_type_by_context": {
+        "hosted": "external",
+        "self_managed": "external",
+        "desktop": "external",
+        "headless": "external"
+      },
+      "owner_by_context": {
+        "hosted": "customer",
+        "self_managed": "customer",
+        "desktop": "customer",
+        "headless": "customer"
+      }
+    }
+  ],
+  "capabilities": [
+    {
+      "id": "telegram.trigger.message.webhook",
+      "display_name": "Telegram: On Message",
+      "auth_profile_id": "telegram-bot-token",
+      "identity": "bot",
+      "required_scopes": [],
+      "policy_keys": [
+        "integrations.telegram.trigger.message"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed"
+      ],
+      "risk": "read",
+      "component_ref": "TelegramOnMessageTriggerComponent"
+    },
+    {
+      "id": "telegram.trigger.message.poll",
+      "display_name": "Telegram: On Message",
+      "auth_profile_id": "telegram-bot-token",
+      "identity": "bot",
+      "required_scopes": [],
+      "policy_keys": [
+        "integrations.telegram.trigger.message"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "self_managed",
+        "desktop"
+      ],
+      "risk": "read",
+      "component_ref": "TelegramOnMessageTriggerComponent"
+    },
+    {
+      "id": "telegram.trigger.command.webhook",
+      "display_name": "Telegram: On Command",
+      "auth_profile_id": "telegram-bot-token",
+      "identity": "bot",
+      "required_scopes": [],
+      "policy_keys": [
+        "integrations.telegram.trigger.command"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed"
+      ],
+      "risk": "read",
+      "component_ref": "TelegramOnCommandTriggerComponent"
+    },
+    {
+      "id": "telegram.trigger.command.poll",
+      "display_name": "Telegram: On Command",
+      "auth_profile_id": "telegram-bot-token",
+      "identity": "bot",
+      "required_scopes": [],
+      "policy_keys": [
+        "integrations.telegram.trigger.command"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "self_managed",
+        "desktop"
+      ],
+      "risk": "read",
+      "component_ref": "TelegramOnCommandTriggerComponent"
+    },
+    {
+      "id": "telegram.bot.send",
+      "display_name": "Telegram: Send Message",
+      "auth_profile_id": "telegram-bot-token",
+      "identity": "bot",
+      "required_scopes": [],
+      "policy_keys": [
+        "integrations.telegram.bot.send"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "write",
+      "component_ref": "TelegramSendMessageComponent"
+    },
+    {
+      "id": "telegram.bot.reply",
+      "display_name": "Telegram: Reply to Message",
+      "auth_profile_id": "telegram-bot-token",
+      "identity": "bot",
+      "required_scopes": [],
+      "policy_keys": [
+        "integrations.telegram.bot.reply"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "write",
+      "component_ref": "TelegramReplyComponent"
+    },
+    {
+      "id": "telegram.bot.notify",
+      "display_name": "Telegram: Send Notification",
+      "auth_profile_id": "telegram-bot-token",
+      "identity": "bot",
+      "required_scopes": [],
+      "policy_keys": [
+        "integrations.telegram.bot.notify"
+      ],
+      "substrate": "rest",
+      "maturity": "preview",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "write",
+      "component_ref": "TelegramNotifyComponent"
+    }
+  ]
+}

lfx_telegram/components/telegram/telegram_notify.py

@@ -0,0 +1,29 @@
+"""Send a plain-text Telegram message as the connected bot."""
+
+from lfx.io import BoolInput, MessageTextInput, MultilineInput, Output
+from lfx.schema.data import Data
+
+from lfx_telegram._base import TelegramActionComponent, connection_input
+from lfx_telegram._validation import message_payload
+
+
+class TelegramNotifyComponent(TelegramActionComponent):
+    display_name = "Telegram: Send Notification"
+    description = "Use Telegram Send Message with Silent Notification enabled for new flows."
+    name = "TelegramNotify"
+    legacy = True
+    replacement = ["telegram.TelegramSendMessageComponent"]
+    capability_id = "telegram.bot.notify"
+    inputs = [
+        connection_input(capabilities=[capability_id]),
+        MessageTextInput(name="chat_id", display_name="Chat ID", required=True),
+        MultilineInput(name="text", display_name="Text", required=True),
+        MessageTextInput(name="thread_id", display_name="Thread ID", advanced=True),
+        BoolInput(name="silent", display_name="Silent Notification", value=True, advanced=True),
+    ]
+    outputs = [Output(display_name="Sent Message", name="message", method="build_message")]
+
+    async def build_message(self) -> Data:
+        return await self.send(
+            message_payload(chat_id=self.chat_id, text=self.text, thread_id=self.thread_id, silent=self.silent)
+        )

lfx_telegram/components/telegram/telegram_on_command.py

@@ -0,0 +1,27 @@
+"""Declare a trigger for commands addressed to a Telegram bot."""
+
+from lfx.io import StrInput
+
+from lfx_telegram._triggers import TelegramTriggerComponent, trigger_inputs
+
+
+class TelegramOnCommandTriggerComponent(TelegramTriggerComponent):
+    display_name = "Telegram: On Command"
+    description = "Receive bot commands in explicitly allowed chats, with optional command and sender filters."
+    name = "TelegramOnCommandTrigger"
+    trigger_kind = "telegram.command"
+    capability_ids = ("telegram.trigger.command.webhook", "telegram.trigger.command.poll")
+    config_fields = (*TelegramTriggerComponent.config_fields, "commands")
+    inputs = [
+        *trigger_inputs("command"),
+        StrInput(
+            name="commands",
+            display_name="Commands",
+            is_list=True,
+            value=[],
+            info=(
+                "Up to 100 unique names of 1 to 32 lowercase letters, digits, or underscores, without a slash. "
+                "Empty means every command addressed to this bot."
+            ),
+        ),
+    ]

lfx_telegram/components/telegram/telegram_on_message.py

@@ -0,0 +1,12 @@
+"""Declare a trigger for messages from explicitly allowed Telegram chats."""
+
+from lfx_telegram._triggers import TelegramTriggerComponent, trigger_inputs
+
+
+class TelegramOnMessageTriggerComponent(TelegramTriggerComponent):
+    display_name = "Telegram: On Message"
+    description = "Receive new text messages visible to your bot in explicitly allowed chats."
+    name = "TelegramOnMessageTrigger"
+    trigger_kind = "telegram.message"
+    capability_ids = ("telegram.trigger.message.webhook", "telegram.trigger.message.poll")
+    inputs = trigger_inputs("message")

lfx_telegram/components/telegram/telegram_reply.py

@@ -0,0 +1,39 @@
+"""Reply using the target and bot identity of a Telegram trigger event."""
+
+from lfx.integrations.errors import InvalidRequestError
+from lfx.io import DataInput, MultilineInput, Output
+from lfx.schema.data import Data
+
+from lfx_telegram._base import TelegramActionComponent, connection_input
+from lfx_telegram._validation import message_payload, numeric_id
+
+
+class TelegramReplyComponent(TelegramActionComponent):
+    display_name = "Telegram: Reply to Message"
+    description = "Reply to a trigger event using the same bot, chat, and topic."
+    name = "TelegramReply"
+    capability_id = "telegram.bot.reply"
+    inputs = [
+        connection_input(capabilities=[capability_id]),
+        DataInput(name="event", display_name="Trigger Event", required=True),
+        MultilineInput(name="text", display_name="Text", required=True),
+    ]
+    outputs = [Output(display_name="Sent Message", name="message", method="build_message")]
+
+    async def build_message(self) -> Data:
+        event = self.event.data if isinstance(self.event, Data) else self.event
+        if isinstance(event, dict) and isinstance(event.get("payload"), dict):
+            event = event["payload"]
+        if isinstance(event, dict):
+            event = event.get("data", event.get("delivery", event))
+        if not isinstance(event, dict) or event.get("provider") != "telegram":
+            msg = "Choose a Telegram trigger event to reply to."
+            raise InvalidRequestError(msg, provider="telegram")
+        bot_id = str(numeric_id(event.get("bot_id"), positive=True))
+        payload = message_payload(
+            chat_id=event.get("chat_id"),
+            text=self.text,
+            thread_id=event.get("thread_id"),
+            reply_id=event.get("message_id"),
+        )
+        return await self.send(payload, expected_bot_id=bot_id)

lfx_telegram/components/telegram/telegram_send_message.py

@@ -0,0 +1,27 @@
+"""Send a plain-text Telegram message as the connected bot."""
+
+from lfx.io import BoolInput, MessageTextInput, MultilineInput, Output
+from lfx.schema.data import Data
+
+from lfx_telegram._base import TelegramActionComponent, connection_input
+from lfx_telegram._validation import message_payload
+
+
+class TelegramSendMessageComponent(TelegramActionComponent):
+    display_name = "Telegram: Send Message"
+    description = "Send one plain-text message to a chat your bot can access."
+    name = "TelegramSendMessage"
+    capability_id = "telegram.bot.send"
+    inputs = [
+        connection_input(capabilities=[capability_id]),
+        MessageTextInput(name="chat_id", display_name="Chat ID", required=True),
+        MultilineInput(name="text", display_name="Text", required=True),
+        MessageTextInput(name="thread_id", display_name="Thread ID", advanced=True),
+        BoolInput(name="silent", display_name="Silent Notification", value=False, advanced=True),
+    ]
+    outputs = [Output(display_name="Sent Message", name="message", method="build_message")]
+
+    async def build_message(self) -> Data:
+        return await self.send(
+            message_payload(chat_id=self.chat_id, text=self.text, thread_id=self.thread_id, silent=self.silent)
+        )

lfx_telegram/extension.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-telegram",
+  "version": "0.1.0",
+  "name": "Telegram",
+  "description": "Telegram bot message and command triggers, messages, replies, and notifications.",
+  "lfx": {
+    "compat": [
+      "1"
+    ]
+  },
+  "bundles": [
+    {
+      "name": "telegram",
+      "path": "components/telegram"
+    }
+  ],
+  "integrations": [
+    {
+      "provider_id": "telegram",
+      "bundle": "telegram",
+      "path": "capabilities.v1.json"
+    }
+  ]
+}

lfx_telegram-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: lfx-telegram
+Version: 0.1.0
+Summary: Connection-backed Telegram bot actions and triggers for Langflow.
+License: MIT
+Requires-Python: <3.16,>=3.10
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Requires-Dist: lfx<2.0.0,>=1.14.0.dev0
+Description-Content-Type: text/markdown
+
+# Telegram integration
+
+This bundle provides connection-backed Telegram bot actions and webhook or polling triggers.
+
+See the [Telegram integration setup guide](https://docs.langflow.org/next/bundles-telegram) for installation, permissions, supported environments, receiver setup, and recovery. The guide's source is [bundles-telegram.mdx](../../../docs/docs/Components/bundles-telegram.mdx).

lfx_telegram-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+lfx_telegram/__init__.py,sha256=1OehYfJnFZk9QxvqiNMcfFNBCiqDLOUax01_lTNmdc4,472
+lfx_telegram/_base.py,sha256=k9Kgw-tOktcOOveAScYJpnTg4lPcxLpqI6urO3F1CCk,2723
+lfx_telegram/_client.py,sha256=KioO1orkQi8XNgTE3xzuset_pPZyK_vJIYwAlO7duvk,5763
+lfx_telegram/_triggers.py,sha256=ik4llIc2qOJ2yKbV4ZNUIiRMnJ3UecuRB6VYZyuiS3o,2693
+lfx_telegram/_validation.py,sha256=puknt0syP35jHzXuXMPW_tf8Sv7A0gQqpx_MXmHk_70,2016
+lfx_telegram/extension.json,sha256=M6f6T8Pifhttf4s8n-W0Ys_hgLWxKNQDWPUmK7imWMQ,512
+lfx_telegram/components/__init__.py,sha256=uqUIw8mTuKaYpUBXVqmRs4d3r6NZkmQMD2KB8U4nFBM,36
+lfx_telegram/components/telegram/__init__.py,sha256=Tu3TMmvau_7IuW8lchYOETQlDHZTwYdI3H88LLFxmb8,531
+lfx_telegram/components/telegram/capabilities.v1.json,sha256=YyD_rQJhZHqzPr7w4qG6A2RQhjWSqMeSyGHPl8aZY9M,4331
+lfx_telegram/components/telegram/telegram_notify.py,sha256=70JiocryDhUC55-k9DXwODnqxESwHM94IHaz9UmulOE,1347
+lfx_telegram/components/telegram/telegram_on_command.py,sha256=hPfgLn08r7goHBMO2mUHk-YvvHnsbuBftWiHDG63wbQ,1050
+lfx_telegram/components/telegram/telegram_on_message.py,sha256=mQOioJCqwnNA5t1oiOGGb-oYqbZjF8-HEig0KrBvFVo,566
+lfx_telegram/components/telegram/telegram_reply.py,sha256=uMDlX20cFRkcfCBCQ-ZVwdwg9SUpqqkst1RkitQY2ZY,1824
+lfx_telegram/components/telegram/telegram_send_message.py,sha256=HrhqMmzAJgjwD1uzeI06HmVkJsP2L2nW8bqcF72WtaE,1258
+lfx_telegram-0.1.0.dist-info/METADATA,sha256=LNJwI7_QxiymLs41EZW-5OBT4jAR12AfoaOD2EOroFU,683
+lfx_telegram-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+lfx_telegram-0.1.0.dist-info/entry_points.txt,sha256=WhAd6NmBVIULJ35jXEDdGO6EI13UINggtlAIaQmWopA,155
+lfx_telegram-0.1.0.dist-info/RECORD,,

lfx_telegram-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

lfx_telegram-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[langflow.extensions]
+lfx-telegram = lfx_telegram
+
+[langflow.trigger_providers]
+telegram = langflow.services.triggers.providers.telegram.provider:PROVIDER