posterly-mcp-server 0.45.0 → 0.45.1

package/README.md

@@ -122,7 +122,7 @@ Add the same server definition to your Cursor MCP settings:
 
 ## Available tools
 
-`posterly-mcp-server@0.45.0` exposes 62 tools covering 94 actions. The hosted HTTP endpoint exposes the same catalog minus the three signup tools: 59 tools covering 91 actions.
+`posterly-mcp-server@0.45.1` exposes 62 tools covering 94 actions. The hosted HTTP endpoint exposes the same catalog minus the three signup tools: 59 tools covering 91 actions.
 
 Many tools pick what to do with one parameter: `view` (reads), `action` (writes), or `type`. A few pick their mode from which parameters you pass (for example `update_post` with `status` changes the status instead of editing). Every tool description names all of its views and actions.
 

package/dist/lib/version.d.ts

@@ -1 +1 @@
-export declare const POSTERLY_MCP_VERSION = "0.45.0";
+export declare const POSTERLY_MCP_VERSION = "0.45.1";

package/dist/lib/version.js

@@ -5,4 +5,4 @@
 // tool set (minus the intentional pre-auth signup tools that only this stdio
 // package exposes). `npm run check:mcp-parity` enforces both the version match
 // and the tool-list match, and runs in the pre-commit hook.
-export const POSTERLY_MCP_VERSION = '0.45.0';
+export const POSTERLY_MCP_VERSION = '0.45.1';

package/dist/tools/create-post.d.ts

@@ -2116,7 +2116,30 @@ export declare const createPostInputSchema: z.ZodObject<{
 }>;
 export type CreatePostInput = z.infer<typeof createPostInputSchema>;
 export type CreatePostPayloadInput = z.infer<typeof createPostPayloadInputSchema>;
