@omnisocials/mcp-server 1.2.1 → 1.3.1

package/README.md

@@ -17,6 +17,16 @@ https://mcp.omnisocials.com?API_KEY=omsk_live_your_key_here
 
 No installation needed. Paste this URL into your client's MCP settings.
 
+### Multiple workspaces
+
+To manage multiple workspaces from a single connection, separate your API keys with commas:
+
+```
+https://mcp.omnisocials.com?API_KEY=omsk_live_key1,omsk_live_key2
+```
+
+Then ask your AI assistant to "list my workspaces" to see all connected workspaces and switch between them. Each key stays scoped to its own workspace for security.
+
 ## Local Setup (npm package)
 
 ### Claude Code
@@ -25,7 +35,7 @@ No installation needed. Paste this URL into your client's MCP settings.
 claude mcp add omnisocials -- npx -y @omnisocials/mcp-server
 ```
 
-Then set your API key:
+Then set your API key (comma-separated for multiple workspaces):
 
 ```bash
 export OMNISOCIALS_API_KEY=omsk_live_your_key_here
@@ -140,6 +150,13 @@ OmniSocials accepts the following channel IDs in `create_post`, `create_and_publ
 | `get_analytics_overview` | Overview analytics for a time period |
 | `get_account_analytics` | Account-level analytics (followers, etc.) |
 
+### Workspaces (2 tools)
+
+| Tool | Description |
+|------|-------------|
+| `list_workspaces` | List all workspaces available in this session |
+| `switch_workspace` | Switch the active workspace |
+
 ### Webhooks (5 tools)
 
 | Tool | Description |
@@ -155,7 +172,7 @@ OmniSocials accepts the following channel IDs in `create_post`, `create_and_publ
 
 | Variable | Required | Description |
 |----------|----------|-------------|
-| `OMNISOCIALS_API_KEY` | Yes | Your API key (`omsk_live_*` or `omsk_test_*`) |
+| `OMNISOCIALS_API_KEY` | Yes | Your API key (`omsk_live_*` or `omsk_test_*`). Comma-separated for multiple workspaces. |
 | `OMNISOCIALS_BASE_URL` | No | Custom API base URL (defaults to production) |
 
 ## Alternative: Agent Skills

package/build/client.d.ts

@@ -9,6 +9,27 @@ export declare function formatDate(iso: string | null): string;
 export declare function formatDateTime(iso: string | null): string;
 export declare function truncate(str: string, len: number): string;
 export declare function capitalize(str: string): string;
