@omnisocials/mcp-server 1.39.0 → 1.46.0

package/README.md

@@ -112,6 +112,8 @@ OmniSocials accepts the following channel IDs in `create_post`, `create_and_publ
 | `threads` | Threads | Posts, chained threads via `threads.thread_parts`, location tagging via `threads.location_id` (rolling out) |
 | `bluesky` | Bluesky | Posts, chained threads via `bluesky.thread_parts` |
 | `mastodon` | Mastodon | Posts, chained threads via `mastodon.thread_parts` |
+| `telegram` | Telegram | A channel or group the OmniSocials bot posts to: text, photos, videos, GIFs, albums of up to 10, native polls and link buttons via `telegram` |
+| `discord` | Discord | One Discord channel, posted through its webhook: text, up to 10 images, GIFs and videos, native polls, link buttons and forum post titles via `discord` |
 
 ## Available Tools
 
@@ -206,11 +208,24 @@ Apply a set when creating a post: `create_post` / `create_and_publish_post` acce
 
 Requires an API key with the opt-in `inbox:read` / `inbox:write` scopes — enable "Social Inbox access" when you create the key.
 
+### Automations (6 tools)
+
+| Tool | Description |
+|------|-------------|
+| `list_automations` | List the comment-to-DM automations of the workspace (Instagram and Facebook Page), optionally by `status`, `post_id` or `platform` |
+| `get_automation` | Get one automation: trigger, keywords, DM text, public reply, limits and stats |
+| `create_automation` | Create a comment-to-DM automation: a keyword in a comment (or a DM) gets a DM back, once per person, with an optional public reply |
+| `update_automation` | Pause, resume or change the keywords, DM text, public reply, limits or post of an automation |
+| `delete_automation` | Delete an automation |
+| `get_automation_activity` | One row per comment or message the automation acted on: the DM sent, a skip with its reason, or the platform's error |
+
+Requires an API key with the opt-in `automations:read` / `automations:write` scopes (Settings > API, "Automations" on the key).
+
 ## Environment Variables
 
 | Variable | Required | Description |
 |----------|----------|-------------|
-| `OMNISOCIALS_API_KEY` | Yes | Your API key (`omsk_live_*` or `omsk_test_*`). Comma-separated for multiple workspaces. |
+| `OMNISOCIALS_API_KEY` | Yes | Your API key (`omsk_live_*`; there are no test keys). Comma-separated for multiple workspaces. |
 | `OMNISOCIALS_BASE_URL` | No | Custom API base URL (defaults to production) |
 
 ## Alternative: Agent Skills
@@ -229,6 +244,44 @@ Full API docs: [docs.omnisocials.com](https://docs.omnisocials.com)
 
 ## Changelog
 
+### 1.46.0 (2026-10-23)
+
+- **Added: comment-to-DM on a Facebook Page.** The automation tools now run on the connected Facebook Page as well as on Instagram. `create_automation` takes `platform` (`instagram`, the default, or `facebook`) and `facebook_post_id` (a Page post published outside OmniSocials, `{page-id}_{post-id}` or the post id alone; it implies `facebook`). On Facebook the DM lands in Messenger, `triggers` takes `comment` and `dm` (a keyword in a Messenger message to the Page), and `story_reply` is refused (Facebook has no story replies). Meta's rules are the same on both: one private reply per comment within 7 days, a follow-up only after the person answers. `list_automations` takes a `platform` filter and shows a Platform column; `get_automation` and `create_automation` print the platform. `update_automation` takes `facebook_post_id` to move a Facebook automation to another Page post; the platform itself cannot change (`platform_immutable`). `get_automation_activity` shows a Facebook person by name, without an @. Same on the companion server (`mcp.omnisocials.com`).
+- **Added: `platforms` on `comment_dm_automation`.** `create_post`, `create_and_publish_post` and `update_post` take `comment_dm_automation.platforms`: `["instagram"]`, `["facebook"]` or both, one automation per channel with the same keywords, DM, public reply and limits. Each listed channel must be a channel of the post. Without it, the post gets one automation: Instagram when the post goes there, else Facebook. On `update_post` a channel no longer listed loses its automation, and `null` removes them all. The post shows every automation id with its channel; `get_post` shows them for a post that goes to Instagram or Facebook.
+- **Added: Discord.** `discord` is a new channel ID: one Discord channel the user connected in OmniSocials (with Continue with Discord, or by pasting a webhook URL). The post is sent through the channel's webhook, so it shows the webhook's name and picture. `create_post`, `create_and_publish_post` and `update_post` take a `discord` object: `silent` (no notification), `link_preview` (`false` hides the link previews), `allow_mentions` (off by default: @everyone, @here and role mentions in the text ping nobody until it is `true`), `spoiler`, `thread_name` (the post title in a forum or media channel, where Discord requires one; max 100 chars), up to 5 `buttons` (`{ text, url }`, labels up to 80 chars, not with a poll) and a native `poll` (`{ options: 2-10 of up to 55 chars, duration_hours: 1-768 (default 24), multiple }`; the post text is the question, max 300 chars; no media). Text up to 2,000 characters; up to 10 images, GIFs and videos per message, which may mix; a video or GIF over Discord's 20 MB file limit is sent as a link in the message (listed in `result.video_links`); no Stories; a Reel is sent as one video message. On `update_post` every key merges into the stored options and `null` removes it. `get_post` prints the options and, once sent, the link to the message. `list_accounts` and `get_account` show the server, the channel name and type (`platform_details.channel_name` and `channel_type`: read by the OmniSocials bot, which Continue with Discord adds with no permissions, or given by the person when connecting), the webhook name, the channel id, how it was connected and the channel link; with the bot in the server, `get_account_analytics` shows the member count as followers. Discord gives webhooks no view counts: `get_post_analytics` shows the reactions (total and per emoji) and the poll votes. Same on the companion server (`mcp.omnisocials.com`), whose version is 1.46.0 too.
+
+### 1.45.0 (not published; included in 1.46.0)
+
+- **Added: a link to the post on every post tool.** `publish_post`, `retry_post`, `approve_post` and `reject_post` now end with the "Open in OmniSocials" row that `create_post`, `create_and_publish_post`, `get_post` and `update_post` already had, and `publish_post` says that `get_post` lists the live links once each platform has posted. Every app link carries `?ref=mcp`, so OmniSocials can count the visits from an agent's answer (the app ignores the parameter).
+- **Added on the companion server (`mcp.omnisocials.com`): the post card.** In apps that show MCP Apps (Claude, ChatGPT, Cursor, VS Code), the results of `get_post`, `create_post`, `create_and_publish_post`, `update_post`, `publish_post`, `retry_post`, `approve_post` and `reject_post` appear as a card: the post the way each platform will show it, a channel list with each channel's state (the planned time, Posting, Posted with its live link, or Failed with the reason), and a link into OmniSocials. While a post publishes, the card follows it until every channel is done. Other clients (terminal agents, automations) get the same text answer as before. The card is built as an MCP App resource, `ui://omnisocials/post-card.html`; a new tool, `get_post_status`, is only for the card (hidden from the model in apps that support MCP Apps).
+
+### 1.44.0 (2026-10-17, not published; included in 1.46.0)
+
+- **Added: Telegram.** `telegram` is a new channel ID: a Telegram channel or group the user connected in OmniSocials, where the OmniSocials bot is an admin that can post. `create_post`, `create_and_publish_post` and `update_post` take a `telegram` object: `silent`, `link_preview`, `pin`, `protect_content`, `spoiler`, `caption_above_media`, up to 3 `buttons` (`{ text, url }`, one per row, not on an album or a poll), a native `poll` (`{ options: 2-12 of up to 100 chars, open_period: 5-2628000 seconds, multiple }`; the post text is the question, max 300 chars; no media) and `first_comment` (a reply under the post). Text up to 4,096 characters; with media, text over 1,024 characters is sent as a reply under the media. Albums hold up to 10 photos and videos; a GIF goes on its own; files up to 50 MB; no Stories; a Reel is sent as a video message. On `update_post` every key merges into the stored options and `null` removes it. `get_post` prints the options and, once sent, the message count, the pin and the link. `list_accounts` and `get_account` show the chat type, the subscribers and the link. Telegram gives bots no view counts: `get_post_analytics` shows the reactions (total and per emoji) and the poll votes. Same on the companion server (`mcp.omnisocials.com`).
+- **Changed: the three version strings match again.** `package.json`, the stdio server and the companion server all say 1.44.0 (the stdio server said 1.42.0 and the companion server 1.41.0 after the last releases).
+
+### 1.43.0 (2026-10-12, not published; included in 1.46.0)
+
+- **Polls on X, Threads and Mastodon.** `create_post`, `create_and_publish_post` and `update_post` take `poll` under `x`, `threads` and `mastodon` (the post text is the question): X `{ options: 2-4 of up to 25 chars, duration_minutes: 5-10080 }`, Threads `{ options: 2-4 of 1-25 chars }` (closed by Threads after 24 hours), Mastodon `{ options, expires_in, multiple, hide_totals }` within the instance's limits. The API refuses a channel with a poll and media; on a thread the poll goes on the first part. `null` on `update_post` removes it. `get_post` prints the poll per channel.
+
+### 1.42.0 (not published; included in 1.46.0)
+
+- **Added: comment-to-DM automations.** Six new tools manage the Instagram comment-to-DM automations of the workspace: `list_automations`, `get_automation`, `create_automation`, `update_automation` (pause, resume, new keywords, new DM text, new limits, another post), `delete_automation` and `get_automation_activity` (one row per comment or message the automation acted on: the DM sent, a skip with its reason, or Instagram's error). An automation DMs a person once when they comment a keyword on a post, and can post a public reply under the comment; `triggers` also takes `dm` (a keyword in a DM to the account) and `story_reply` (a keyword in a reply to a story). `scope` is one post (`post_id` = an OmniSocials post, scheduled or live; `instagram_media_id` = a post published outside OmniSocials, read from Instagram to check it belongs to the account), `next_post` (the next Instagram post the workspace publishes) or `any` (every post). Backed by the new `/automations` endpoints, which need the opt-in API key scopes `automations:read` and `automations:write` (Settings > API, "Automations" on the key); the tools say so on a 403. Same on the companion server (`mcp.omnisocials.com`), where the OAuth session needs the `create_schedule_post` permission for the writes.
+- **Added: `comment_dm_automation` on `create_post`, `create_and_publish_post` and `update_post`.** A comment-to-DM automation bound to the new post (Instagram must be a channel): `{ trigger: { keywords, match }, actions: { dm: { text }, public_reply: { enabled, variations } }, limits: { max_sends, stop_at } }`. The automation starts listening once the post is live on Instagram. On `update_post` the object replaces the post's automation and `null` removes it. The created automation comes back as `comment_dm_automation` on the post, and `get_post` shows it for a post that goes to Instagram. Same on the companion server.
+
+### 1.41.0 (not published; included in 1.46.0)
+
+- **Added: image fit per channel (`media_fit`).** A feed image whose ratio is outside what a channel shows uncropped is handled per channel at create time. Instagram shows feed images between 4:5 and 1.91:1: a 9:16 (story-style) or very wide image posted to the Instagram feed is now cropped to 4:5 / 1.91:1 around the subject by default, because Instagram cut it to that window anyway (a blind centre crop) and Meta cannot boost a feed post outside it. Pinterest keeps a Pin taller than 2:3 and reports it. `create_post`, `create_and_publish_post` and `update_post` take `media_fit: { instagram: "auto" | "crop" | "keep", pinterest: ... }`; every decision comes back as a `warnings` entry with code `image_fit` (`action` cropped / kept / crop_failed, the crop's url, and how to undo it). The crop is a separate file for that channel only; `default` and the other channels keep the original; stories, reels and videos are never cropped. On `update_post`, `media_fit` alone re-decides the stored images (`keep` gives the original back). Same on the companion server (`mcp.omnisocials.com`).
+- **Changed: `check_media_compatibility` reports image fit.** For an image whose size is known (a library file of the workspace) the answer lists, per connected channel with a rule, whether its feed shows the image uncropped and what a post does by default, so an assistant can ask "crop to 4:5 or keep the original?" before it posts. Media items (`list_media`, `get_media`, uploads) now carry `width` and `height`.
+
+### 1.40.0 (not published; included in 1.46.0)
+
+- **Changed: the MCP SDK dependency moves to 1.32.1.** GHSA-6qxp-vccf-f47h (CVE-2026-104850) is in the SDK's OAuth client, which let an MCP server name the authorization server that received the client's credentials. This package is a server and talks to OmniSocials with an API key, so it was not affected; the move clears the advisory for everyone who installs it.
+
+### 1.39.1 (2026-10-06, not published; included in 1.46.0)
+
+- **Changed: `list_pinterest_products` names an account without a catalog.** Pinterest answers HTTP 409 ("Can't access this feature without an existing catalog") when the connection has catalog access but the account has no catalog yet. The API now returns `no_catalog: true` with empty `products` and `product_groups` instead of a `platform_error`, and the tool says where the user adds products (https://www.pinterest.com/business/catalogs/). Seen live on 2026-10-06, the first day of the feature.
+
 ### 1.39.0 (2026-10-05)
 
 - **Added: tag products on a Pinterest Pin.** `pinterest.product_tags` on `create_post`, `create_and_publish_post` and `update_post` takes up to 24 product Pins of the connected Pinterest account (Pin IDs or Pin links), so people can shop the items in the image. Pinterest accepts a product only when its Pin is public, belongs to the same account and links to a website that account claimed; products of other merchants cannot be tagged. The tags are added right after the Pin is published. A product that Pinterest refuses never fails the post: the other products are still tagged, and `get_post` shows the outcome (`product_tags_result`, with Pinterest's reason for each product that was not tagged).
@@ -365,7 +418,7 @@ Full API docs: [docs.omnisocials.com](https://docs.omnisocials.com)
 ### 1.16.0
 
 - **Hashtag sets:** save reusable, named groups of hashtags per workspace and apply one to a new post in a single call. Four new tools: `list_hashtag_sets`, `create_hashtag_set`, `update_hashtag_set`, `delete_hashtag_set`.
-- `create_post` / `create_and_publish_post` accept `hashtag_set`, `hashtag_placement` (`caption_append` default, or `first_comment`), and `hashtag_platforms`. The set expands server-side once at create time — editing a set later never changes existing posts; duplicate tags are skipped; Instagram's 30-hashtag cap fails fast with `hashtag_limit_exceeded`.
+- `create_post` / `create_and_publish_post` accept `hashtag_set`, `hashtag_placement` (`caption_append` default, or `first_comment`), and `hashtag_platforms`. The set expands server-side once at create time — editing a set later never changes existing posts; duplicate tags are skipped; Instagram's 5-hashtag cap fails fast with `hashtag_limit_exceeded`.
 - Same tools on the companion server (`mcp.omnisocials.com`).
 
 ### 1.15.0

package/build/client.d.ts

@@ -1,4 +1,4 @@
-import type { Account, AnalyticsOverview, AccountAnalyticsEntry, ApiPost, ApiResponse, ApiVideoCover, AudioSearchResult, BestTimesResult, HashtagSet, LocationSearchResult, PinterestProductCheck, PinterestProductsResult, MediaCheckResult, MediaCompatibility, MediaFolder, MediaItem, PdfUploadResult, PostAnalytics, PublishPostResult, RecentPlatformPost, RetryPostResult, ApprovePostResult, RejectPostResult, PostApproval, InboxConversation, InboxDeleteResult, InboxMessage, InboxNextUnanswered, Webhook } from "./types.js";
+import type { Account, AnalyticsOverview, AccountAnalyticsEntry, ApiPost, ApiResponse, ApiVideoCover, AudioSearchResult, Automation, AutomationEvent, AutomationEventsResult, AutomationInput, BestTimesResult, CommentDmAutomationInput, HashtagSet, LocationSearchResult, PinterestProductCheck, PinterestProductsResult, MediaCheckResult, MediaCompatibility, MediaFolder, MediaItem, PdfUploadResult, PostAnalytics, PublishPostResult, RecentPlatformPost, RetryPostResult, ApprovePostResult, RejectPostResult, PostApproval, InboxConversation, InboxDeleteResult, InboxMessage, InboxNextUnanswered, Webhook } from "./types.js";
 export declare function fetchImageAsBase64(url: string): Promise<{
     data: string;
     mimeType: string;
@@ -44,10 +44,27 @@ export interface XThreadPartInput {
      * Entries may be `{ url, alt }` to attach alt text (photos/GIFs only). */
     media_urls?: MediaUrlEntry[];
 }
+/**
+ * A poll on an X, Threads or Mastodon post (the post text is the question).
+ * X: 2 to 4 options of up to 25 characters, duration_minutes 5 to 10080
+ * (default 1440). Threads: 2 to 4 options of 1 to 25 characters, closed by
+ * Threads after 24 hours. Mastodon: options and expires_in (seconds) within
+ * the instance's limits, plus multiple and hide_totals. No media together
+ * with a poll; on a thread the poll goes on the first part. On update,
+ * `null` removes the poll.
+ */
+export interface ChannelPollInput {
+    options: string[];
+    duration_minutes?: number;
+    expires_in?: number;
+    multiple?: boolean;
+    hide_totals?: boolean;
+}
 export interface XPostOptions {
     reply_settings?: "" | "following" | "mentionedUsers";
     paid_partnership?: boolean;
     made_with_ai?: boolean;
+    poll?: ChannelPollInput | null;
     /** Provide 2–25 parts to publish as a thread. Omit for a single tweet. */
     thread_parts?: XThreadPartInput[];
 }
@@ -93,6 +110,7 @@ export interface MastodonThreadPartInput {
     media_urls?: MediaUrlEntry[];
 }
 export interface MastodonPostOptions {
+    poll?: ChannelPollInput | null;
     /** Provide 2–25 parts to publish as a thread. Omit for a single status. */
     thread_parts?: MastodonThreadPartInput[];
 }
@@ -101,8 +119,96 @@ export interface MastodonPostOptions {
  * single status); `undefined` leaves the existing thread untouched.
  */
 export interface MastodonPostOptionsUpdate {
+    poll?: ChannelPollInput | null;
     thread_parts?: MastodonThreadPartInput[] | null;
 }
+export interface TelegramButtonInput {
+    /** Button label, 1 to 64 characters. */
+    text: string;
+    /** https://, http:// or tg:// link. */
+    url: string;
+}
+export interface TelegramPollInput {
+    /** 2 to 12 answer options of up to 100 characters, all different. */
+    options: string[];
+    /** Seconds the poll stays open (5 to 2628000). Omit to keep it open. */
+    open_period?: number;
+    /** Allow several answers per person. */
+    multiple?: boolean;
+}
+export interface TelegramPostOptions {
+    silent?: boolean | null;
+    link_preview?: boolean | null;
+    pin?: boolean | null;
+    protect_content?: boolean | null;
+    spoiler?: boolean | null;
+    caption_above_media?: boolean | null;
+    /** Up to 3 link buttons, one per row. Not on an album or a poll. */
+    buttons?: TelegramButtonInput[] | null;
+    /** A native poll; the post text is the question (max 300 characters). */
+    poll?: TelegramPollInput | null;
+    /** A reply under the post, sent right after it is published. */
+    first_comment?: string;
+}
+/** What GET /posts/{id} returns under `telegram` once the post went out. */
+export interface TelegramPostResult {
+    chat_id: string | null;
+    message_ids: string[];
+    pinned: boolean;
+    pin_error?: string;
+    text_message_id?: string;
+    link_public: string | null;
+    link_private: string | null;
+    sent_at: string | null;
+}
+export interface DiscordButtonInput {
+    /** Button label, 1 to 80 characters. */
+    text: string;
+    /** https:// or http:// link. */
+    url: string;
+}
+export interface DiscordPollInput {
+    /** 2 to 10 answer options of up to 55 characters, all different. */
+    options: string[];
+    /** Hours the poll stays open (1 to 768). Default 24. */
+    duration_hours?: number;
+    /** Allow several answers per person. */
+    multiple?: boolean;
+}
+export interface DiscordPostOptions {
+    /** Send without a push or desktop notification (@silent). */
+    silent?: boolean | null;
+    /** false hides the previews of the links in the text. */
+    link_preview?: boolean | null;
+    /** true lets @everyone, @here, role and user mentions ping. Off by default. */
+    allow_mentions?: boolean | null;
+    /** Blur every image and video until someone clicks it. */
+    spoiler?: boolean | null;
+    /** Post title in a forum or media channel (required there), max 100 characters. */
+    thread_name?: string | null;
+    /** Up to 5 link buttons in one row. Not with a poll. */
+    buttons?: DiscordButtonInput[] | null;
+    /** A native poll; the post text is the question (max 300 characters). */
+    poll?: DiscordPollInput | null;
+}
+/** What GET /posts/{id} returns under `discord` once the message went out. */
+export interface DiscordPostResult {
+    webhook_id: string | null;
+    guild_id: string | null;
+    channel_id: string | null;
+    /** The forum post the message opened, in a forum or media channel. */
+    thread_id: string | null;
+    message_id: string | null;
+    /** discord.com/channels/<server>/<channel or thread>/<message>. */
+    url: string | null;
+    sent_at: string | null;
+    /** Media sent as a link in the text (videos and GIFs over 20 MB). */
+    video_links: string[];
+    /** A second message with the media links, when they did not fit in the text. */
+    link_message_id: string | null;
+    /** Codes such as "media_sent_as_links" or "links_sent_as_follow_up". */
+    warnings: string[];
+}
 export interface ThreadsThreadPartInput {
     /** Part text, 1 to 500 characters. */
     text: string;
@@ -114,6 +220,7 @@ export interface ThreadsThreadPartInput {
     media_urls?: MediaUrlEntry[];
 }
 export interface ThreadsPostOptions {
+    poll?: ChannelPollInput | null;
     /** Provide 2 to 25 parts to publish as a thread. Omit for a single post.
      * When set, the Threads caption is taken from part 1. */
     thread_parts?: ThreadsThreadPartInput[];
@@ -128,6 +235,7 @@ export interface ThreadsPostOptions {
  * single post); `undefined` leaves the existing thread untouched.
  */
 export interface ThreadsPostOptionsUpdate {
+    poll?: ChannelPollInput | null;
     thread_parts?: ThreadsThreadPartInput[] | null;
     /** New Threads location id, or null to remove the tag. Omit to leave the
      * existing tag untouched. */
@@ -152,6 +260,10 @@ export interface CreatePostInput {
     content: string | Record<string, string>;
     channels?: string[];
     scheduled_at?: string;
+    /** With scheduled_at: keep the time but store the post as a draft (planned draft). */
+    draft?: boolean;
+    /** Image fit per channel: { instagram: "auto" | "crop" | "keep" }. */
+    media_fit?: Record<string, "auto" | "crop" | "keep">;
     media_ids?: MediaIdEntry[] | Record<string, MediaIdEntry[]>;
     media_urls?: MediaUrlEntry[] | Record<string, MediaUrlEntry[]>;
     type?: string;
@@ -183,11 +295,15 @@ export interface CreatePostInput {
     mastodon?: MastodonPostOptions;
     threads?: ThreadsPostOptions;
     google_business?: Record<string, unknown>;
+    telegram?: TelegramPostOptions | null;
+    discord?: DiscordPostOptions | null;
     hashtag_set?: string;
     hashtag_placement?: "caption_append" | "first_comment";
     hashtag_platforms?: string[];
     /** Route the post through a saved approval workflow (GET /approval-workflows). */
     approval_workflow_id?: string;
+    /** Comment-to-DM automations bound to this post (Instagram or Facebook must be a channel). `null` removes them on update. */
+    comment_dm_automation?: CommentDmAutomationInput | null;
 }
 export interface ApprovalWorkflowApprover {
     id: string;
@@ -234,6 +350,8 @@ export declare class OmniSocialsClient {
     updatePost(id: string, data: {
         content?: string | Record<string, string>;
         scheduled_at?: string;
+        /** false = schedule a planned draft at its stored time; true = unschedule, keep the time. */
+        draft?: boolean;
         channels?: string[];
         media_ids?: MediaIdEntry[] | Record<string, MediaIdEntry[]>;
         media_urls?: MediaUrlEntry[] | Record<string, MediaUrlEntry[]>;
@@ -258,12 +376,15 @@ export declare class OmniSocialsClient {
         linkedin?: Record<string, unknown>;
         linkedin_page?: Record<string, unknown>;
         linkedin_poll?: LinkedInPollInput | null;
+        comment_dm_automation?: CommentDmAutomationInput | null;
         tiktok?: Record<string, unknown>;
         x?: XPostOptionsUpdate;
         bluesky?: BlueskyPostOptionsUpdate;
         mastodon?: MastodonPostOptionsUpdate;
         threads?: ThreadsPostOptionsUpdate;
         google_business?: Record<string, unknown>;
+        telegram?: TelegramPostOptions | null;
+        discord?: DiscordPostOptions | null;
     }): Promise<ApiResponse<ApiPost>>;
     deletePost(id: string): Promise<ApiResponse<unknown>>;
     publishPost(id: string): Promise<ApiResponse<PublishPostResult>>;
@@ -343,6 +464,20 @@ export declare class OmniSocialsClient {
         hashtags?: string[];
     }): Promise<ApiResponse<HashtagSet>>;
     deleteHashtagSet(id: string): Promise<ApiResponse<unknown>>;
+    listAutomations(params?: {
+        status?: string;
+        post_id?: string;
+        platform?: string;
+    }): Promise<ApiResponse<Automation[]>>;
+    getAutomation(id: string): Promise<ApiResponse<Automation>>;
+    createAutomation(data: AutomationInput): Promise<ApiResponse<Automation>>;
+    updateAutomation(id: string, data: AutomationInput): Promise<ApiResponse<Automation>>;
+    deleteAutomation(id: string): Promise<ApiResponse<unknown>>;
+    listAutomationEvents(id: string, params?: {
+        outcome?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<AutomationEvent[]> & Partial<Omit<AutomationEventsResult, "data">>>;
     listAccounts(): Promise<ApiResponse<Account[]> & {
         workspace_id?: number | string | null;
         workspace_name?: string | null;

package/build/client.js

@@ -198,6 +198,13 @@ export function metricRows(m) {
     }
     return rows;
 }
+// Query params as strings, without the undefined ones (request() takes
+// Record<string, string>).
+const queryString = (params) => params
+    ? Object.fromEntries(Object.entries(params)
+        .filter(([, v]) => v !== undefined && v !== null)
+        .map(([k, v]) => [k, String(v)]))
+    : undefined;
 export class OmniSocialsClient {
     baseUrl;
     apiKey;
@@ -391,6 +398,26 @@ export class OmniSocialsClient {
     async deleteHashtagSet(id) {
         return this.request("DELETE", `/hashtag-sets/${id}`);
     }
+    // Comment-to-DM automations (opt-in scopes automations:read / automations:write)
+    async listAutomations(params) {
+        return this.request("GET", "/automations", undefined, queryString(params));
+    }
+    async getAutomation(id) {
+        return this.request("GET", `/automations/${id}`);
+    }
+    async createAutomation(data) {
+        return this.request("POST", "/automations", data);
+    }
+    async updateAutomation(id, data) {
+        return this.request("PATCH", `/automations/${id}`, data);
+    }
+    async deleteAutomation(id) {
+        return this.request("DELETE", `/automations/${id}`);
+    }
+    // The events response is not the plain list envelope: { data, counts, pagination }.
+    async listAutomationEvents(id, params) {
+        return this.request("GET", `/automations/${id}/events`, undefined, queryString(params));
+    }
     // Accounts. Alongside `data`, the list response carries the workspace's
     // identity top-level (backend/routes/api/v1/accounts.js) — the workspaces
     // tool reads it to label multi-workspace setups.

package/build/index.js

@@ -9,6 +9,7 @@ import { registerAccountTools } from "./tools/accounts.js";
 import { registerAnalyticsTools } from "./tools/analytics.js";
 import { registerWebhookTools } from "./tools/webhooks.js";
 import { registerHashtagSetTools } from "./tools/hashtag-sets.js";
+import { registerAutomationTools } from "./tools/automations.js";
 import { registerInboxTools } from "./tools/inbox.js";
 import { registerWorkspaceTools } from "./tools/workspaces.js";
 const apiKeyEnv = process.env.OMNISOCIALS_API_KEY;
@@ -29,7 +30,7 @@ const sessionState = { activeIndex: 0 };
 const getActiveClient = () => workspaceClients[sessionState.activeIndex].client;
 const server = new McpServer({
     name: "OmniSocials",
-    version: "1.39.0",
+    version: "1.46.0",
 });
 // Register all tools - pass getter function so tools always use the active workspace's client
 registerPostTools(server, getActiveClient);
@@ -38,6 +39,7 @@ registerAccountTools(server, getActiveClient);
 registerAnalyticsTools(server, getActiveClient);
 registerWebhookTools(server, getActiveClient);
 registerHashtagSetTools(server, getActiveClient);
+registerAutomationTools(server, getActiveClient);
 registerInboxTools(server, getActiveClient);
 registerWorkspaceTools(server, workspaceClients, sessionState);
 // Register prompts

package/build/metrics.js

@@ -57,6 +57,14 @@ export function getEngagement(platform, metrics) {
             return sum("likes", "comments", "reposts", "quotes", "bookmarks");
         case "mastodon":
             return sum("likes", "comments", "reposts", "quotes");
+        case "telegram":
+            // Reactions are the only post number a bot gets (message_reaction_count),
+            // stored as `likes` (total) next to `reactions` (per emoji).
+            return sum("likes");
+        case "discord":
+            // A webhook reads back its own message: reactions only (2026-10-22),
+            // stored the Telegram way, `likes` (total) next to `reactions` (per emoji).
+            return sum("likes");
         case "reddit":
             // likes == upvote score; shares == crossposts.
             return sum("likes", "comments", "shares");
@@ -177,6 +185,28 @@ export const UNSUPPORTED_POST_METRICS = {
         video_views: "Mastodon does not report video views.",
         engagement_rate: "Engagement rate needs impressions, which Mastodon does not report.",
     },
+    telegram: {
+        impressions: "Telegram does not give view counts to bots. Open the post in Telegram to see its views.",
+        reach: "Telegram does not report reach to bots.",
+        comments: "Telegram does not report comment counts to bots.",
+        shares: "Telegram does not report forwards to bots.",
+        saves: "Telegram does not report saves.",
+        clicks: "Telegram does not report clicks.",
+        link_clicks: "Telegram does not report clicks.",
+        video_views: "Telegram does not give view counts to bots.",
+        engagement_rate: "Engagement rate needs views, which Telegram does not give to bots.",
+    },
+    discord: {
+        impressions: "Discord does not report views. Open the message in Discord to see who reacted.",
+        reach: "Discord does not report reach.",
+        comments: "Discord does not report replies to a webhook message.",
+        shares: "Discord does not report shares.",
+        saves: "Discord does not report saves.",
+        clicks: "Discord does not report clicks.",
+        link_clicks: "Discord does not report clicks.",
+        video_views: "Discord does not report video views.",
+        engagement_rate: "Engagement rate needs views, which Discord does not report.",
+    },
     google_business: {
         impressions: "Google discontinued per-post metrics for Business Profiles in 2023.",
         reach: "Google discontinued per-post metrics for Business Profiles in 2023.",

package/build/tools/accounts.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { fetchImageAsBase64, capitalize } from "../client.js";
 export function registerAccountTools(server, getClient) {
-    server.tool("list_accounts", "List all connected social media accounts in the workspace. Each account includes its platform, display name, channel ID (used for create_post), supported content_types (post, story, reel), and `needs_reconnect` (true when the OAuth token has been revoked/expired and the user must reconnect before posts can succeed; also reflected in `status` as `needs_reconnect` instead of `active`). Pinterest accounts include a `boards` array with `{id, name}` — use the board `id` as `board_id` when creating Pinterest posts. X accounts with Premium include `platform_details` with `subscription_type` (e.g. \"Premium\", \"PremiumPlus\"). LinkedIn appears as two independent platforms: `linkedin` for a personal profile and `linkedin_page` for a company page. A workspace can have both connected at the same time and post to each separately. Call this to help users pick which platforms to post to.", {}, { title: "List Connected Accounts", readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async () => {
+    server.tool("list_accounts", "List all connected social media accounts in the workspace. Each account includes its platform, display name, channel ID (used for create_post), supported content_types (post, story, reel), and `needs_reconnect` (true when the OAuth token has been revoked/expired and the user must reconnect before posts can succeed; also reflected in `status` as `needs_reconnect` instead of `active`). Pinterest accounts include a `boards` array with `{id, name}` — use the board `id` as `board_id` when creating Pinterest posts. X accounts with Premium include `platform_details` with `subscription_type` (e.g. \"Premium\", \"PremiumPlus\"). Telegram accounts are a channel or group the OmniSocials bot posts to; `platform_details` carries `chat_type` (channel, supergroup or group), `subscribers` and `url`. Discord accounts are one Discord channel the workspace posts to through its webhook (posts show the webhook's name and picture); `platform_details` carries `guild_id`, `guild_name` (the server, when connected with Continue with Discord), `channel_id`, `channel_name` (read by the OmniSocials bot or given by the person, else null), `channel_type` (text, voice, announcement, stage, forum or media; a forum or media channel needs `discord.thread_name` on every post), `webhook_name`, `connect_method` (oauth or url) and `url`. LinkedIn appears as two independent platforms: `linkedin` for a personal profile and `linkedin_page` for a company page. A workspace can have both connected at the same time and post to each separately. Call this to help users pick which platforms to post to.", {}, { title: "List Connected Accounts", readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async () => {
         const result = await getClient().listAccounts();
         if (result.error) {
             return {
@@ -20,13 +20,21 @@ export function registerAccountTools(server, getClient) {
         md += `|---|----------|---------|---------------|------------|--------|\n`;
         for (let i = 0; i < accounts.length; i++) {
             const a = accounts[i];
-            const name = a.username ? `@${a.username}` : a.display_name || "—";
+            // Discord: the server, then the channel the bot read or the person gave.
+            const channel = a.platform === "discord" && a.platform_details?.channel_name ? ` · #${a.platform_details.channel_name}` : "";
+            const name = `${a.username ? `@${a.username}` : a.display_name || "—"}${channel}`;
             const types = (a.content_types || []).join(", ");
             const platform = capitalize(a.platform);
             const subType = a.platform_details?.subscription_type;
+            const chatType = a.platform === "telegram" ? a.platform_details?.chat_type : null;
+            const guildName = a.platform === "discord" ? a.platform_details?.guild_name : null;
             const sub = subType === "Premium" || subType === "PremiumPlus"
                 ? ` (${subType})`
-                : "";
+                : chatType
+                    ? ` (${chatType === "channel" ? "channel" : "group"})`
+                    : guildName && guildName !== a.display_name
+                        ? ` (${guildName})`
+                        : "";
             const statusCell = a.needs_reconnect
                 ? `⚠️ needs_reconnect`
                 : "active";
@@ -93,6 +101,30 @@ export function registerAccountTools(server, getClient) {
         if (getSubType === "Premium" || getSubType === "PremiumPlus") {
             md += `| **Subscription** | ${getSubType} |\n`;
         }
+        if (a.platform === "telegram" && a.platform_details) {
+            const d = a.platform_details;
+            if (d.chat_type)
+                md += `| **Chat type** | ${d.chat_type} |\n`;
+            if (typeof d.subscribers === "number")
+                md += `| **Subscribers** | ${d.subscribers.toLocaleString("en-US")} |\n`;
+            if (d.url)
+                md += `| **Link** | ${d.url} |\n`;
+        }
+        if (a.platform === "discord" && a.platform_details) {
+            const d = a.platform_details;
+            if (d.guild_name)
+                md += `| **Server** | ${d.guild_name} |\n`;
+            if (d.channel_name)
+                md += `| **Channel** | #${d.channel_name}${d.channel_type ? ` (${d.channel_type})` : ""} |\n`;
+            if (d.webhook_name)
+                md += `| **Posts as** | ${d.webhook_name} (the webhook's name) |\n`;
+            if (d.channel_id)
+                md += `| **Channel ID** | ${d.channel_id} |\n`;
+            if (d.connect_method)
+                md += `| **Connected with** | ${d.connect_method === "oauth" ? "Continue with Discord" : "a webhook URL"} |\n`;
+            if (d.url)
+                md += `| **Link** | ${d.url} |\n`;
+        }
         if (a.boards?.length) {
             md += `\n### Pinterest Boards\n\n`;
             md += `| Board Name | Board ID |\n`;

package/build/tools/analytics.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { formatNumber, capitalize, metricRows, metricBreakdownRows, sortMetricLabels } from "../client.js";
 import { getEngagement, getImpressions, getEngagementRate, MIN_IMPRESSIONS_FOR_ENGAGEMENT_RATE, } from "../metrics.js";
 export function registerAnalyticsTools(server, getClient) {
-    server.tool("get_post_analytics", "Get analytics/statistics for a specific published post. Renders every metric the platform reported per platform: impressions, reach, views, saves, likes, comments, shares, clicks, link_clicks, engagements, and more. A missing key means the platform does not report it: reach is absent (not 0) on X, Pinterest, YouTube, Threads, Bluesky, Mastodon and Facebook (Meta retired Facebook post reach in June 2026 and its replacement metric returns no data; a Facebook row collected before 2026-09-27 may still carry reach: 0, treat it as absent); link_clicks (clicks on links in the post) exists for X posts under 30 days, LinkedIn profile, Facebook feed posts, Pinterest and Instagram stories, while clicks is the platform's broadest click count. TikTok videos also carry average_time_watched, full_video_watched_rate, total_time_watched, favorites and reach when the workspace enabled TikTok comments (Business API authorization).", {
+    server.tool("get_post_analytics", "Get analytics/statistics for a specific published post. Renders every metric the platform reported per platform: impressions, reach, views, saves, likes, comments, shares, clicks, link_clicks, engagements, and more. A missing key means the platform does not report it: reach is absent (not 0) on X, Pinterest, YouTube, Threads, Bluesky, Mastodon, Telegram, Discord and Facebook (Meta retired Facebook post reach in June 2026 and its replacement metric returns no data; a Facebook row collected before 2026-09-27 may still carry reach: 0, treat it as absent); link_clicks (clicks on links in the post) exists for X posts under 30 days, LinkedIn profile, Facebook feed posts, Pinterest and Instagram stories, while clicks is the platform's broadest click count. TikTok videos also carry average_time_watched, full_video_watched_rate, total_time_watched, favorites and reach when the workspace enabled TikTok comments (Business API authorization). Telegram gives bots no view counts: a Telegram post carries likes (all reactions), reactions (per emoji) and, for a poll, the votes. Discord reports the same for a webhook message: likes (all reactions), reactions (per emoji) and the poll votes, no views.", {
         post_id: z.string().describe("The numeric OmniSocials post id (the `id` field from list_posts). NOT a platform post id such as a YouTube video id or tweet id."),
     }, { title: "Get Post Analytics", readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async ({ post_id }) => {
         const result = await getClient().getPostAnalytics(post_id);
@@ -310,7 +310,7 @@ export function registerAnalyticsTools(server, getClient) {
         };
     });
     server.tool("get_best_times", "Get recommended posting times (day + hour) for one platform, computed from the workspace's own posting history: publish time × engagement of every post published there, recency-weighted and outlier-damped, bucketed in the user's timezone, and blended with when the account's followers are online when the platform provides that (Instagram, TikTok Business; `basis: own_data_and_audience`, response carries `audience_online`). Returns the top 3 recommended slots plus a per-day breakdown. When the workspace has fewer than 15 analyzed posts on the platform, the audience-online profile alone is used (`basis: audience`) or industry-average defaults are returned (`basis: defaults`) with how many more posts unlock personalized recommendations — tell the user that so the numbers aren't mistaken for their own audience data. Use this before scheduling when the user asks 'when should I post?' or hasn't specified a time. Requires the analytics:read scope.", {
-        platform: z.string().describe("Platform identifier, e.g. instagram, tiktok, linkedin, linkedin_page, x, facebook, youtube, pinterest, threads, bluesky, mastodon, google_business"),
+        platform: z.string().describe("Platform identifier, e.g. instagram, tiktok, linkedin, linkedin_page, x, facebook, youtube, pinterest, threads, bluesky, mastodon, google_business, telegram, discord"),
         timezone: z.string().optional().describe("IANA timezone for the buckets (e.g. Europe/Amsterdam). Defaults to the account's timezone."),
     }, { title: "Get Best Times to Post", readOnlyHint: true, destructiveHint: false, openWorldHint: false }, async (params) => {
         const result = await getClient().getBestTimes(params);

package/build/tools/automations.d.ts

@@ -0,0 +1,25 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { OmniSocialsClient } from "../client.js";
+import type { Automation, AutomationInput } from "../types.js";
+export declare const automationChannelLabel: (platform: string | null | undefined) => "Facebook Page" | "Instagram";
+type Fields = {
+    platform?: "instagram" | "facebook";
+    name?: string;
+    keywords?: string[];
+    match?: "word" | "contains" | "any";
+    dm_text?: string;
+    public_replies?: string[];
+    triggers?: Array<"comment" | "dm" | "story_reply">;
+    scope?: "post" | "next_post" | "any";
+    post_id?: string;
+    instagram_media_id?: string;
+    facebook_post_id?: string;
+    max_sends?: number | null;
+    stop_at?: string | null;
+};
+export declare function buildAutomationBody(f: Fields, { create }: {
+    create: boolean;
+}): AutomationInput;
+export declare function describeAutomation(a: Automation): string;
+export declare function registerAutomationTools(server: McpServer, getClient: () => OmniSocialsClient): void;
+export {};