@omnisocials/mcp-server 1.29.0 → 1.32.0

package/README.md

@@ -109,13 +109,13 @@ OmniSocials accepts the following channel IDs in `create_post`, `create_and_publ
 | `tiktok` | TikTok | Posts and reels |
 | `pinterest` | Pinterest | Pins (requires `board_id`) |
 | `x` | X (Twitter) | Posts, chained threads via `x.thread_parts` |
-| `threads` | Threads | Posts, chained threads via `threads.thread_parts` |
+| `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` |
 
 ## Available Tools
 
-### Posts (7 tools)
+### Posts (12 tools)
 
 | Tool | Description |
 |------|-------------|
@@ -126,7 +126,11 @@ OmniSocials accepts the following channel IDs in `create_post`, `create_and_publ
 | `update_post` | Update a draft or scheduled post |
 | `delete_post` | Delete a post |
 | `publish_post` | Publish a draft or scheduled post now |
-| `search_locations` | Find an Instagram location to tag (returns place IDs for `location_id`) |
+| `retry_post` | Retry the failed platforms of a failed or partially failed post |
+| `approve_post` | Approve the current step of a post's approval workflow (the connected user must be a listed approver for that step) |
+| `reject_post` | Reject a post's approval workflow, stopping it immediately |
+| `search_locations` | Find an Instagram or Threads location to tag (Instagram place IDs for `location_id`, Threads location ids for `threads.location_id`; Threads also searches by latitude/longitude) |
+| `search_instagram_audio` | Search Instagram's licensed music catalog for a track to attach to a Reel |
 
 ### Media & folders (6 tools)
 
@@ -184,14 +188,15 @@ Apply a set when creating a post: `create_post` / `create_and_publish_post` acce
 | `delete_webhook` | Delete a webhook |
 | `rotate_webhook_secret` | Rotate a webhook's signing secret |
 
-### Social Inbox (4 tools)
+### Social Inbox (5 tools)
 
 | Tool | Description |
 |------|-------------|
-| `list_inbox_conversations` | List conversations — Instagram/Facebook DMs, comments, mentions, LinkedIn company-page comments/mentions, TikTok video comments, YouTube video comments, and X DMs (opt-in); filter by platform, type, or unread |
+| `list_inbox_conversations` | List conversations — Instagram/Facebook DMs, comments, mentions, LinkedIn company-page comments/mentions, TikTok video comments, YouTube video comments, X DMs (opt-in), and Threads replies on your posts plus mentions (rolling out); filter by platform, type, or unread |
 | `get_inbox_conversation` | Get a conversation's full message history |
 | `mark_inbox_read` | Mark all incoming messages in a conversation as read |
 | `reply_to_inbox` | Reply to a DM, comment, or mention (existing conversations only) |
+| `hide_inbox_reply` | Hide or unhide a reply on one of your Threads posts (Threads only for now) |
 
 Requires an API key with the opt-in `inbox:read` / `inbox:write` scopes — enable "Social Inbox access" when you create the key.
 