+export interface XThreadPartInput {
+    /** Tweet text — ≤ 280 chars (the API enforces 280 even for X Premium). */
+    text: string;
+    /** Optional per-part media URLs (max 4). Overrides top-level media_urls.x. */
+    media_urls?: string[];
+}
+export interface XPostOptions {
+    reply_settings?: "" | "following" | "mentionedUsers";
+    paid_partnership?: boolean;
+    made_with_ai?: boolean;
+    /** Provide 2–25 parts to publish as a thread. Omit for a single tweet. */
+    thread_parts?: XThreadPartInput[];
+}
+/**
+ * Update-side variant: passing `thread_parts: null` explicitly clears the
+ * thread shape on the post (reverting to single-tweet mode). Passing
+ * `undefined` (omit it) leaves the existing thread untouched.
+ */
+export interface XPostOptionsUpdate extends Omit<XPostOptions, "thread_parts"> {
+    thread_parts?: XThreadPartInput[] | null;
+}
 export declare class OmniSocialsClient {
     private baseUrl;
     private apiKey;
@@ -21,7 +42,7 @@ export declare class OmniSocialsClient {
     }): Promise<ApiResponse<unknown>>;
     getPost(id: string): Promise<ApiResponse<unknown>>;
     createPost(data: {
-        content: string;
+        content: string | Record<string, string>;
         channels?: string[];
         scheduled_at?: string;
         media_ids?: string[] | Record<string, string[]>;
@@ -32,10 +53,10 @@ export declare class OmniSocialsClient {
         youtube?: Record<string, unknown>;
         instagram?: Record<string, unknown>;
         tiktok?: Record<string, unknown>;
-        x?: Record<string, unknown>;
+        x?: XPostOptions;
     }): Promise<ApiResponse<unknown>>;
     createAndPublishPost(data: {
-        content: string;
+        content: string | Record<string, string>;
         channels?: string[];
         media_ids?: string[] | Record<string, string[]>;
         media_urls?: string[] | Record<string, string[]>;
@@ -45,10 +66,10 @@ export declare class OmniSocialsClient {
         youtube?: Record<string, unknown>;
         instagram?: Record<string, unknown>;
         tiktok?: Record<string, unknown>;
-        x?: Record<string, unknown>;
+        x?: XPostOptions;
     }): Promise<ApiResponse<unknown>>;
     updatePost(id: string, data: {
-        content?: string;
+        content?: string | Record<string, string>;
         scheduled_at?: string;
         channels?: string[];
         media_ids?: string[] | Record<string, string[]>;
@@ -58,7 +79,7 @@ export declare class OmniSocialsClient {
         youtube?: Record<string, unknown>;
         instagram?: Record<string, unknown>;
         tiktok?: Record<string, unknown>;
-        x?: Record<string, unknown>;
+        x?: XPostOptionsUpdate;
     }): Promise<ApiResponse<unknown>>;
     deletePost(id: string): Promise<ApiResponse<unknown>>;
     publishPost(id: string): Promise<ApiResponse<unknown>>;
@@ -70,6 +91,11 @@ export declare class OmniSocialsClient {
         url: string;
         filename?: string;
     }): Promise<ApiResponse<unknown>>;
+    uploadMediaFromBase64(data: {
+        data: string;
+        mime_type: string;
+        filename?: string;
+    }): Promise<ApiResponse<unknown>>;
     deleteMedia(id: string): Promise<ApiResponse<unknown>>;
     listAccounts(): Promise<ApiResponse<unknown>>;
     getAccount(id: string): Promise<ApiResponse<unknown>>;

package/build/client.js

@@ -7,7 +7,13 @@ export async function fetchImageAsBase64(url) {
         clearTimeout(timeout);
         if (!response.ok)
             return null;
+        // Skip images larger than 3MB to avoid blowing up MCP responses
+        const contentLength = response.headers.get("content-length");
+        if (contentLength && parseInt(contentLength) > 3 * 1024 * 1024)
+            return null;
         const buffer = await response.arrayBuffer();
+        if (buffer.byteLength > 3 * 1024 * 1024)
+            return null;
         const base64 = Buffer.from(buffer).toString("base64");
         const mimeType = response.headers.get("content-type") || "image/png";
         return { data: base64, mimeType };
@@ -131,6 +137,9 @@ export class OmniSocialsClient {
     async uploadMedia(data) {
         return this.request("POST", "/media/upload-from-url", data);
     }
+    async uploadMediaFromBase64(data) {
+        return this.request("POST", "/media/upload-from-base64", data);
+    }
     async deleteMedia(id) {
         return this.request("DELETE", `/media/${id}`);
     }

package/build/index.js

@@ -8,24 +8,34 @@ import { registerMediaTools } from "./tools/media.js";
 import { registerAccountTools } from "./tools/accounts.js";
 import { registerAnalyticsTools } from "./tools/analytics.js";
 import { registerWebhookTools } from "./tools/webhooks.js";
-const apiKey = process.env.OMNISOCIALS_API_KEY;
-if (!apiKey) {
+import { registerWorkspaceTools } from "./tools/workspaces.js";
+const apiKeyEnv = process.env.OMNISOCIALS_API_KEY;
+if (!apiKeyEnv) {
     console.error("Error: OMNISOCIALS_API_KEY environment variable is required.");
     console.error("Get your API key from OmniSocials Settings > API.");
+    console.error("For multiple workspaces, separate keys with commas.");
     process.exit(1);
 }
 const baseUrl = process.env.OMNISOCIALS_BASE_URL;
-const client = new OmniSocialsClient(apiKey, baseUrl);
+// Support comma-separated keys for multi-workspace access
+const apiKeys = apiKeyEnv.split(",").map((k) => k.trim()).filter(Boolean);
+const workspaceClients = apiKeys.map((key) => ({
+    apiKey: key,
+    client: new OmniSocialsClient(key, baseUrl),
+}));
+const sessionState = { activeIndex: 0 };
+const getActiveClient = () => workspaceClients[sessionState.activeIndex].client;
 const server = new McpServer({
     name: "OmniSocials",
-    version: "1.0.0",
+    version: "1.2.0",
 });
-// Register all tools
-registerPostTools(server, client);
-registerMediaTools(server, client);
-registerAccountTools(server, client);
-registerAnalyticsTools(server, client);
-registerWebhookTools(server, client);
+// Register all tools - pass getter function so tools always use the active workspace's client
+registerPostTools(server, getActiveClient);
+registerMediaTools(server, getActiveClient);
+registerAccountTools(server, getActiveClient);
+registerAnalyticsTools(server, getActiveClient);
+registerWebhookTools(server, getActiveClient);
+registerWorkspaceTools(server, workspaceClients, sessionState);
 // Register prompts
 server.prompt("weekly-report", "Generate a weekly social media performance report", {}, async () => ({
     messages: [

package/build/tools/accounts.d.ts

@@ -1,3 +1,3 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { OmniSocialsClient } from "../client.js";
-export declare function registerAccountTools(server: McpServer, client: OmniSocialsClient): void;
+export declare function registerAccountTools(server: McpServer, getClient: () => OmniSocialsClient): void;

package/build/tools/accounts.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { fetchImageAsBase64, capitalize } from "../client.js";
-export function registerAccountTools(server, client) {
+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), and supported content_types (post, story, reel). Pinterest accounts also 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.", {}, async () => {
-        const result = await client.listAccounts();
+        const result = await getClient().listAccounts();
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -54,7 +54,7 @@ export function registerAccountTools(server, client) {
     server.tool("get_account", "Get details of a specific connected social media account.", {
         id: z.string().describe("The account ID"),
     }, async ({ id }) => {
-        const result = await client.getAccount(id);
+        const result = await getClient().getAccount(id);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],

package/build/tools/analytics.d.ts

@@ -1,3 +1,3 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { OmniSocialsClient } from "../client.js";
-export declare function registerAnalyticsTools(server: McpServer, client: OmniSocialsClient): void;
+export declare function registerAnalyticsTools(server: McpServer, getClient: () => OmniSocialsClient): void;

package/build/tools/analytics.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { formatNumber, capitalize } from "../client.js";
-export function registerAnalyticsTools(server, client) {
+export function registerAnalyticsTools(server, getClient) {
     server.tool("get_post_analytics", "Get analytics/statistics for a specific published post (impressions, engagements, likes, etc.).", {
         post_id: z.string().describe("The post ID to get analytics for"),
     }, async ({ post_id }) => {
-        const result = await client.getPostAnalytics(post_id);
+        const result = await getClient().getPostAnalytics(post_id);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -54,7 +54,7 @@ export function registerAnalyticsTools(server, client) {
         start_date: z.string().optional().describe("Custom start date (ISO 8601)"),
         end_date: z.string().optional().describe("Custom end date (ISO 8601)"),
     }, async (params) => {
-        const result = await client.getAnalyticsOverview(params);
+        const result = await getClient().getAnalyticsOverview(params);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -92,7 +92,7 @@ export function registerAnalyticsTools(server, client) {
         platform: z.string().optional().describe("Filter by platform (e.g., instagram, youtube)"),
         date: z.string().optional().describe("Date to get analytics for (YYYY-MM-DD, defaults to today)"),
     }, async (params) => {
-        const result = await client.getAccountAnalytics(params);
+        const result = await getClient().getAccountAnalytics(params);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],

package/build/tools/media.d.ts

@@ -1,3 +1,3 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { OmniSocialsClient } from "../client.js";
-export declare function registerMediaTools(server: McpServer, client: OmniSocialsClient): void;
+export declare function registerMediaTools(server: McpServer, getClient: () => OmniSocialsClient): void;

package/build/tools/media.js

@@ -1,11 +1,11 @@
 import { z } from "zod";
 import { fetchImageAsBase64, formatBytes } from "../client.js";
-export function registerMediaTools(server, client) {
+export function registerMediaTools(server, getClient) {
     server.tool("list_media", "List all media files in the workspace. Returns each file's ID, URL, type (image/video), and size. Use this to help users pick media for posts, stories, or reels. Media IDs or URLs from this list can be passed to create_post.", {
         limit: z.string().optional().describe("Max results to return"),
         offset: z.string().optional().describe("Offset for pagination"),
     }, async (params) => {
-        const result = await client.listMedia(params);
+        const result = await getClient().listMedia(params);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -42,11 +42,30 @@ export function registerMediaTools(server, client) {
         content.push({ type: "text", text: md });
         return { content };
     });
-    server.tool("upload_media", "Upload media from a URL. The file will be downloaded and stored. Max 50MB.", {
-        url: z.string().describe("Public URL of the media file to upload"),
+    server.tool("upload_media", `Upload media to the library. Accepts EITHER a public URL OR base64-encoded image data (e.g. when the user pastes an image directly in chat). Max 50MB. Supported: JPEG, PNG, GIF, WebP, MP4, MOV, AVI.
+
+When the user provides an image in the conversation (not a URL), use base64_data + mime_type to upload it directly.`, {
+        url: z.string().optional().describe("Public URL of the media file to upload. Use this OR base64_data, not both."),
+        base64_data: z.string().optional().describe("Base64-encoded file data. Use when the user provides an image directly in chat rather than a URL."),
+        mime_type: z.string().optional().describe("MIME type of the file (e.g. 'image/jpeg', 'image/png'). Required when using base64_data."),
         filename: z.string().optional().describe("Optional filename for the uploaded media"),
     }, async (params) => {
-        const result = await client.uploadMedia(params);
+        let result;
+        if (params.base64_data && params.mime_type) {
+            result = await getClient().uploadMediaFromBase64({
+                data: params.base64_data,
+                mime_type: params.mime_type,
+                filename: params.filename,
+            });
+        }
+        else if (params.url) {
+            result = await getClient().uploadMedia({ url: params.url, filename: params.filename });
+        }
+        else {
+            return {
+                content: [{ type: "text", text: "Error: Provide either 'url' or 'base64_data' + 'mime_type'." }],
+            };
+        }
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -68,7 +87,7 @@ export function registerMediaTools(server, client) {
     server.tool("delete_media", "Delete a media file by ID.", {
         id: z.string().describe("The media ID to delete"),
     }, async ({ id }) => {
-        const result = await client.deleteMedia(id);
+        const result = await getClient().deleteMedia(id);
         return {
             content: [{ type: "text", text: result.error ? `Error: ${result.error.message}` : "Media deleted successfully." }],
         };

package/build/tools/posts.d.ts

@@ -1,3 +1,3 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { OmniSocialsClient } from "../client.js";
-export declare function registerPostTools(server: McpServer, client: OmniSocialsClient): void;
+export declare function registerPostTools(server: McpServer, getClient: () => OmniSocialsClient): void;

package/build/tools/posts.js

@@ -1,12 +1,30 @@
 import { z } from "zod";
 import { formatDateTime, truncate, capitalize } from "../client.js";
-export function registerPostTools(server, client) {
-    server.tool("list_posts", "List all posts in the workspace. Optionally filter by status.", {
+// Render full content for get_post — preserves per-platform overrides so Claude
+// can see custom captions (e.g. a shorter X version) instead of only `default`.
+function renderContent(content) {
+    if (!content)
+        return "(empty)";
+    if (typeof content === "string")
+        return content;
+    if (typeof content !== "object")
+        return "(empty)";
+    const entries = Object.entries(content).filter(([, v]) => typeof v === "string" && v);
+    if (!entries.length)
+        return "(empty)";
+    if (entries.length === 1)
+        return entries[0][1];
+    return entries
+        .map(([key, value]) => `**${key === "default" ? "Default (fallback)" : capitalize(key.replace(/_/g, " "))}**\n\n${value}`)
+        .join("\n\n---\n\n");
+}
+export function registerPostTools(server, getClient) {
+    server.tool("list_posts", "List all posts in the workspace. Optionally filter by status. The content column shows a preview of the default caption; if a post has per-platform overrides (e.g. a custom X version), the preview is suffixed with *(per-platform)* — call `get_post` to see every variant.", {
         status: z.string().optional().describe("Filter by status: draft, scheduled, published, failed"),
         limit: z.string().optional().describe("Max results to return (default: 20)"),
         offset: z.string().optional().describe("Offset for pagination"),
     }, async (params) => {
-        const result = await client.listPosts(params);
+        const result = await getClient().listPosts(params);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -24,7 +42,21 @@ export function registerPostTools(server, client) {
         md += `|---|---------|----------|--------|------|----|\n`;
         for (let i = 0; i < posts.length; i++) {
             const p = posts[i];
-            const content = truncate(p.content || "", 50);
+            const isObj = typeof p.content === "object" && p.content !== null;
+            const rawContent = isObj
+                ? (p.content.default || Object.values(p.content).find((v) => typeof v === "string" && v) || "")
+                : (p.content || "");
+            const hasOverrides = isObj && Object.keys(p.content).filter((k) => k !== "default" && typeof p.content[k] === "string" && p.content[k]).length > 0;
+            const threadParts = Array.isArray(p.x?.thread_parts) ? p.x.thread_parts : [];
+            const isThread = threadParts.length >= 2;
+            let content;
+            if (isThread && !rawContent) {
+                const first = typeof threadParts[0]?.text === "string" ? threadParts[0].text : "";
+                content = truncate(first, 32) + ` *(X thread, ${threadParts.length} parts)*`;
+            }
+            else {
+                content = truncate(rawContent, hasOverrides ? 35 : 50) + (hasOverrides ? " *(per-platform)*" : "");
+            }
             const channels = (p.channels || []).join(", ");
             const status = capitalize(p.status || "—");
             const date = p.scheduled_at
@@ -38,10 +70,10 @@ export function registerPostTools(server, client) {
             content: [{ type: "text", text: md }],
         };
     });
-    server.tool("get_post", "Get details of a specific post by ID.", {
+    server.tool("get_post", "Get details of a specific post by ID. When a post has per-platform caption overrides (e.g. a shorter X version alongside the default), every variant is rendered as its own labeled block under `### Content` so you can see exactly what each platform will publish. X threads are rendered under `### X Thread` with each tweet labeled in publish order — read this to see the full chained tweet text, since thread-only posts have no caption in `content`. After publishing, includes `published_urls` — a map of platform → live URL for each platform that successfully posted (e.g. facebook, instagram, linkedin, x). Useful for polling: when a post's status is `published`, read `published_urls` to surface the live links.", {
         id: z.string().describe("The post ID"),
     }, async ({ id }) => {
-        const result = await client.getPost(id);
+        const result = await getClient().getPost(id);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -68,7 +100,34 @@ export function registerPostTools(server, client) {
         if (p.media?.length) {
             md += `| **Media** | ${p.media.length} file(s) |\n`;
         }
-        md += `\n### Content\n\n${p.content || "(empty)"}`;
+        md += `\n### Content\n\n${renderContent(p.content)}`;
+        // X thread: when present, the canonical tweet text lives here, not in `content`.
+        const threadParts = Array.isArray(p.x?.thread_parts)
+            ? p.x.thread_parts
+            : [];
+        if (threadParts.length >= 2) {
+            md += `\n\n### X Thread (${threadParts.length} parts)\n\n`;
+            for (let i = 0; i < threadParts.length; i++) {
+                const part = threadParts[i] || {};
+                const text = typeof part.text === "string" ? part.text : "";
+                md += `**${i + 1}/${threadParts.length}.** ${text}\n`;
+                if (Array.isArray(part.media_urls) && part.media_urls.length) {
+                    for (const url of part.media_urls)
+                        md += `  - ${url}\n`;
+                }
+                md += `\n`;
+            }
+        }
+        const publishedUrls = (p.published_urls && typeof p.published_urls === "object" && !Array.isArray(p.published_urls))
+            ? p.published_urls
+            : {};
+        const urlEntries = Object.entries(publishedUrls);
+        if (urlEntries.length) {
+            md += `\n\n### Published URLs\n\n`;
+            for (const [platform, url] of urlEntries) {
+                md += `- **${capitalize(platform.replace(/_/g, " "))}**: ${url}\n`;
+            }
+        }
         return {
             content: [{ type: "text", text: md }],
         };
@@ -77,7 +136,8 @@ export function registerPostTools(server, client) {
 
 IMPORTANT — Before calling this tool, make sure you have all required information from the user. If anything is missing, ASK the user before calling:
 
-1. **Content/caption**: What text should the post have?
+0. **Workspace**: If the user has only one workspace, just use it (no need to ask). If the user has multiple workspaces and has NOT named one in their request, call list_workspaces and ask which workspace to post to before calling this tool. If the user has named a workspace, switch to it once and remember the choice for the rest of the conversation. Never silently pick a workspace when more than one exists. After a successful create/schedule, mention the workspace name in your reply to the user for clarity (e.g. "Scheduled to the Acme workspace for Tuesday 3pm").
+1. **Content/caption**: What text should the post have? If captions differ per platform, use one call with an object: { "default": "fallback text", "linkedin": "long version", "threads": "short version" }. Always prefer one call per topic.
 2. **Channels**: Which platforms to post to? Use list_accounts to show available options if needed.
 3. **Schedule**: When should it be published? (Or save as draft?)
 4. **Media** (REQUIRED for some types):
@@ -91,9 +151,12 @@ IMPORTANT — Before calling this tool, make sure you have all required informat
    - Pinterest: Which board? Any link to attach?
    - YouTube: Title, privacy status, tags?
    - TikTok: Privacy level?
+   - **X threads**: When the user asks for an X/Twitter "thread" (or anything that exceeds 280 chars on X), DO NOT cram it into \`content\` with "1/", "2/" prefixes. Instead pass \`x.thread_parts\` as an array of 2–25 \`{ text }\` objects (each ≤ 280 chars). The \`content\` field is then ignored for X. For a single tweet, omit \`thread_parts\` and use \`content\` normally.
 
-Do NOT call this tool without media when creating stories, reels, Instagram posts, TikTok posts, or Pinterest posts — it will fail.`, {
-        content: z.string().describe("The post content/caption text"),
+Do NOT call this tool without media when creating stories, reels, Instagram posts, TikTok posts, or Pinterest posts — it will fail.
+
+**When the user shares an image in chat but you cannot upload it** (e.g. no public URL available): save the post as a draft with the caption, then tell the user: "I saved your post as a draft in OmniSocials. Open it there to add your image and schedule it when ready." Include a link to https://app.omnisocials.com. Do NOT tell the user it's impossible — always save the draft so their caption isn't lost.`, {
+        content: z.union([z.string(), z.record(z.string(), z.string())]).describe("Post caption. String for same text on all channels, or object with platform keys for per-channel captions: { \"default\": \"fallback\", \"linkedin\": \"long version\", \"threads\": \"short version\" }. The \"default\" key is used for any selected channel without its own key."),
         channels: z.array(z.string()).optional().describe("Array of channel IDs to post to. Get the available channel IDs from list_accounts. Note: `linkedin` (personal profile) and `linkedin_page` (company page) are independent channels. A workspace can have both connected and post to each separately."),
         scheduled_at: z.string().optional().describe("ISO 8601 date for scheduled publishing"),
         media_ids: z.union([
@@ -135,9 +198,15 @@ Do NOT call this tool without media when creating stories, reels, Instagram post
         }).optional().describe("TikTok options"),
         x: z.object({
             reply_settings: z.enum(["", "following", "mentionedUsers"]).optional(),
+            paid_partnership: z.boolean().optional().describe("Mark as paid partnership disclosure"),
+            made_with_ai: z.boolean().optional().describe("Mark as AI-generated content"),
+            thread_parts: z.array(z.object({
+                text: z.string().describe("Tweet text (≤ 280 chars)"),
+                media_urls: z.array(z.string()).max(4).optional().describe("Per-tweet media URLs (max 4)"),
+            })).min(2).max(25).optional().describe("Publish as a chained X thread instead of a single tweet. Provide 2–25 parts; each is posted in order via in_reply_to_tweet_id. Per-part media_urls override top-level media for that specific tweet. For a single tweet, omit thread_parts and use content."),
         }).optional().describe("X (Twitter) options"),
     }, async (params) => {
-        const result = await client.createPost({ ...params, source: "mcp" });
+        const result = await getClient().createPost({ ...params, source: "mcp" });
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -162,7 +231,8 @@ Do NOT call this tool without media when creating stories, reels, Instagram post
 
 IMPORTANT — Before calling this tool, make sure you have all required information. If anything is missing, ASK the user first:
 
-1. **Content/caption**: What text?
+0. **Workspace**: If the user has only one workspace, just use it (no need to ask). If the user has multiple workspaces and has NOT named one, call list_workspaces and ask before publishing. If the user has named a workspace, switch to it once and remember it. Never silently pick a workspace when more than one exists — published posts are public. After publishing, mention the workspace name in your reply (e.g. "Published to the Acme workspace LinkedIn Page").
+1. **Content/caption**: What text? If captions differ per platform, use one call with an object: { "default": "fallback", "linkedin": "long", "threads": "short" }.
 2. **Channels**: Which platforms? Use list_accounts if needed.
 3. **Media** (REQUIRED for some types — same rules as create_post):
    - Stories: ALWAYS need an image or video.
@@ -170,9 +240,10 @@ IMPORTANT — Before calling this tool, make sure you have all required informat
    - Instagram/TikTok posts: ALWAYS need at least one image or video.
    - Pinterest: ALWAYS need an image + board_id.
    - Ask the user which media to use. Use list_media to show options.
+4. **X threads**: When the user asks for an X/Twitter "thread" (or anything > 280 chars on X), pass \`x.thread_parts\` as a 2–25 entry array of \`{ text }\` objects. Do NOT split into "1/", "2/" inside \`content\` — that produces a single tweet, not a thread.
 
 Do NOT call without required media — it will fail.`, {
-        content: z.string().describe("The post content/caption text"),
+        content: z.union([z.string(), z.record(z.string(), z.string())]).describe("Post caption. String for same text on all channels, or object with platform keys for per-channel captions: { \"default\": \"fallback\", \"linkedin\": \"long version\", \"threads\": \"short version\" }. The \"default\" key is used for any selected channel without its own key."),
         channels: z.array(z.string()).optional().describe("Array of channel IDs to post to. Get the available channel IDs from list_accounts. Note: `linkedin` (personal profile) and `linkedin_page` (company page) are independent channels. A workspace can have both connected and post to each separately."),
         media_ids: z.union([
             z.array(z.string()),
@@ -196,8 +267,17 @@ Do NOT call without required media — it will fail.`, {
         tiktok: z.object({
             privacy_level: z.enum(["PUBLIC_TO_EVERYONE", "MUTUAL_FOLLOW_FRIENDS", "FOLLOWER_OF_CREATOR", "SELF_ONLY"]).optional(),
         }).optional().describe("TikTok options"),
+        x: z.object({
+            reply_settings: z.enum(["", "following", "mentionedUsers"]).optional(),
+            paid_partnership: z.boolean().optional().describe("Mark as paid partnership disclosure"),
+            made_with_ai: z.boolean().optional().describe("Mark as AI-generated content"),
+            thread_parts: z.array(z.object({
+                text: z.string().describe("Tweet text (≤ 280 chars)"),
+                media_urls: z.array(z.string()).max(4).optional().describe("Per-tweet media URLs (max 4)"),
+            })).min(2).max(25).optional().describe("Publish as a chained X thread (2–25 parts). Each is posted in order via in_reply_to_tweet_id. Per-part media_urls override top-level media."),
+        }).optional().describe("X (Twitter) options"),
     }, async (params) => {
-        const result = await client.createAndPublishPost({ ...params, source: "mcp" });
+        const result = await getClient().createAndPublishPost({ ...params, source: "mcp" });
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -216,9 +296,11 @@ Do NOT call without required media — it will fail.`, {
             content: [{ type: "text", text: md }],
         };
     });
-    server.tool("update_post", "Update an existing post. Only draft and scheduled posts can be updated.", {
+    server.tool("update_post", `Update an existing post. Only draft and scheduled posts can be updated.
+
+**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.`, {
         id: z.string().describe("The post ID to update"),
-        content: z.string().optional().describe("Updated post content"),
+        content: z.union([z.string(), z.record(z.string(), z.string())]).optional().describe("Updated post content. String or object with platform keys: { \"default\": \"fallback\", \"linkedin\": \"long\" }."),
         scheduled_at: z.string().optional().describe("Updated scheduled date (ISO 8601)"),
         channels: z.array(z.string()).optional().describe("Updated channel IDs. Note: `linkedin` (personal profile) and `linkedin_page` (company page) are independent channels."),
         media_ids: z.union([
@@ -229,8 +311,17 @@ Do NOT call without required media — it will fail.`, {
             z.array(z.string()),
             z.record(z.string(), z.array(z.string())),
         ]).optional().describe("External URLs — flat array or per-platform object. Max 10 total. 'default' key is fallback for platforms without their own key. Empty array opts out."),
+        x: z.object({
+            reply_settings: z.enum(["", "following", "mentionedUsers"]).optional(),
+            paid_partnership: z.boolean().optional(),
+            made_with_ai: z.boolean().optional(),
+            thread_parts: z.array(z.object({
+                text: z.string().describe("Tweet text (≤ 280 chars)"),
+                media_urls: z.array(z.string()).max(4).optional().describe("Per-tweet media URLs (max 4)"),
+            })).min(2).max(25).nullable().optional().describe("Replace the X thread shape on this post. Pass an array (2–25 parts) to update/create the thread, or `null` to revert to single-tweet mode."),
+        }).optional().describe("X (Twitter) options"),
     }, async ({ id, ...data }) => {
-        const result = await client.updatePost(id, data);
+        const result = await getClient().updatePost(id, data);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -251,7 +342,7 @@ Do NOT call without required media — it will fail.`, {
     server.tool("delete_post", "Delete a post by ID. This action cannot be undone.", {
         id: z.string().describe("The post ID to delete"),
     }, async ({ id }) => {
-        const result = await client.deletePost(id);
+        const result = await getClient().deletePost(id);
         return {
             content: [{ type: "text", text: result.error ? `Error: ${result.error.message}` : "Post deleted successfully." }],
         };
@@ -261,7 +352,7 @@ Do NOT call without required media — it will fail.`, {
 IMPORTANT: Before publishing, verify the post has all required media. If publishing a story or reel, ensure media was attached when the post was created/updated. If it's missing, use update_post to add media first, or inform the user.`, {
         id: z.string().describe("The post ID to publish"),
     }, async ({ id }) => {
-        const result = await client.publishPost(id);
+        const result = await getClient().publishPost(id);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],

package/build/tools/webhooks.d.ts

@@ -1,3 +1,3 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { OmniSocialsClient } from "../client.js";
-export declare function registerWebhookTools(server: McpServer, client: OmniSocialsClient): void;
+export declare function registerWebhookTools(server: McpServer, getClient: () => OmniSocialsClient): void;

package/build/tools/webhooks.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { formatDateTime } from "../client.js";
-export function registerWebhookTools(server, client) {
+export function registerWebhookTools(server, getClient) {
     server.tool("list_webhooks", "List all configured webhooks.", {}, async () => {
-        const result = await client.listWebhooks();
+        const result = await getClient().listWebhooks();
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -32,7 +32,7 @@ export function registerWebhookTools(server, client) {
         url: z.string().describe("The HTTPS URL to send webhook events to"),
         events: z.array(z.string()).describe("Events to subscribe to: post.scheduled, post.published, post.failed"),
     }, async (params) => {
-        const result = await client.createWebhook(params);
+        const result = await getClient().createWebhook(params);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -57,7 +57,7 @@ export function registerWebhookTools(server, client) {
     server.tool("get_webhook", "Get details of a specific webhook by ID.", {
         id: z.string().describe("The webhook ID"),
     }, async ({ id }) => {
-        const result = await client.getWebhook(id);
+        const result = await getClient().getWebhook(id);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -84,7 +84,7 @@ export function registerWebhookTools(server, client) {
         events: z.array(z.string()).optional().describe("Updated event list"),
         is_active: z.boolean().optional().describe("Enable or disable the webhook"),
     }, async ({ id, ...data }) => {
-        const result = await client.updateWebhook(id, data);
+        const result = await getClient().updateWebhook(id, data);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],
@@ -105,7 +105,7 @@ export function registerWebhookTools(server, client) {
     server.tool("delete_webhook", "Delete a webhook by ID. You will stop receiving notifications at this URL.", {
         id: z.string().describe("The webhook ID to delete"),
     }, async ({ id }) => {
-        const result = await client.deleteWebhook(id);
+        const result = await getClient().deleteWebhook(id);
         return {
             content: [{ type: "text", text: result.error ? `Error: ${result.error.message}` : "Webhook deleted successfully." }],
         };
@@ -113,7 +113,7 @@ export function registerWebhookTools(server, client) {
     server.tool("rotate_webhook_secret", "Rotate the signing secret for a webhook. The new secret will only be shown once.", {
         id: z.string().describe("The webhook ID"),
     }, async ({ id }) => {
-        const result = await client.rotateWebhookSecret(id);
+        const result = await getClient().rotateWebhookSecret(id);
         if (result.error) {
             return {
                 content: [{ type: "text", text: `Error: ${result.error.message}` }],

package/build/tools/workspaces.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { OmniSocialsClient } from "../client.js";
+export interface WorkspaceClient {
+    apiKey: string;
+    client: OmniSocialsClient;
+}
+export interface SessionState {
+    activeIndex: number;
+}
+export declare function registerWorkspaceTools(server: McpServer, workspaceClients: WorkspaceClient[], sessionState: SessionState): void;

package/build/tools/workspaces.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export function registerWorkspaceTools(server, workspaceClients, sessionState) {
+    server.tool("list_workspaces", "List all workspaces available in this session. Each workspace corresponds to an API key provided at connection time. Shows which workspace is currently active. Workspace selection rule: if only one workspace is available, just use it (no need to ask). If the user has named a workspace in their request (e.g. 'post to my Acme workspace'), proceed with that workspace and remember it for the rest of the conversation. If multiple workspaces exist and the user has NOT named one, call this tool, present the list, and ASK the user which one to use before posting, switching, or fetching analytics. After a successful action, mention the workspace name in your reply for clarity.", {}, async () => {
+        const workspaces = await Promise.all(workspaceClients.map(async (wc, index) => {
+            try {
+                const result = await wc.client.listAccounts();
+                return {
+                    index,
+                    workspace_name: result.workspace_name || `Workspace ${index + 1}`,
+                    active: index === sessionState.activeIndex,
+                    accounts_count: (Array.isArray(result.data) ? result.data : []).length,
+                };
+            }
+            catch {
+                return {
+                    index,
+                    workspace_name: `Workspace ${index + 1}`,
+                    active: index === sessionState.activeIndex,
+                    accounts_count: 0,
+                };
+            }
+        }));
+        if (workspaces.length === 1) {
+            const ws = workspaces[0];
+            return {
+                content: [{
+                        type: "text",
+                        text: `## Current Workspace\n\n**${ws.workspace_name}** (${ws.accounts_count} connected accounts)\n\nThis is the only workspace available. To add more workspaces, add additional API keys separated by commas in OMNISOCIALS_API_KEY.`,
+                    }],
+            };
+        }
+        let md = `## Workspaces (${workspaces.length})\n\n`;
+        md += `| # | Workspace | Accounts | Status |\n`;
+        md += `|---|-----------|----------|--------|\n`;
+        for (const ws of workspaces) {
+            const status = ws.active ? "**Active**" : "";
+            md += `| ${ws.index + 1} | ${ws.workspace_name} | ${ws.accounts_count} | ${status} |\n`;
+        }
+        md += `\nUse **switch_workspace** with the workspace number to change the active workspace.`;
+        return { content: [{ type: "text", text: md }] };
+    });
+    server.tool("switch_workspace", "Switch the active workspace. All subsequent tool calls (posts, media, analytics, etc.) will operate on the selected workspace. Only call this when the user has explicitly named the target workspace, or after the user has picked one from list_workspaces. Never call switch_workspace silently when the user hasn't specified a workspace — ask first.", {
+        workspace_number: z.string().describe("The workspace number from list_workspaces (1, 2, 3, etc.)"),
+    }, async ({ workspace_number }) => {
+        const index = parseInt(workspace_number, 10) - 1;
+        if (isNaN(index) || index < 0 || index >= workspaceClients.length) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: Invalid workspace number. Use list_workspaces to see available options (1-${workspaceClients.length}).`,
+                    }],
+            };
+        }
+        sessionState.activeIndex = index;
+        const wc = workspaceClients[index];
+        let workspaceName = `Workspace ${index + 1}`;
+        try {
+            const result = await wc.client.listAccounts();
+            if (result.workspace_name)
+                workspaceName = result.workspace_name;
+        }
+        catch { }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Switched to **${workspaceName}**. All subsequent calls will use this workspace.`,
+                }],
+        };
+    });
+}

package/build/types.d.ts

@@ -14,6 +14,17 @@ export interface Post {
     channels: string[];
     media: string[];
     created_at: string;
+    x?: {
+        reply_settings?: string;
+        paid_partnership?: boolean;
+        made_with_ai?: boolean;
+        thread_parts?: Array<{
+            id?: string;
+            text: string;
+            media_urls?: string[];
+        }>;
+        [key: string]: unknown;
+    };
 }
 export interface MediaItem {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnisocials/mcp-server",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "MCP server for OmniSocials API - manage social media posts, media, accounts, analytics, and webhooks",
   "type": "module",
   "main": "build/index.js",