-export declare function buildCreatePostPayload(input: CreatePostPayloadInput | CreatePostInput): Parameters<PosterlyClient['createPost']>[0];
+export type AccountPlatformLookup = {
+    found: true;
+    platform: string | null;
+} | {
+    found: false;
+    detail: string;
+};
+export type AccountPlatformResolver = (accountId: string, workspaceId?: string) => Promise<AccountPlatformLookup>;
+/**
+ * Builds a resolver that answers "what platform is this account_id on?" via
+ * client.listAccounts() (there is no GET /accounts/:id), for thread_posts
+ * calls that gave account_id without platform. Caches one in-flight lookup
+ * per workspace_id (including the unscoped list, keyed ''), so
+ * create_posts_batch never issues more than one accounts request per
+ * distinct workspace_id even though every item in the batch calls this
+ * independently: the cache is populated synchronously (before the first
+ * await) on the first call for a given workspace_id, so concurrent
+ * Promise.all callers for the same workspace_id share the one in-flight
+ * request. A failed lookup (non-2xx, missing accounts:read, network error)
+ * is cached too, so it is reported once per workspace_id rather than
+ * surfacing a fresh error per item.
+ */
+export declare function createAccountPlatformResolver(client: PosterlyClient): AccountPlatformResolver;
+export declare function buildCreatePostPayload(input: CreatePostPayloadInput | CreatePostInput, resolvePlatform: AccountPlatformResolver): Promise<Parameters<PosterlyClient['createPost']>[0]>;
 export declare const createPostTool: {
     name: string;
     description: string;

package/dist/tools/create-post.js

@@ -163,17 +163,83 @@ export const createPostPayloadInputSchema = z.object({
 export const createPostInputSchema = createPostPayloadInputSchema.extend({
     confirm: z.literal(true).describe('Must be true after explicit user confirmation of the post/account/workspace/schedule.'),
 });
-export function buildCreatePostPayload(input) {
+/**
+ * Builds a resolver that answers "what platform is this account_id on?" via
+ * client.listAccounts() (there is no GET /accounts/:id), for thread_posts
+ * calls that gave account_id without platform. Caches one in-flight lookup
+ * per workspace_id (including the unscoped list, keyed ''), so
+ * create_posts_batch never issues more than one accounts request per
+ * distinct workspace_id even though every item in the batch calls this
+ * independently: the cache is populated synchronously (before the first
+ * await) on the first call for a given workspace_id, so concurrent
+ * Promise.all callers for the same workspace_id share the one in-flight
+ * request. A failed lookup (non-2xx, missing accounts:read, network error)
+ * is cached too, so it is reported once per workspace_id rather than
+ * surfacing a fresh error per item.
+ */
+export function createAccountPlatformResolver(client) {
+    const cache = new Map();
+    const lookupForWorkspace = (workspaceKey) => {
+        let pending = cache.get(workspaceKey);
+        if (!pending) {
+            pending = (async () => {
+                try {
+                    const accounts = await client.listAccounts(workspaceKey ? { workspace_id: workspaceKey } : undefined);
+                    const platforms = new Map();
+                    for (const account of accounts) {
+                        if (account && typeof account.platform === 'string' && account.id !== undefined && account.id !== null) {
+                            platforms.set(String(account.id), account.platform);
+                        }
+                    }
+                    return { ok: true, platforms };
+                }
+                catch (error) {
+                    return { ok: false, detail: error?.message || 'accounts lookup failed' };
+                }
+            })();
+            cache.set(workspaceKey, pending);
+        }
+        return pending;
+    };
+    return async (accountId, workspaceId) => {
+        const workspaceKey = workspaceId || '';
+        const lookup = await lookupForWorkspace(workspaceKey);
+        if (!lookup.ok)
+            return { found: false, detail: lookup.detail };
+        return { found: true, platform: lookup.platforms.get(String(accountId)) ?? null };
+    };
+}
+export async function buildCreatePostPayload(input, resolvePlatform) {
     const { confirm: _confirm, thread_posts, caption, post_type, instagram_settings, platform_settings, ...rest } = input;
     if (thread_posts && thread_posts.length > 0) {
         if (thread_posts.length < 2) {
             throw new Error('thread_posts must contain at least 2 entries');
         }
         const platformHint = (input.platform || '').toLowerCase();
-        const isTwitter = platformHint === 'twitter' || platformHint === 'x';
-        const isThreads = platformHint === 'threads';
-        if (!isTwitter && !isThreads && !input.account_id) {
-            throw new Error('thread_posts requires `platform` to be "twitter" or "threads", or pass `account_id` for an X/Threads account.');
+        let isTwitter = platformHint === 'twitter' || platformHint === 'x';
+        let isThreads = platformHint === 'threads';
+        if (!isTwitter && !isThreads) {
+            if (!input.account_id) {
+                throw new Error('thread_posts requires `platform` to be "twitter" or "threads", or pass `account_id` for an X/Threads account.');
+            }
+            // No platform hint: never guess X. Resolve the account's real platform
+            // first, so a Threads account_id builds a threads_thread, not an
+            // x_thread that the server then rejects.
+            const lookup = await resolvePlatform(input.account_id, input.workspace_id);
+            if (!lookup.found) {
+                throw new Error(`thread_posts could not resolve account_id's platform (${lookup.detail}). Pass \`platform\` explicitly.`);
+            }
+            else if (lookup.platform === 'threads') {
+                isThreads = true;
+            }
+            else if (lookup.platform === 'twitter') {
+                isTwitter = true;
+            }
+            else {
+                throw new Error(lookup.platform
+                    ? `thread_posts requires an X/Twitter or Threads account; account_id resolved to platform "${lookup.platform}".`
+                    : 'thread_posts requires `platform` to be "twitter" or "threads", or an `account_id` that exists in list_accounts. Pass `platform` explicitly.');
+            }
         }
         const arrayKey = isThreads ? 'threads_thread_posts' : 'x_thread_tweets';
         const totalKey = isThreads ? 'threads_thread_total' : 'x_thread_total';
@@ -227,7 +293,7 @@ export const createPostTool = {
         if (input.confirm !== true) {
             throw new Error('Refusing to create post without confirm=true after explicit user confirmation.');
         }
-        const payload = buildCreatePostPayload(input);
+        const payload = await buildCreatePostPayload(input, createAccountPlatformResolver(client));
         const { thread_posts, instagram_settings, platform_settings } = input;
         const result = await client.createPost(payload);
         const p = result.post;

package/dist/tools/create-posts-batch.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { dashboardUrlForPostList, formatLocalDateTime } from '../lib/format.js';
-import { buildCreatePostPayload, createPostPayloadInputSchema } from './create-post.js';
+import { buildCreatePostPayload, createAccountPlatformResolver, createPostPayloadInputSchema } from './create-post.js';
 export const createPostsBatchTool = {
     name: 'create_posts_batch',
     description: 'Create 1-25 scheduled or immediate social posts in one API request. This is a DESTRUCTIVE WRITE that creates content on the user\'s real social accounts - once scheduled_at passes, posts may go public and cannot be un-posted.\n\n' +
@@ -22,7 +22,19 @@ export const createPostsBatchTool = {
         if (input.confirm !== true) {
             throw new Error('Refusing to create batch posts without confirm=true after explicit user confirmation.');
         }
-        const payloads = input.posts.map((post) => buildCreatePostPayload(post));
+        // One resolver shared across the whole batch: createAccountPlatformResolver
+        // caches its accounts lookup per workspace_id, so N items that all need
+        // thread_posts platform resolution for the same workspace still cost one
+        // listAccounts() call, not N.
+        const resolvePlatform = createAccountPlatformResolver(client);
+        const payloads = await Promise.all(input.posts.map(async (post, index) => {
+            try {
+                return await buildCreatePostPayload(post, resolvePlatform);
+            }
+            catch (error) {
+                throw new Error(`Item ${index}: ${error?.message || 'invalid post input'}`);
+            }
+        }));
         const result = await client.createPostsBatch({ posts: payloads });
         const createdPosts = result.posts.map((item) => item.post);
         const dashboardUrl = dashboardUrlForPostList(createdPosts);

package/dist/tools/validate-post.js

@@ -1,11 +1,11 @@
-import { buildCreatePostPayload, createPostPayloadInputSchema, } from './create-post.js';
+import { buildCreatePostPayload, createAccountPlatformResolver, createPostPayloadInputSchema, } from './create-post.js';
 export const validatePostInputSchema = createPostPayloadInputSchema;
 export const validatePostTool = {
     name: 'validate_post',
     description: 'Validate and normalize one post without creating it. This does not create records, copy remote media, consume post-item/storage quota, reserve X quota, emit webhooks, or enqueue publication. Third-party media may return remote_media_not_materialized because live create performs storage copy and final byte validation. Use this before showing the final preview and asking for confirmation to call create_post.',
     inputSchema: validatePostInputSchema,
     async execute(client, input) {
-        const payload = buildCreatePostPayload(input);
+        const payload = await buildCreatePostPayload(input, createAccountPlatformResolver(client));
         const result = await client.validatePost(payload);
         const lines = [
             'Post validation passed.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posterly-mcp-server",
-  "version": "0.45.0",
+  "version": "0.45.1",
   "mcpName": "io.github.awpthorp/posterly",
   "description": "MCP server for posterly: schedule and publish social media posts across 18 platforms from any MCP client (Claude, ChatGPT, Cursor, Windsurf, Cline, and more)",
   "license": "MIT",

package/scripts/test-payload-builders.mjs

@@ -12,15 +12,23 @@
  *
  * These tests pin the rules the server actually applies, so a future edit that
  * tightens the client past the server fails here.
+ *
+ * buildCreatePostPayload also takes an AccountPlatformResolver (built from a
+ * PosterlyClient by createAccountPlatformResolver) so it can resolve an
+ * account_id's real platform for thread_posts when the caller did not pass
+ * `platform` (there is no other way to tell an X thread from a Threads
+ * thread). fakeClient() below stands in for the real client, and counts
+ * calls so the "one lookup per workspace_id" batching behaviour can be
+ * asserted directly.
  */
 
 import assert from 'node:assert/strict';
-import { buildCreatePostPayload } from '../dist/tools/create-post.js';
+import { buildCreatePostPayload, createAccountPlatformResolver } from '../dist/tools/create-post.js';
 
 let failures = 0;
-function check(name, fn) {
+async function check(name, fn) {
   try {
-    fn();
+    await fn();
     console.log(`PASS  ${name}`);
   } catch (error) {
     failures += 1;
@@ -30,58 +38,173 @@ function check(name, fn) {
 
 const IMAGE = 'https://assets.poster.ly/users/test/a.jpg';
 
+/**
+ * A minimal PosterlyClient stand-in. Throws if listAccounts is called when
+ * the test does not expect it (accounts === null), or rejects with `fail`
+ * when a lookup-failure test needs a realistic error. Tracks call count so
+ * "one lookup per workspace_id" can be asserted.
+ */
+function fakeClient(accounts = null, { fail } = {}) {
+  let calls = 0;
+  return {
+    calls: () => calls,
+    async listAccounts() {
+      calls += 1;
+      if (fail) throw new Error(fail);
+      if (accounts === null) {
+        throw new Error('listAccounts should not have been called for this input');
+      }
+      return accounts;
+    },
+  };
+}
+
 // The server rule (lib/api-v1-post-create.ts) is "provide caption or media".
 // Media-only posts are valid and must not be rejected by the client.
-check('media-only post is accepted (Instagram Story shape)', () => {
-  const payload = buildCreatePostPayload({
+await check('media-only post is accepted (Instagram Story shape)', async () => {
+  const payload = await buildCreatePostPayload({
     platform: 'instagram',
     media_url: IMAGE,
     post_type: 'story',
     instagram_settings: { post_type: 'story' },
-  });
+  }, createAccountPlatformResolver(fakeClient()));
   assert.equal(typeof payload.caption, 'string', 'caption should be sent as a string');
   assert.equal(payload.post_type, 'story');
 });
 
-check('media-only post is accepted (Facebook Story shape)', () => {
-  const payload = buildCreatePostPayload({
+await check('media-only post is accepted (Facebook Story shape)', async () => {
+  const payload = await buildCreatePostPayload({
     platform: 'facebook',
     media_url: IMAGE,
     post_type: 'story',
     platform_settings: { __type: 'facebook', post_type: 'story' },
-  });
+  }, createAccountPlatformResolver(fakeClient()));
   assert.equal(typeof payload.caption, 'string');
 });
 
-check('media_urls-only post is accepted', () => {
-  const payload = buildCreatePostPayload({ platform: 'instagram', media_urls: [IMAGE] });
+await check('media_urls-only post is accepted', async () => {
+  const payload = await buildCreatePostPayload(
+    { platform: 'instagram', media_urls: [IMAGE] },
+    createAccountPlatformResolver(fakeClient()),
+  );
   assert.equal(typeof payload.caption, 'string');
 });
 
-check('caption-only post is accepted', () => {
-  const payload = buildCreatePostPayload({ platform: 'linkedin', caption: 'hello' });
+await check('caption-only post is accepted', async () => {
+  const payload = await buildCreatePostPayload(
+    { platform: 'linkedin', caption: 'hello' },
+    createAccountPlatformResolver(fakeClient()),
+  );
   assert.equal(payload.caption, 'hello');
 });
 
-check('post with neither caption nor media is rejected', () => {
-  assert.throws(
-    () => buildCreatePostPayload({ platform: 'instagram' }),
+await check('post with neither caption nor media is rejected', async () => {
+  await assert.rejects(
+    () => buildCreatePostPayload({ platform: 'instagram' }, createAccountPlatformResolver(fakeClient())),
     /caption or media/i,
     'should reject, and the message should tell the caller media is an option',
   );
 });
 
-check('thread_posts still bypasses the caption rule', () => {
-  const payload = buildCreatePostPayload({
+await check('thread_posts still bypasses the caption rule', async () => {
+  const payload = await buildCreatePostPayload({
     platform: 'twitter',
     thread_posts: ['one', 'two'],
-  });
+  }, createAccountPlatformResolver(fakeClient()));
   assert.equal(payload.caption, 'one');
   assert.equal(payload.post_type, 'x_thread');
 });
 
+// Regression: thread_posts with only account_id (no platform) used to always
+// guess an X thread, so a Threads account_id built x_thread_tweets and the
+// server rejected it with "post_type x_thread requires a Twitter/X account".
+await check('thread_posts + account_id resolves to threads_thread for a Threads account', async () => {
+  const payload = await buildCreatePostPayload({
+    account_id: 'acct_threads',
+    thread_posts: ['one', 'two'],
+  }, createAccountPlatformResolver(fakeClient([{ id: 'acct_threads', platform: 'threads', username: 'brand' }])));
+  assert.equal(payload.platform, 'threads');
+  assert.equal(payload.post_type, 'threads_thread');
+  assert.deepEqual(payload.metadata.threads_thread_posts, ['one', 'two']);
+  assert.equal(payload.metadata.x_thread_tweets, undefined);
+});
+
+await check('thread_posts + account_id resolves to x_thread for a Twitter/X account', async () => {
+  const payload = await buildCreatePostPayload({
+    account_id: 'acct_x',
+    thread_posts: ['one', 'two'],
+  }, createAccountPlatformResolver(fakeClient([{ id: 'acct_x', platform: 'twitter', username: 'brand' }])));
+  assert.equal(payload.platform, 'twitter');
+  assert.equal(payload.post_type, 'x_thread');
+  assert.deepEqual(payload.metadata.x_thread_tweets, ['one', 'two']);
+  assert.equal(payload.metadata.threads_thread_posts, undefined);
+});
+
+await check('thread_posts + explicit platform never looks up the account (unchanged request shape)', async () => {
+  const payload = await buildCreatePostPayload({
+    platform: 'threads',
+    account_id: 'acct_threads',
+    thread_posts: ['one', 'two'],
+  }, createAccountPlatformResolver(fakeClient(null)));
+  assert.equal(payload.platform, 'threads');
+  assert.equal(payload.post_type, 'threads_thread');
+});
+
+await check('thread_posts + account_id on a non-thread platform is rejected with a clear error', async () => {
+  await assert.rejects(
+    () => buildCreatePostPayload({
+      account_id: 'acct_ig',
+      thread_posts: ['one', 'two'],
+    }, createAccountPlatformResolver(fakeClient([{ id: 'acct_ig', platform: 'instagram', username: 'brand' }]))),
+    /resolved to platform "instagram"/,
+  );
+});
+
+await check('thread_posts + account_id that cannot be found is rejected with a clear error', async () => {
+  await assert.rejects(
+    () => buildCreatePostPayload({
+      account_id: 'does-not-exist',
+      thread_posts: ['one', 'two'],
+    }, createAccountPlatformResolver(fakeClient([{ id: 'acct_threads', platform: 'threads', username: 'brand' }]))),
+    /that exists in list_accounts/,
+  );
+});
+
+// The lookup itself can fail (non-2xx, missing accounts:read scope, network
+// error): the caller needs that real cause, not just a generic "pass
+// platform explicitly" that hides why resolution failed.
+await check('thread_posts + account_id surfaces the real lookup failure, not a generic message', async () => {
+  await assert.rejects(
+    () => buildCreatePostPayload({
+      account_id: 'acct_threads',
+      thread_posts: ['one', 'two'],
+    }, createAccountPlatformResolver(fakeClient(null, { fail: 'Missing required scope: accounts:read' }))),
+    /Missing required scope: accounts:read/,
+  );
+});
+
+// Batching: a batch of items sharing one workspace_id must cost one
+// accounts lookup, not one per item. create_posts_batch builds a single
+// resolver and reuses it across every buildCreatePostPayload call; this
+// pins that the resolver itself (not the caller) is what dedupes.
+await check('one resolver shared across a batch makes exactly one accounts lookup per workspace_id', async () => {
+  const client = fakeClient([
+    { id: 'acct_threads', platform: 'threads', username: 'brand' },
+    { id: 'acct_x', platform: 'twitter', username: 'brand2' },
+  ]);
+  const resolvePlatform = createAccountPlatformResolver(client);
+  const [threadsPayload, xPayload, thirdPayload] = await Promise.all([
+    buildCreatePostPayload({ account_id: 'acct_threads', workspace_id: 'ws_1', thread_posts: ['a', 'b'] }, resolvePlatform),
+    buildCreatePostPayload({ account_id: 'acct_x', workspace_id: 'ws_1', thread_posts: ['c', 'd'] }, resolvePlatform),
+    buildCreatePostPayload({ account_id: 'acct_threads', workspace_id: 'ws_1', thread_posts: ['e', 'f'] }, resolvePlatform),
+  ]);
+  assert.equal(threadsPayload.platform, 'threads');
+  assert.equal(xPayload.platform, 'twitter');
+  assert.equal(thirdPayload.platform, 'threads');
+  assert.equal(client.calls(), 1, `expected exactly one accounts lookup for one workspace_id, got ${client.calls()}`);
+});
+
 if (failures > 0) {
   console.error(`\n${failures} payload-builder test(s) failed.`);
   process.exit(1);
 }
-console.log(`\nOK  payload builders honour the server's "caption or media" rule.`);

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.awpthorp/posterly",
   "title": "posterly",
   "description": "Validate, schedule, publish, and analyze social content across 18 platforms with posterly.",
-  "version": "0.45.0",
+  "version": "0.45.1",
   "websiteUrl": "https://www.poster.ly/mcp",
   "repository": {
     "url": "https://github.com/awpthorp/posterly",
@@ -14,7 +14,7 @@
     {
       "registryType": "npm",
       "identifier": "posterly-mcp-server",
-      "version": "0.45.0",
+      "version": "0.45.1",
       "transport": {
         "type": "stdio"
       },

package/src/lib/version.ts

@@ -5,4 +5,4 @@
 // tool set (minus the intentional pre-auth signup tools that only this stdio
 // package exposes). `npm run check:mcp-parity` enforces both the version match
 // and the tool-list match, and runs in the pre-commit hook.
-export const POSTERLY_MCP_VERSION = '0.45.0';
+export const POSTERLY_MCP_VERSION = '0.45.1';

package/src/tools/create-post.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { PosterlyClient } from '../lib/api-client.js';
+import type { PosterlyClient, Account } from '../lib/api-client.js';
 import { dashboardUrlForPost, formatLocalDateTime } from '../lib/format.js';
 import { SUPPORTED_PLATFORM_INPUTS, SUPPORTED_PLATFORM_IDS } from '../generated/platform-manifest.js';
 
@@ -173,7 +173,61 @@ export const createPostInputSchema = createPostPayloadInputSchema.extend({
 export type CreatePostInput = z.infer<typeof createPostInputSchema>;
 export type CreatePostPayloadInput = z.infer<typeof createPostPayloadInputSchema>;
 
-export function buildCreatePostPayload(input: CreatePostPayloadInput | CreatePostInput): Parameters<PosterlyClient['createPost']>[0] {
+export type AccountPlatformLookup =
+  | { found: true; platform: string | null }
+  | { found: false; detail: string };
+
+export type AccountPlatformResolver = (accountId: string, workspaceId?: string) => Promise<AccountPlatformLookup>;
+
+/**
+ * Builds a resolver that answers "what platform is this account_id on?" via
+ * client.listAccounts() (there is no GET /accounts/:id), for thread_posts
+ * calls that gave account_id without platform. Caches one in-flight lookup
+ * per workspace_id (including the unscoped list, keyed ''), so
+ * create_posts_batch never issues more than one accounts request per
+ * distinct workspace_id even though every item in the batch calls this
+ * independently: the cache is populated synchronously (before the first
+ * await) on the first call for a given workspace_id, so concurrent
+ * Promise.all callers for the same workspace_id share the one in-flight
+ * request. A failed lookup (non-2xx, missing accounts:read, network error)
+ * is cached too, so it is reported once per workspace_id rather than
+ * surfacing a fresh error per item.
+ */
+export function createAccountPlatformResolver(client: PosterlyClient): AccountPlatformResolver {
+  const cache = new Map<string, Promise<{ ok: true; platforms: Map<string, string> } | { ok: false; detail: string }>>();
+  const lookupForWorkspace = (workspaceKey: string) => {
+    let pending = cache.get(workspaceKey);
+    if (!pending) {
+      pending = (async () => {
+        try {
+          const accounts: Account[] = await client.listAccounts(workspaceKey ? { workspace_id: workspaceKey } : undefined);
+          const platforms = new Map<string, string>();
+          for (const account of accounts) {
+            if (account && typeof account.platform === 'string' && account.id !== undefined && account.id !== null) {
+              platforms.set(String(account.id), account.platform);
+            }
+          }
+          return { ok: true as const, platforms };
+        } catch (error: any) {
+          return { ok: false as const, detail: error?.message || 'accounts lookup failed' };
+        }
+      })();
+      cache.set(workspaceKey, pending);
+    }
+    return pending;
+  };
+  return async (accountId, workspaceId) => {
+    const workspaceKey = workspaceId || '';
+    const lookup = await lookupForWorkspace(workspaceKey);
+    if (!lookup.ok) return { found: false, detail: lookup.detail };
+    return { found: true, platform: lookup.platforms.get(String(accountId)) ?? null };
+  };
+}
+
+export async function buildCreatePostPayload(
+  input: CreatePostPayloadInput | CreatePostInput,
+  resolvePlatform: AccountPlatformResolver,
+): Promise<Parameters<PosterlyClient['createPost']>[0]> {
   const { confirm: _confirm, thread_posts, caption, post_type, instagram_settings, platform_settings, ...rest } = input as CreatePostInput & CreatePostPayloadInput;
 
   if (thread_posts && thread_posts.length > 0) {
@@ -181,12 +235,33 @@ export function buildCreatePostPayload(input: CreatePostPayloadInput | CreatePos
       throw new Error('thread_posts must contain at least 2 entries');
     }
     const platformHint = (input.platform || '').toLowerCase();
-    const isTwitter = platformHint === 'twitter' || platformHint === 'x';
-    const isThreads = platformHint === 'threads';
-    if (!isTwitter && !isThreads && !input.account_id) {
-      throw new Error(
-        'thread_posts requires `platform` to be "twitter" or "threads", or pass `account_id` for an X/Threads account.',
-      );
+    let isTwitter = platformHint === 'twitter' || platformHint === 'x';
+    let isThreads = platformHint === 'threads';
+    if (!isTwitter && !isThreads) {
+      if (!input.account_id) {
+        throw new Error(
+          'thread_posts requires `platform` to be "twitter" or "threads", or pass `account_id` for an X/Threads account.',
+        );
+      }
+      // No platform hint: never guess X. Resolve the account's real platform
+      // first, so a Threads account_id builds a threads_thread, not an
+      // x_thread that the server then rejects.
+      const lookup = await resolvePlatform(input.account_id, input.workspace_id);
+      if (!lookup.found) {
+        throw new Error(
+          `thread_posts could not resolve account_id's platform (${lookup.detail}). Pass \`platform\` explicitly.`,
+        );
+      } else if (lookup.platform === 'threads') {
+        isThreads = true;
+      } else if (lookup.platform === 'twitter') {
+        isTwitter = true;
+      } else {
+        throw new Error(
+          lookup.platform
+            ? `thread_posts requires an X/Twitter or Threads account; account_id resolved to platform "${lookup.platform}".`
+            : 'thread_posts requires `platform` to be "twitter" or "threads", or an `account_id` that exists in list_accounts. Pass `platform` explicitly.',
+        );
+      }
     }
     const arrayKey = isThreads ? 'threads_thread_posts' : 'x_thread_tweets';
     const totalKey = isThreads ? 'threads_thread_total' : 'x_thread_total';
@@ -250,7 +325,7 @@ export const createPostTool = {
     if (input.confirm !== true) {
       throw new Error('Refusing to create post without confirm=true after explicit user confirmation.');
     }
-    const payload = buildCreatePostPayload(input);
+    const payload = await buildCreatePostPayload(input, createAccountPlatformResolver(client));
     const { thread_posts, instagram_settings, platform_settings } = input;
 
     const result = await client.createPost(payload);

package/src/tools/create-posts-batch.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import type { PosterlyClient } from '../lib/api-client.js';
 import { dashboardUrlForPostList, formatLocalDateTime } from '../lib/format.js';
-import { buildCreatePostPayload, createPostPayloadInputSchema, type CreatePostPayloadInput } from './create-post.js';
+import { buildCreatePostPayload, createAccountPlatformResolver, createPostPayloadInputSchema, type CreatePostPayloadInput } from './create-post.js';
 
 export const createPostsBatchTool = {
   name: 'create_posts_batch',
@@ -26,7 +26,18 @@ export const createPostsBatchTool = {
     if (input.confirm !== true) {
       throw new Error('Refusing to create batch posts without confirm=true after explicit user confirmation.');
     }
-    const payloads = input.posts.map((post) => buildCreatePostPayload(post));
+    // One resolver shared across the whole batch: createAccountPlatformResolver
+    // caches its accounts lookup per workspace_id, so N items that all need
+    // thread_posts platform resolution for the same workspace still cost one
+    // listAccounts() call, not N.
+    const resolvePlatform = createAccountPlatformResolver(client);
+    const payloads = await Promise.all(input.posts.map(async (post, index) => {
+      try {
+        return await buildCreatePostPayload(post, resolvePlatform);
+      } catch (error: any) {
+        throw new Error(`Item ${index}: ${error?.message || 'invalid post input'}`);
+      }
+    }));
     const result = await client.createPostsBatch({ posts: payloads });
 
     const createdPosts = result.posts.map((item) => item.post);

package/src/tools/validate-post.ts

@@ -1,6 +1,7 @@
 import type { PosterlyClient } from '../lib/api-client.js';
 import {
   buildCreatePostPayload,
+  createAccountPlatformResolver,
   createPostPayloadInputSchema,
 } from './create-post.js';
 
@@ -15,7 +16,7 @@ export const validatePostTool = {
   inputSchema: validatePostInputSchema,
 
   async execute(client: PosterlyClient, input: ValidatePostInput) {
-    const payload = buildCreatePostPayload(input);
+    const payload = await buildCreatePostPayload(input, createAccountPlatformResolver(client));
     const result = await client.validatePost(payload);
 
     const lines = [