@@ -218,6 +223,18 @@ Full API docs: [docs.omnisocials.com](https://docs.omnisocials.com)
 
 ## Changelog
 
+### 1.32.0 (2026-09-02)
+
+- **Added: TikTok Photo Mode title.** The `tiktok` option object on `create_post`, `create_and_publish_post`, and `update_post` accepts `title` (max 90 characters): the title TikTok shows above the caption on photo carousels. TikTok's photo endpoint takes the title and the caption as two separate fields, and until now only the caption (`content`) could be set here, so photo posts created through the MCP always published with an empty title. Video posts have a single caption field and ignore `title`. `get_post` returns it as `tiktok.title`. Same on the companion server (`mcp.omnisocials.com`).
+
+### 1.31.0 (2026-08-30)
+
+- **Added: write access to approvals.** New tools `approve_post` and `reject_post`. Both act on a post's approval workflow (`approval_status: "pending"`, post status `in_approval`) and only succeed if the connected user is a listed approver for the workflow's CURRENT step — steps approve in order. Approving the final step finalizes the post (`scheduled` or `posting`); rejecting stops the whole workflow immediately (`rejected`), with an optional `comment` shown to the requester. Previously `approval_status` was read-only via `get_post` / `list_posts`. Same on the companion server (`mcp.omnisocials.com`).
+
+### 1.30.0 (2026-08-30)
+
+- **Added: media on inbox messages.** Instagram and Facebook DM messages (images, videos, voice messages, and story mentions) now carry an `attachment` object (`url`, `type`) in `get_inbox_conversation`. Incoming attachment URLs are re-hosted on our own CDN so they stay valid indefinitely. `reply_to_inbox` gains optional `attachment_url` / `attachment_type` to send media on a Facebook or Instagram DM reply; `text` is optional when an attachment is set. Same on the companion server (`mcp.omnisocials.com`).
+
 ### 1.29.0 (2026-08-29)
 
 - **Added: YouTube comments in the Social Inbox.** `list_inbox_conversations` accepts `platform: "youtube"` and returns YouTube video comment threads (comments only; YouTube has no DMs). `reply_to_inbox` can reply to YouTube comments. YouTube has no comment webhooks, so each channel is checked for new comments once per day; a new comment can take up to a day to appear. Same on the companion server (`mcp.omnisocials.com`).

package/build/client.d.ts

@@ -1,4 +1,4 @@
-import type { Account, AnalyticsOverview, AccountAnalyticsEntry, ApiPost, ApiResponse, AudioSearchResult, BestTimesResult, HashtagSet, LocationSearchResult, MediaCheckResult, MediaCompatibility, MediaFolder, MediaItem, PdfUploadResult, PostAnalytics, PublishPostResult, RecentPlatformPost, RetryPostResult, InboxConversation, InboxMessage, Webhook } from "./types.js";
+import type { Account, AnalyticsOverview, AccountAnalyticsEntry, ApiPost, ApiResponse, AudioSearchResult, BestTimesResult, HashtagSet, LocationSearchResult, MediaCheckResult, MediaCompatibility, MediaFolder, MediaItem, PdfUploadResult, PostAnalytics, PublishPostResult, RecentPlatformPost, RetryPostResult, ApprovePostResult, RejectPostResult, InboxConversation, InboxMessage, Webhook } from "./types.js";
 export declare function fetchImageAsBase64(url: string): Promise<{
     data: string;
     mimeType: string;
@@ -34,7 +34,7 @@ export type MediaIdEntry = string | {
     alt?: string;
 };
 export interface XThreadPartInput {
-    /** Tweet text — ≤ 280 chars (the API enforces 280 even for X Premium). */
+    /** Tweet text — ≤ 280 chars standard, 25,000 for X Premium/Premium+ accounts. */
     text: string;
     /** Optional per-part media as Library IDs from upload_media (max 4 combined
      * with media_urls). Entries may be `{ id, alt }` to attach alt text (X
@@ -117,6 +117,11 @@ export interface ThreadsPostOptions {
     /** 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[];
+    /** Threads location id from search_locations with platform "threads"
+     * (NOT a Facebook Place ID). Tagged on the post; on a multi-post thread
+     * the tag goes on the first post. Needs the threads_location_tagging
+     * permission on the Threads connection. */
+    location_id?: string | null;
 }
 /**
  * Update-side variant: `thread_parts: null` clears the thread (revert to a
@@ -124,6 +129,9 @@ export interface ThreadsPostOptions {
  */
 export interface ThreadsPostOptionsUpdate {
     thread_parts?: ThreadsThreadPartInput[] | null;
+    /** New Threads location id, or null to remove the tag. Omit to leave the
+     * existing tag untouched. */
+    location_id?: string | null;
 }
 /** Non-sponsored LinkedIn poll: question + 2-4 options + duration. */
 export interface LinkedInPollFields {
@@ -236,7 +244,12 @@ export declare class OmniSocialsClient {
     deletePost(id: string): Promise<ApiResponse<unknown>>;
     publishPost(id: string): Promise<ApiResponse<PublishPostResult>>;
     retryPost(id: string): Promise<ApiResponse<RetryPostResult>>;
-    searchLocations(query: string): Promise<LocationSearchResult>;
+    approvePost(id: string): Promise<ApiResponse<ApprovePostResult>>;
+    rejectPost(id: string, comment?: string): Promise<ApiResponse<RejectPostResult>>;
+    searchLocations(query?: string, platform?: "instagram" | "threads", coords?: {
+        latitude?: number;
+        longitude?: number;
+    }): Promise<LocationSearchResult>;
     validateLocation(id: string): Promise<ApiResponse<unknown>>;
     searchInstagramAudio(query?: string, type?: "music" | "original_sound"): Promise<AudioSearchResult>;
     listMedia(params?: {
@@ -358,4 +371,5 @@ export declare class OmniSocialsClient {
         attachment_url?: string;
         attachment_type?: string;
     }): Promise<ApiResponse<InboxMessage>>;
+    hideInboxMessage(messageId: string, hide?: boolean): Promise<ApiResponse<InboxMessage>>;
 }

package/build/client.js

@@ -272,13 +272,34 @@ export class OmniSocialsClient {
     async retryPost(id) {
         return this.request("POST", `/posts/${id}/retry`);
     }
-    // Locations (Instagram place tagging). NOT the standard envelope — see
-    // LocationSearchResult (degraded-path `error` is a plain string).
-    async searchLocations(query) {
-        return this.request("GET", "/locations/search", undefined, {
-            q: query,
+    // Approves the CURRENT step of the post's approval workflow. The API key's
+    // owner must be a listed approver for that step (steps approve in order) —
+    // otherwise the request returns a `forbidden` error.
+    async approvePost(id) {
+        return this.request("POST", `/posts/${id}/approve`);
+    }
+    // Rejects the post's approval workflow, stopping it immediately (not just
+    // the current step). Same approver requirement as approvePost.
+    async rejectPost(id, comment) {
+        return this.request("POST", `/posts/${id}/reject`, {
+            ...(comment ? { comment } : {}),
         });
     }
+    // Locations (Instagram or Threads place tagging). NOT the standard
+    // envelope; see LocationSearchResult: Instagram's degraded-path `error` is
+    // a plain string next to `data`; Threads answers with `locations` and a
+    // { code, message } `error` object when the search could not run.
+    // Threads accepts either a text query or a latitude/longitude pair.
+    async searchLocations(query, platform = "instagram", coords) {
+        const params = { platform };
+        if (query)
+            params.q = query;
+        if (coords?.latitude !== undefined)
+            params.latitude = String(coords.latitude);
+        if (coords?.longitude !== undefined)
+            params.longitude = String(coords.longitude);
+        return this.request("GET", "/locations/search", undefined, params);
+    }
     async validateLocation(id) {
         return this.request("GET", "/locations/validate", undefined, { id });
     }
@@ -413,4 +434,9 @@ export class OmniSocialsClient {
     async replyToInboxConversation(conversationId, data) {
         return this.request("POST", `/inbox/conversations/${encodeURIComponent(conversationId)}/reply`, data);
     }
+    // Hide/unhide a reply on one of the workspace's Threads posts (Threads
+    // only for now). `hide: false` unhides. Needs the inbox:write scope.
+    async hideInboxMessage(messageId, hide = true) {
+        return this.request("POST", `/inbox/messages/${encodeURIComponent(messageId)}/hide`, { hide });
+    }
 }

package/build/index.js

@@ -29,7 +29,7 @@ const sessionState = { activeIndex: 0 };
 const getActiveClient = () => workspaceClients[sessionState.activeIndex].client;
 const server = new McpServer({
     name: "OmniSocials",
-    version: "1.29.0",
+    version: "1.32.0",
 });
 // Register all tools - pass getter function so tools always use the active workspace's client
 registerPostTools(server, getActiveClient);

package/build/tools/inbox.js

@@ -7,11 +7,12 @@ const PLATFORM_EMOJI = {
     tiktok: "🎵",
     youtube: "▶️",
     x: "🐦",
+    threads: "🧵",
 };
 export function registerInboxTools(server, getClient) {
-    server.tool("list_inbox_conversations", "List social inbox conversations (Instagram/Facebook DMs, comments, mentions, LinkedIn company-page comments/mentions, TikTok video comments, YouTube video comments, and X DMs where the workspace has opted into X DMs), newest activity first. Cursor-paginated: pass the returned cursor to get the next page.", {
+    server.tool("list_inbox_conversations", "List social inbox conversations (Instagram/Facebook DMs, comments, mentions, LinkedIn company-page comments/mentions, TikTok video comments, YouTube video comments, X DMs where the workspace has opted into X DMs, and Threads replies on the workspace's posts plus mentions), newest activity first. Threads conversations are comment (replies on the workspace's posts) and mention only, need a Threads connection with the reply-reading permission, and are currently rolling out (disabled on production until Meta approves the permission). Cursor-paginated: pass the returned cursor to get the next page.", {
         platform: z
-            .enum(["instagram", "facebook", "linkedin", "tiktok", "youtube", "x"])
+            .enum(["instagram", "facebook", "linkedin", "tiktok", "x", "youtube", "threads"])
             .optional()
             .describe("Filter to one platform"),
         type: z
@@ -109,7 +110,17 @@ export function registerInboxTools(server, getClient) {
             const who = m.direction === "outgoing"
                 ? "→ You"
                 : `← ${m.sender?.name || m.sender?.username || "Them"}`;
-            md += `**${who}** _(${formatDateTime(m.timestamp)})_\n${m.text || ""}\n\n`;
+            // The message id is what hide_inbox_reply takes, so always render it.
+            const flags = [`id ${m.id}`];
+            if (m.hidden === true)
+                flags.push("hidden on Threads");
+            md += `**${who}** _(${formatDateTime(m.timestamp)})_ \`${flags.join(" · ")}\`\n${m.text || ""}\n`;
+            if (m.attachment?.url) {
+                md += `📎 [${m.attachment.type}] ${m.attachment.url}\n`;
+            }
+            if (m.permalink)
+                md += `${m.permalink}\n`;
+            md += `\n`;
         }
         if (result.pagination?.next_cursor) {
             md += `_More messages — call again with cursor "${result.pagination.next_cursor}"._`;
@@ -139,14 +150,25 @@ export function registerInboxTools(server, getClient) {
             ],
         };
     });
-    server.tool("reply_to_inbox", "Reply to an existing inbox conversation (DM, comment, or mention) on Instagram, Facebook, LinkedIn, TikTok, YouTube, or X. You can only reply to conversations that already exist. Meta direct-message replies must be within the platform's 24-hour messaging window. TikTok replies are comments only, text-only, and capped at 150 characters; they can take a few minutes to appear on TikTok while they pass spam review. YouTube replies are comments only. X replies are DM-only and use 2 prepaid credits per send (X's API fee passed through at cost) — a 402 insufficient_credits error means the organisation needs to top up at https://app.omnisocials.com/credits; relay that link to the user rather than retrying. Each workspace can send up to 1,000 replies per day.", {
+    server.tool("reply_to_inbox", "Reply to an existing inbox conversation (DM, comment, or mention) on Instagram, Facebook, LinkedIn, TikTok, X, YouTube, or Threads (Threads replies are on the workspace's posts and mentions; a 401 reauth_required means the Threads connection must be reconnected to grant the reply permission; the reply publishes as a native Threads reply). You can only reply to conversations that already exist. Meta direct-message replies must be within the platform's 24-hour messaging window. TikTok replies are comments only, text-only, and capped at 150 characters; they can take a few minutes to appear on TikTok while they pass spam review. YouTube replies are comments only. X replies are DM-only and use 2 prepaid credits per send (X's API fee passed through at cost) — a 402 insufficient_credits error means the organisation needs to top up at https://app.omnisocials.com/credits; relay that link to the user rather than retrying. Each workspace can send up to 1,000 replies per day. attachment_url/attachment_type let you send media on a Facebook or Instagram DM (text is optional when an attachment is set — an attachment-only DM is allowed); other platforms are text-only.", {
         conversation_id: z.string().describe("The conversation ID to reply to"),
         text: z
             .string()
-            .describe("The reply text (max 2000 characters; TikTok comments max 150)"),
-    }, { title: "Reply to Inbox Message", readOnlyHint: false, destructiveHint: false, openWorldHint: true }, async ({ conversation_id, text }) => {
+            .optional()
+            .describe("The reply text (max 2000 characters; TikTok comments max 150). Optional when attachment_url is set."),
+        attachment_url: z
+            .string()
+            .optional()
+            .describe("Media URL to send (Facebook and Instagram DMs only)"),
+        attachment_type: z
+            .enum(["image", "video", "audio", "file"])
+            .optional()
+            .describe("Required if attachment_url is set"),
+    }, { title: "Reply to Inbox Message", readOnlyHint: false, destructiveHint: false, openWorldHint: true }, async ({ conversation_id, text, attachment_url, attachment_type }) => {
         const result = await getClient().replyToInboxConversation(conversation_id, {
-            text,
+            text: text ?? "",
+            attachment_url,
+            attachment_type,
         });
         if (result.error) {
             return {
@@ -168,4 +190,36 @@ export function registerInboxTools(server, getClient) {
             ],
         };
     });
+    server.tool("hide_inbox_reply", "Hide (or unhide) a reply someone left on one of the workspace's Threads posts, as the post owner. Threads only for now, and only incoming top-level replies can be hidden (Threads does not allow hiding nested replies). The message keeps its place in the conversation; its `hidden` flag flips. Use the message id shown by get_inbox_conversation. Errors: 400 unsupported_platform (not an incoming Threads reply), 400 not_hideable (nested reply, or Threads refused), 401 reauth_required (the Threads connection lacks the reply permission; reconnect Threads under Settings → Organisation → Workspaces). Threads inbox features are currently rolling out (disabled on production until Meta approves the permission). Requires the inbox:write scope.", {
+        message_id: z
+            .string()
+            .describe("The inbox message id of the reply (from get_inbox_conversation)"),
+        hide: z
+            .boolean()
+            .optional()
+            .describe("true (default) hides the reply; false unhides it"),
+    }, async ({ message_id, hide }) => {
+        const result = await getClient().hideInboxMessage(message_id, hide ?? true);
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error (${result.error.code}): ${result.error.message}`,
+                    },
+                ],
+            };
+        }
+        const hidden = result.data?.hidden === true;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: hidden
+                        ? `Reply \`${message_id}\` is now hidden on Threads.`
+                        : `Reply \`${message_id}\` is now visible on Threads again.`,
+                },
+            ],
+        };
+    });
 }

package/build/tools/posts.js

@@ -122,6 +122,11 @@ const LINKEDIN_POLL_OPTIONS = z
 // google_business, and the thread_parts wrappers with their per-tool
 // nullability/descriptions) stay inline in each tool.
 const TIKTOK_OPTIONS = z.object({
+    title: z
+        .string()
+        .max(90)
+        .optional()
+        .describe("Photo carousels only. TikTok post title (max 90 characters), shown above the caption on Photo Mode posts. TikTok's photo endpoint takes the title and the caption as two separate fields; the caption (content) is the description. Ignored on video posts, which have one caption field. Read back as tiktok.title in get_post. The tiktok block replaces wholesale on update_post, so resend it together with the other TikTok options."),
     privacy_level: z.enum(["PUBLIC_TO_EVERYONE", "MUTUAL_FOLLOW_FRIENDS", "FOLLOWER_OF_CREATOR", "SELF_ONLY"]).optional(),
     disable_comment: z.boolean().optional(),
     disable_duet: z.boolean().optional().describe("Reels only. Disable Duet on the video."),
@@ -156,7 +161,7 @@ const USER_TAG_ENTRY = z.object({
 // z.array(...).min(2).max(25)[.nullable()].optional().describe(...) stays
 // per-tool (update_post allows null to clear the thread).
 const X_THREAD_PART = z.object({
-    text: z.string().describe("Tweet text (≤ 280 chars by X's weighted count). X counts every link as 23 characters (its t.co length) and every emoji or non-Latin symbol (🚀, …, ₹, CJK) as 2 — so text that looks under 280 can still be over. When trimming generated copy to fit, leave headroom instead of cutting to exactly 280 raw characters."),
+    text: z.string().describe("Tweet text (≤ 280 chars by X's weighted count; 25,000 for X Premium/Premium+ accounts). X counts every link as 23 characters (its t.co length) and every emoji or non-Latin symbol (🚀, …, ₹, CJK) as 2 — so text that looks under 280 can still be over. When trimming generated copy to fit, leave headroom instead of cutting to exactly 280 raw characters."),
     media_ids: z.array(mediaIdEntry).max(4).optional().describe("Per-tweet media as Library IDs from upload_media (max 4 combined with media_urls). Each entry is a plain ID string or { id, alt } to attach alt text (X applies it to photos/GIFs). Attach your uploaded graphics to any tweet in the thread."),
     media_urls: z.array(mediaUrlEntry).max(4).optional().describe("Per-tweet media as external URLs (max 4 combined with media_ids). Each entry is a plain URL string or { url, alt } to attach alt text (X applies it to photos/GIFs)."),
 });
@@ -370,6 +375,12 @@ export function registerPostTools(server, getClient) {
         // Instagram extras, echoed top-level by the API to mirror create_post.
         if (p.location_id)
             md += `| **IG location** | \`${p.location_id}\` |\n`;
+        // Threads location tag read-back (threads.location on the Post).
+        const threadsLoc = p.threads?.location;
+        if (threadsLoc?.id) {
+            const locBits = [threadsLoc.name, threadsLoc.city, threadsLoc.country].filter(Boolean).join(", ");
+            md += `| **Threads location** | ${locBits ? `${locBits} ` : ""}\`${threadsLoc.id}\` |\n`;
+        }
         if (Array.isArray(p.collaborators) && p.collaborators.length) {
             md += `| **IG collaborators** | ${p.collaborators.map((c) => `@${c}`).join(", ")} |\n`;
         }
@@ -609,8 +620,8 @@ IMPORTANT — Before calling this tool, make sure you have all required informat
    - Pinterest carousel — 2–5 images, all same aspect ratio (a video splits off into its own video pin)
    - Facebook, LinkedIn, LinkedIn Page — cannot mix images and video in one post (images only, or a single video)
 
-   **Per-platform video caps (duration + size, checked via ffprobe at submit — exceeding either returns a 400 validation_error stating the exact cap and the file's value, e.g. "X only allows videos up to 2min 20s — yours is 2min 35s. Trim the video or deselect X."):**
-   - X — **140s (2min 20s)** · **512MB** (X also can't mix a video with images in one tweet: a tweet is either 1 video OR up to 4 images)
+   **Per-platform video caps (duration + size, checked via ffprobe at submit; exceeding either returns a 400 validation_error stating the exact cap and the file's value, e.g. "X only allows videos up to 2min 20s; yours is 2min 35s. Trim the video or deselect X."):**
+   - X — **140s (2min 20s)** · **512MB** on free/Basic accounts; when the connected X account has **Premium or Premium+** the caps rise to **125min / 16GB** automatically (tier is read from the connection; reconnect X after upgrading). X also can't mix a video with images in one tweet: a tweet is either 1 video OR up to 4 images
    - Bluesky 180s · Threads 5min · Instagram 15min · TikTok 10min · YouTube Short 3min · LinkedIn 10min · Pinterest 15min · Facebook Reel 90s
    Pick a file within the cap up front; if the user's video is over, tell them the limit so they can trim it rather than retrying blindly.
 
@@ -623,7 +634,7 @@ IMPORTANT — Before calling this tool, make sure you have all required informat
      If the user named a board ("post to my Marketing board") or specified one in the request, use that one instead of the first — match on name (case-insensitive) against the boards list.
    - YouTube: Title, privacy status, tags?
    - TikTok: Privacy level?
-   - **X threads vs long-form**: A chained "thread" (the user explicitly asks for one) → pass \`x.thread_parts\` as an array of 2–25 \`{ text }\` objects (each ≤ 280 chars); the \`content\` field is then ignored for X. A single **long-form** post on a Premium / Premium+ account → just put the full text (up to 25,000 chars) in \`content\` — no threading needed (check \`platform_details.subscription_type\` via list_accounts). On free / Basic, X caps a single post at 280 chars, so either split into a thread or shorten. Never cram "1/", "2/" prefixes into \`content\` — that posts one tweet, not a thread.
+   - **X threads vs long-form**: A chained "thread" (the user explicitly asks for one) → pass \`x.thread_parts\` as an array of 2–25 \`{ text }\` objects (each ≤ 280 chars on free/Basic, 25,000 on Premium/Premium+); the \`content\` field is then ignored for X. A single **long-form** post on a Premium / Premium+ account → just put the full text (up to 25,000 chars) in \`content\` — no threading needed (check \`platform_details.subscription_type\` via list_accounts). On free / Basic, X caps a single post at 280 chars, so either split into a thread or shorten. Never cram "1/", "2/" prefixes into \`content\` — that posts one tweet, not a thread.
    - **Bluesky, Mastodon and Threads chains**: the same \`thread_parts\` shape works under \`bluesky\`, \`mastodon\` and \`threads\` (each an array of 2 to 25 \`{ text, media_ids?, media_urls? }\` objects); parts after the first publish as replies to the previous part and \`content\` is then ignored for that platform. Threads: 2 to 25 parts, 500 characters per part, up to 10 media per part (images and videos can be mixed). Bluesky: 300 characters per part, 4 media. Mastodon: 500 characters per part (instance-dependent), 4 media.
    - **X posts containing a link cost credits**: X's API bills posts whose text contains a URL at a premium, and OmniSocials passes that through as prepaid credits at X's exact rate (20 credits ≈ $0.20 per URL-containing tweet; threads are charged per part that contains a link). The create response includes a \`warnings\` entry (\`x_url_post_credits\`) with the cost and current balance — relay it to the user. Credits are only deducted after the post successfully publishes; a failed publish is never charged. If the balance can't cover it at publish time, only the X target fails (message says to top up at https://app.omnisocials.com/credits) and the post can be retried after topping up. Posts without links stay free — never remove a user's link to dodge the fee without asking them. Scheduling is also gated up front: every scheduled X link post reserves its cost, and a create/schedule that would push the reserved total past the balance is refused with a 402 \`x_credits_insufficient\` error (details carry credits_required / credits_balance / credits_reserved) — tell the user to top up or remove the link, don't silently retry.
 
@@ -694,8 +705,9 @@ Do NOT call this tool without media when creating stories, reels, Instagram post
             thread_parts: z.array(MASTODON_THREAD_PART).min(2).max(25).optional().describe("Publish as a chained Mastodon thread instead of a single status. Provide 2–25 parts; each is posted in order as a native reply to the previous status (in_reply_to_id). Attach media to any part via media_ids (from upload_media) or media_urls — max 4 per part. For a single status, omit thread_parts and use content."),
         }).optional().describe("Mastodon options"),
         threads: z.object({
+            location_id: z.string().nullable().optional().describe("Tag a location on the Threads post. Use an `id` from search_locations with platform \"threads\" (Threads location ids are NOT Facebook Place IDs, so never reuse the Instagram location_id here). On a multi-post thread the tag goes on the first post. Needs the workspace's Threads connection to have the threads_location_tagging permission; the API returns a clear 400 asking to reconnect Threads when it is missing, and a clear 400 while location tagging is still rolling out (disabled in this environment). On update_post, pass null to remove the tag."),
             thread_parts: z.array(THREADS_THREAD_PART).min(2).max(25).optional().describe("Publish as a chained Threads (Meta) thread instead of a single post. Provide 2 to 25 parts; parts after the first are posted as replies to the previous part. Each part holds up to 500 characters and up to 10 media (images and videos can be mixed) via media_ids (from upload_media) or media_urls. When set, the Threads caption is taken from part 1 and content is ignored for Threads. For a single post, omit thread_parts and use content."),
-        }).optional().describe("Threads (Meta) options"),
+        }).optional().describe("Threads (Meta) options: thread mode via `thread_parts`, location tag via `location_id`."),
         google_business: GOOGLE_BUSINESS_OPTIONS,
     }, { title: "Create Post", readOnlyHint: false, destructiveHint: false, openWorldHint: false }, async (params) => {
         const result = await getClient().createPost({ ...params, source: "mcp" });
@@ -772,9 +784,9 @@ IMPORTANT — Before calling this tool, make sure you have all required informat
    - Pinterest: ALWAYS need an image + board_id.
    - Ask the user which media to use. Use list_media to show options.
    - **Max items per platform** (same caps as create_post — exceeding returns 400): Bluesky/X/Mastodon ≤4, Instagram/Threads ≤10, TikTok ≤35 photos, Pinterest carousel 2–5 same-ratio images. Mixing images+video is rejected on Facebook/LinkedIn/X/Bluesky/Mastodon/TikTok; Instagram and Threads mixed carousels are allowed.
-   - **Video duration/size caps** (ffprobe at submit — over either returns 400 validation_error with the exact cap + the file's value): X **140s/512MB** (no video+image mix in one tweet), Bluesky 180s, Threads 5min, Instagram 15min, TikTok 10min, YouTube Short 3min, LinkedIn 10min, Facebook Reel 90s.
+   - **Video duration/size caps** (ffprobe at submit — over either returns 400 validation_error with the exact cap + the file's value): X **140s/512MB** free/Basic, **125min/16GB** when the connected X account has Premium/Premium+ (auto-detected; no video+image mix in one tweet), Bluesky 180s, Threads 5min, Instagram 15min, TikTok 10min, YouTube Short 3min, LinkedIn 10min, Facebook Reel 90s.
 4. **Pinterest board (auto-default to first board)**: If Pinterest is in \`channels\` and \`pinterest.board_id\` is NOT provided, do NOT block on asking — and do NOT skip Pinterest. Call \`get_account\` on the Pinterest account, take the FIRST board from the returned boards list, and pass its \`id\` as \`pinterest.board_id\`. In your reply, mention which board you used (e.g. "Published to your 'Marketing' board on Pinterest — let me know if you'd prefer a different one.") so the user can redirect. If the user named a specific board in the request, match it (case-insensitive) against the list and use that one instead.
-5. **X threads vs long-form**: A chained "thread" → pass \`x.thread_parts\` as a 2–25 entry array of \`{ text }\` objects (each ≤ 280 chars). A single long-form post on a Premium / Premium+ account → put the full text (up to 25,000 chars) in \`content\`; no threading needed. On free / Basic, X caps a single post at 280 chars. Do NOT split into "1/", "2/" inside \`content\` — that produces a single tweet, not a thread. The same \`thread_parts\` shape works under \`bluesky\`, \`mastodon\` and \`threads\` (Threads: 2 to 25 parts, 500 characters per part, up to 10 media per part; parts after the first publish as replies to the previous part).
+5. **X threads vs long-form**: A chained "thread" → pass \`x.thread_parts\` as a 2–25 entry array of \`{ text }\` objects (each ≤ 280 chars on free/Basic, 25,000 on Premium/Premium+). A single long-form post on a Premium / Premium+ account → put the full text (up to 25,000 chars) in \`content\`; no threading needed. On free / Basic, X caps a single post at 280 chars. Do NOT split into "1/", "2/" inside \`content\` — that produces a single tweet, not a thread. The same \`thread_parts\` shape works under \`bluesky\`, \`mastodon\` and \`threads\` (Threads: 2 to 25 parts, 500 characters per part, up to 10 media per part; parts after the first publish as replies to the previous part).
 6. **X posts containing a link cost credits**: X bills API posts whose text contains a URL at a premium; OmniSocials passes that through as prepaid credits at X's exact rate (20 credits ≈ $0.20 per URL-containing tweet, threads charged per link-containing part). Because this tool publishes IMMEDIATELY, the debit happens right away — if the company's balance can't cover it, the X target fails with a top-up message while other platforms still publish. Relay any \`x_url_post_credits\` warning and X publish failure to the user; never strip their link to avoid the fee without asking. If the balance (minus credits reserved by scheduled X link posts) can't cover this post, the request is refused up front with a 402 \`x_credits_insufficient\` error instead of failing at publish.
 
 Do NOT call without required media — it will fail.`, {
@@ -841,8 +853,9 @@ Do NOT call without required media — it will fail.`, {
             thread_parts: z.array(MASTODON_THREAD_PART).min(2).max(25).optional().describe("Publish as a chained Mastodon thread (2–25 parts). Each is posted in order as a native reply (in_reply_to_id). Attach media to any part via media_ids or media_urls — max 4 per part."),
         }).optional().describe("Mastodon options"),
         threads: z.object({
+            location_id: z.string().nullable().optional().describe("Tag a location on the Threads post. Use an `id` from search_locations with platform \"threads\" (Threads location ids are NOT Facebook Place IDs, so never reuse the Instagram location_id here). On a multi-post thread the tag goes on the first post. Needs the workspace's Threads connection to have the threads_location_tagging permission; the API returns a clear 400 asking to reconnect Threads when it is missing, and a clear 400 while location tagging is still rolling out (disabled in this environment). On update_post, pass null to remove the tag."),
             thread_parts: z.array(THREADS_THREAD_PART).min(2).max(25).optional().describe("Publish as a chained Threads (Meta) thread (2 to 25 parts). Parts after the first are posted as replies to the previous part. Each part holds up to 500 characters and up to 10 media (images and videos can be mixed) via media_ids or media_urls. The Threads caption is taken from part 1."),
-        }).optional().describe("Threads (Meta) options"),
+        }).optional().describe("Threads (Meta) options: thread mode via `thread_parts`, location tag via `location_id`."),
         google_business: GOOGLE_BUSINESS_OPTIONS,
     }, { title: "Create and Publish Post", readOnlyHint: false, destructiveHint: false, openWorldHint: true }, async (params) => {
         const result = await getClient().createAndPublishPost({ ...params, source: "mcp" });
@@ -892,7 +905,7 @@ Do NOT call without required media — it will fail.`, {
 
 **Per-platform options (\`youtube\`, \`pinterest\`, \`instagram\`, \`tiktok\`, \`google_business\`)** are accepted here, same shape as in \`create_post\`. Pass an object — never a JSON-encoded string. For YouTube Shorts, the **title** lives at \`youtube.title\`; the **video description** lives in \`content\` (or \`content.youtube\` for a per-platform override). They are not the same field — changing the caption does NOT rename the Short.
 
-**X threads**: To convert an existing draft into a chained X thread, pass \`x.thread_parts\` as a 2–25 entry array of \`{ text }\` objects (each ≤ 280 chars). Pass \`null\` to revert to single-tweet mode. Do NOT shove "1/", "2/" into \`content\` — that's a single tweet, not a thread. The same applies to \`bluesky.thread_parts\`, \`mastodon.thread_parts\` and \`threads.thread_parts\` (Threads: 2 to 25 parts, 500 characters per part, up to 10 media per part; \`null\` reverts to a single post).`, {
+**X threads**: To convert an existing draft into a chained X thread, pass \`x.thread_parts\` as a 2–25 entry array of \`{ text }\` objects (each ≤ 280 chars on free/Basic, 25,000 on Premium/Premium+). Pass \`null\` to revert to single-tweet mode. Do NOT shove "1/", "2/" into \`content\` — that's a single tweet, not a thread. The same applies to \`bluesky.thread_parts\`, \`mastodon.thread_parts\` and \`threads.thread_parts\` (Threads: 2 to 25 parts, 500 characters per part, up to 10 media per part; \`null\` reverts to a single post).`, {
         id: z.string().describe("The post ID to update"),
         content: z.union([z.string(), z.record(z.string(), z.string())]).optional().describe("Updated post caption / body text. For YouTube Shorts this becomes the video description, NOT the title — to rename the Short, use `youtube.title`. String or object with platform keys: { \"default\": \"fallback\", \"linkedin\": \"long\" }."),
         scheduled_at: z.string().optional().describe("Updated scheduled date (ISO 8601, must be in the future). A draft becomes scheduled. A post waiting for approval keeps its in_approval status; only its time moves."),
@@ -954,8 +967,9 @@ Do NOT call without required media — it will fail.`, {
             thread_parts: z.array(MASTODON_THREAD_PART).min(2).max(25).nullable().optional().describe("Replace the Mastodon thread shape on this post. Pass an array (2–25 parts) to update/create the thread (attach media to any part via media_ids or media_urls; max 4 per part), or `null` to revert to single-status mode."),
         }).optional().describe("Mastodon options"),
         threads: z.object({
+            location_id: z.string().nullable().optional().describe("Tag a location on the Threads post. Use an `id` from search_locations with platform \"threads\" (Threads location ids are NOT Facebook Place IDs, so never reuse the Instagram location_id here). On a multi-post thread the tag goes on the first post. Needs the workspace's Threads connection to have the threads_location_tagging permission; the API returns a clear 400 asking to reconnect Threads when it is missing, and a clear 400 while location tagging is still rolling out (disabled in this environment). On update_post, pass null to remove the tag."),
             thread_parts: z.array(THREADS_THREAD_PART).min(2).max(25).nullable().optional().describe("Replace the Threads (Meta) thread shape on this post. Pass an array (2 to 25 parts, 500 characters per part) to update/create the thread (attach up to 10 media to any part via media_ids or media_urls; images and videos can be mixed), or `null` to revert to single-post mode."),
-        }).optional().describe("Threads (Meta) options"),
+        }).optional().describe("Threads (Meta) options: thread mode via `thread_parts`, location tag via `location_id`."),
         google_business: GOOGLE_BUSINESS_OPTIONS,
     }, { title: "Update Post", readOnlyHint: false, destructiveHint: false, openWorldHint: false }, async ({ id, ...data }) => {
         const result = await getClient().updatePost(id, data);
@@ -1049,32 +1063,152 @@ The retry runs asynchronously (usually within a few minutes). Poll \`get_post\`
             content: [{ type: "text", text: md }],
         };
     });
-    server.tool("search_locations", `Search for an Instagram location to tag on a post. Use this whenever the user wants to post WITH a place/location (e.g. "post this at my dealership", "tag the café"). It returns matching real venues with their addresses and a location ID.
+    server.tool("approve_post", `Approve the current step of a post's approval workflow. Only works on a post with \`approval_status: "pending"\` (post status \`in_approval\`) — check \`get_post\` first.
+
+IMPORTANT: this only succeeds if the connected user is a listed approver for the workflow's CURRENT step — steps approve in order, so being an approver on a later step is not enough yet. A \`forbidden\` error means the user isn't (or isn't yet) an approver for this step; tell them who needs to approve instead, don't retry.
+
+If this is the workflow's last step, the post is finalized immediately: it moves to \`scheduled\` (future time) or \`posting\` (due now/in the past). If steps remain, the post stays \`in_approval\` and the next step's approvers are notified — call this again once they've approved, or use \`reject_post\` to stop the workflow instead.`, {
+        id: z.string().describe("The post ID to approve (must have approval_status 'pending')"),
+    }, { title: "Approve Post", readOnlyHint: false, destructiveHint: false, openWorldHint: true }, async ({ id }) => {
+        const result = await getClient().approvePost(id);
+        if (result.error) {
+            return {
+                content: [{ type: "text", text: `Error (${result.error.code}): ${result.error.message}` }],
+            };
+        }
+        const p = result.data;
+        if (!p) {
+            return {
+                content: [{ type: "text", text: "Approval recorded. Check its status with get_post." }],
+            };
+        }
+        let md = `## Approval Recorded\n\n`;
+        md += `| Field | Value |\n`;
+        md += `|-------|-------|\n`;
+        md += `| **ID** | \`${p.id}\` |\n`;
+        md += `| **Status** | ${capitalize(p.status || "in_approval")} |\n`;
+        md += `| **Approval status** | ${capitalize(p.approval_status || "pending")} |\n`;
+        if (p.message)
+            md += `\n${p.message}\n`;
+        return {
+            content: [{ type: "text", text: md }],
+        };
+    });
+    server.tool("reject_post", `Reject a post's approval workflow. Only works on a post with \`approval_status: "pending"\` (post status \`in_approval\`) — check \`get_post\` first.
+
+IMPORTANT: this only succeeds if the connected user is a listed approver for the workflow's CURRENT step (same requirement as \`approve_post\`). Unlike approval, a rejection stops the WHOLE workflow immediately, not just the current step — the post's status becomes \`rejected\` and it will not publish. Pass \`comment\` to explain why; it's shown to the requester and other approvers in the post's review thread.`, {
+        id: z.string().describe("The post ID to reject (must have approval_status 'pending')"),
+        comment: z
+            .string()
+            .max(2000)
+            .optional()
+            .describe("Optional reason for the rejection, shown to the requester and other approvers."),
+    }, { title: "Reject Post", readOnlyHint: false, destructiveHint: false, openWorldHint: true }, async ({ id, comment }) => {
+        const result = await getClient().rejectPost(id, comment);
+        if (result.error) {
+            return {
+                content: [{ type: "text", text: `Error (${result.error.code}): ${result.error.message}` }],
+            };
+        }
+        const p = result.data;
+        let md = `## Post Rejected\n\n`;
+        md += `| Field | Value |\n`;
+        md += `|-------|-------|\n`;
+        md += `| **ID** | \`${p?.id || id}\` |\n`;
+        md += `| **Status** | Rejected |\n`;
+        md += `\n_The approval workflow has stopped. This post will not be published unless it's edited and resubmitted for approval._`;
+        return {
+            content: [{ type: "text", text: md }],
+        };
+    });
+    server.tool("search_locations", `Search for a location to tag on a post. Use this whenever the user wants to post WITH a place/location (e.g. "post this at my dealership", "tag the café"). It returns matching real venues with their addresses and a location ID.
+
+Pick the platform with \`platform\`: "instagram" (default) or "threads". The two use DIFFERENT ids (a Facebook Place ID is not a Threads location id), so search with the platform you will tag. If the user wants both, search twice.
 
-Flow: call this with the place name → present the options to the user → once they pick, pass that result's \`id\` as \`location_id\` on create_post / create_and_publish_post / update_post. Only Instagram supports location tagging.
+Flow (Instagram): call with the place name → present the options to the user → once they pick, pass that result's \`id\` as \`location_id\` on create_post / create_and_publish_post / update_post.
+Flow (Threads): same, but pass the \`id\` as \`threads.location_id\`. Threads can also search by coordinates: pass latitude + longitude instead of a query. On a multi-post thread the tag goes on the first post.
 
 Notes:
 - Use a SPECIFIC venue name. Searching a broad brand ("Starbucks") returns individual store locations, not the brand page.
-- If the user already gives you a numeric Facebook Place ID, you can pass it straight to create_post as \`location_id\`; it's validated at publish time and an invalid one returns a clear error.
-- If results come back empty with a permission note, the workspace's Facebook app can't search arbitrary places — tell the user to use their own business Page's ID.`, {
+- Instagram: if the user already gives you a numeric Facebook Place ID, you can pass it straight to create_post as \`location_id\`; it's validated at publish time and an invalid one returns a clear error. If results come back empty with a permission note, the workspace's Facebook app can't search arbitrary places; tell the user to use their own business Page's ID.
+- Threads: needs the workspace's Threads connection to have the location permission; if the result says to reconnect Threads, tell the user to reconnect it under Settings → Organisation → Workspaces. Threads location tagging is currently rolling out, so the search can also answer that it is not available yet.`, {
         query: z
             .string()
-            .describe("Place name to search (min 2 chars) — a dealership, café, venue, etc."),
-    }, { title: "Search Locations", readOnlyHint: true, destructiveHint: false, openWorldHint: true }, async ({ query }) => {
-        const result = await getClient().searchLocations(query);
+            .optional()
+            .describe("Place name to search (min 2 chars): a dealership, café, venue, etc. Required for instagram; for threads pass either query or latitude + longitude."),
+        platform: z
+            .enum(["instagram", "threads"])
+            .optional()
+            .describe("Which platform the location will be tagged on. Defaults to instagram. Use threads to get a Threads location id for threads.location_id."),
+        latitude: z
+            .number()
+            .min(-90)
+            .max(90)
+            .optional()
+            .describe("Threads only. Search places around this point; pass together with longitude instead of query."),
+        longitude: z
+            .number()
+            .min(-180)
+            .max(180)
+            .optional()
+            .describe("Threads only. Pass together with latitude."),
+    }, { title: "Search Locations", readOnlyHint: true, destructiveHint: false, openWorldHint: true }, async ({ query, platform, latitude, longitude }) => {
+        const target = platform === "threads" ? "threads" : "instagram";
+        if (!query && target !== "threads") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: 'Pass a place name to search (query). Coordinates are only supported with platform "threads".',
+                    },
+                ],
+            };
+        }
+        if (target === "threads" && !query && (latitude === undefined || longitude === undefined)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Pass a place name (query), or both latitude and longitude.",
+                    },
+                ],
+            };
+        }
+        const result = await getClient().searchLocations(query, target, latitude !== undefined || longitude !== undefined
+            ? { latitude, longitude }
+            : undefined);
+        const label = query ? `"${query}"` : `${latitude}, ${longitude}`;
+        if (target === "threads") {
+            const locations = result?.locations || [];
+            if (!locations.length) {
+                // Threads answers with a { code, message } error object when the
+                // search could not run (not_available, threads_not_connected,
+                // threads_reauth_required, platform_error).
+                const err = result?.error;
+                const why = (typeof err === "string" ? err : err?.message) ||
+                    `No Threads locations found for ${label}. Try a more specific place name.`;
+                return { content: [{ type: "text", text: why }] };
+            }
+            let md = `## Threads locations matching ${label}\n\nAsk the user which one, then use its ID as \`threads.location_id\`:\n\n`;
+            md += `| # | Name | Address | City | Country | threads.location_id |\n|---|------|---------|------|---------|---------------------|\n`;
+            locations.forEach((p, i) => {
+                md += `| ${i + 1} | ${p.name || "-"} | ${p.address || "-"} | ${p.city || "-"} | ${p.country || "-"} | \`${p.id}\` |\n`;
+            });
+            return { content: [{ type: "text", text: md }] };
+        }
         const places = result?.data || [];
         if (!places.length) {
             // The degraded path returns `error` as a plain string; the object form
             // only appears on transport failures — render its message.
             const err = result?.error;
             const why = (typeof err === "string" ? err : err?.message) ||
-                `No taggable locations found for "${query}". Try a more specific venue name, or pass a known Facebook Place ID directly as location_id.`;
+                `No taggable locations found for ${label}. Try a more specific venue name, or pass a known Facebook Place ID directly as location_id.`;
             return { content: [{ type: "text", text: why }] };
         }
-        let md = `## Locations matching "${query}"\n\nAsk the user which one, then use its ID as \`location_id\`:\n\n`;
+        let md = `## Instagram locations matching ${label}\n\nAsk the user which one, then use its ID as \`location_id\`:\n\n`;
         md += `| # | Name | Address | location_id |\n|---|------|---------|-------------|\n`;
         places.forEach((p, i) => {
-            md += `| ${i + 1} | ${p.name} | ${p.address || "—"} | \`${p.id}\` |\n`;
+            md += `| ${i + 1} | ${p.name} | ${p.address || "-"} | \`${p.id}\` |\n`;
         });
         return { content: [{ type: "text", text: md }] };
     });

package/build/types.d.ts

@@ -28,7 +28,7 @@ export interface InboxParticipant {
 }
 export interface InboxConversation {
     conversation_id: string;
-    platform: "instagram" | "facebook" | "linkedin" | "tiktok" | "youtube" | "x";
+    platform: "instagram" | "facebook" | "linkedin" | "tiktok" | "x" | "youtube" | "threads";
     type: "dm" | "comment" | "mention";
     participant: InboxParticipant;
     unread_count: number;
@@ -57,6 +57,18 @@ export interface InboxMessage {
     is_replied: boolean;
     reaction: string | null;
     parent_comment_id: string | null;
+    /** Threads replies only: true when the reply is hidden on Threads (flip it
+     * with hide_inbox_reply). null for every other platform. */
+    hidden?: boolean | null;
+    /** Link to the reply or mentioning post on the platform, when known. */
+    permalink?: string | null;
+    /** Media sent with this message, when present. Incoming Instagram/Facebook
+     * DM images, videos, voice messages, and story mentions are re-hosted on
+     * our CDN so the URL stays valid indefinitely. */
+    attachment?: {
+        url: string;
+        type: "image" | "video" | "audio" | "file";
+    } | null;
     sender: InboxParticipant;
     post: {
         id: string | null;
@@ -207,6 +219,21 @@ export interface RetryPostResult {
     platforms?: string[];
     message?: string;
 }
+/** `data` of POST /posts/:id/approve (backend/routes/api/v1/posts.js). */
+export interface ApprovePostResult {
+    id: string;
+    /** The post's status after this call: `in_approval` (more steps remain), `scheduled`, or `posting`. */
+    status: string;
+    approval_status: "pending" | "approved";
+    message?: string;
+}
+/** `data` of POST /posts/:id/reject (backend/routes/api/v1/posts.js). */
+export interface RejectPostResult {
+    id: string;
+    status: "rejected";
+    approval_status: "rejected";
+    message?: string;
+}
 /** One place from GET /locations/search
  * (@openapi block in backend/routes/api/v1/locations.js). */
 export interface LocationPlace {
@@ -217,12 +244,30 @@ export interface LocationPlace {
     city?: string | null;
     country?: string | null;
 }
-/** GET /locations/search envelope — NOT the standard data/error envelope:
- * on the documented degraded path (no Facebook account / missing permission)
- * `error` is a human-readable STRING next to an empty `data`; the standard
- * { code, message } object appears only on transport/HTTP failures. */
+/** One place from GET /locations/search?platform=threads. Threads location
+ * ids are NOT Facebook Place IDs; use them as `threads.location_id`. */
+export interface ThreadsLocationPlace {
+    /** Threads location id: use as `threads.location_id`. */
+    id: string;
+    name?: string | null;
+    address?: string | null;
+    city?: string | null;
+    country?: string | null;
+    latitude?: number | null;
+    longitude?: number | null;
+}
+/** GET /locations/search envelope: NOT the standard data/error envelope.
+ * platform=instagram (default): `data` holds LocationPlace rows; on the
+ * documented degraded path (no Facebook account / missing permission)
+ * `error` is a human-readable STRING next to an empty `data`.
+ * platform=threads: `locations` holds ThreadsLocationPlace rows, and when
+ * the search could not run `error` is a { code, message } OBJECT with code
+ * one of not_available | threads_not_connected | threads_reauth_required |
+ * platform_error. The standard { code, message } object also appears on
+ * transport/HTTP failures. */
 export interface LocationSearchResult {
     data?: LocationPlace[];
+    locations?: ThreadsLocationPlace[];
     error?: string | {
         code: string;
         message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnisocials/mcp-server",
-  "version": "1.29.0",
+  "version": "1.32.0",
   "mcpName": "io.github.omnisocials/mcp-server",
   "description": "MCP server for OmniSocials API - manage social media posts, media, accounts, analytics, and webhooks",
   "type": "module",