@xpoz/xpoz 0.6.13 → 0.8.0

package/dist/index.js

@@ -248,7 +248,7 @@ function coerce(value) {
 }
 
 // src/version.ts
-var VERSION = "0.6.13";
+var VERSION = "0.8.0";
 
 // src/mcp/transport.ts
 var USER_AGENT = `xpoz-ts-sdk/${VERSION}`;
@@ -401,6 +401,11 @@ var DEFAULT_TIMEOUT_MS = 3e5;
 var DEFAULT_API_URL = "https://api.xpoz.ai";
 var ENV_API_URL = "XPOZ_API_URL";
 var INSTAGRAM_BASE = "/api/data/instagram";
+var TWITTER_BASE = "/api/data/twitter";
+var INSTAGRAM_ROUTES = {
+  user: (identifier) => `${INSTAGRAM_BASE}/users/${encodeURIComponent(identifier)}`,
+  postsByIds: `${INSTAGRAM_BASE}/posts/ids`
+};
 var INSTAGRAM_LIVE_ROUTES = {
   posts: `${INSTAGRAM_BASE}/posts/live`,
   userPosts: (identifier) => `${INSTAGRAM_BASE}/posts/users/${encodeURIComponent(identifier)}/live`,
@@ -411,6 +416,20 @@ var INSTAGRAM_LIVE_ROUTES = {
   user: (identifier) => `${INSTAGRAM_BASE}/users/${encodeURIComponent(identifier)}/live`,
   userConnections: (identifier) => `${INSTAGRAM_BASE}/users/${encodeURIComponent(identifier)}/connections/live`
 };
+var TWITTER_ROUTES = {
+  posts: `${TWITTER_BASE}/posts`
+};
+var TWITTER_LIVE_ROUTES = {
+  posts: `${TWITTER_BASE}/posts/live`,
+  userPosts: (username) => `${TWITTER_BASE}/posts/users/${encodeURIComponent(username)}/live`,
+  post: (postId) => `${TWITTER_BASE}/posts/${encodeURIComponent(postId)}/live`,
+  postComments: (postId) => `${TWITTER_BASE}/posts/${encodeURIComponent(postId)}/comments/live`,
+  postQuotes: (postId) => `${TWITTER_BASE}/posts/${encodeURIComponent(postId)}/quotes/live`,
+  postInteractingUsers: (postId) => `${TWITTER_BASE}/posts/${encodeURIComponent(postId)}/interacting-users/live`,
+  users: `${TWITTER_BASE}/users/live`,
+  user: (username) => `${TWITTER_BASE}/users/${encodeURIComponent(username)}/live`,
+  userConnections: (username) => `${TWITTER_BASE}/users/${encodeURIComponent(username)}/connections/live`
+};
 var REST_TIMEOUT_MS = 12e4;
 
 // src/rest/transport.ts
@@ -523,8 +542,16 @@ var CursorResult = class {
   }
 };
 
-// src/namespaces/instagramLive.ts
-var STRING_ID_FIELDS = ["id", "userId", "user_id", "postId", "post_id"];
+// src/namespaces/liveBase.ts
+var STRING_ID_FIELDS = [
+  "id",
+  "userId",
+  "user_id",
+  "postId",
+  "post_id",
+  "authorId",
+  "author_id"
+];
 function coerceStringIds(item) {
   const record = item;
   for (const field of STRING_ID_FIELDS) {
@@ -537,7 +564,7 @@ function coerceStringIds(item) {
 function csvFields(fields) {
   return fields && fields.length > 0 ? fields.join(",") : void 0;
 }
-var InstagramLiveNamespace = class {
+var LiveNamespace = class {
   transport;
   constructor(transport) {
     this.transport = transport;
@@ -555,6 +582,10 @@ var InstagramLiveNamespace = class {
     const page = await this.page(path, params);
     return page.data[0] ?? null;
   }
+};
+
+// src/namespaces/instagramLive.ts
+var InstagramLiveNamespace = class extends LiveNamespace {
   async searchPosts(query, options = {}) {
     return this.page(INSTAGRAM_LIVE_ROUTES.posts, {
       q: query,
@@ -607,6 +638,73 @@ var InstagramLiveNamespace = class {
   }
 };
 
+// src/namespaces/twitterLive.ts
+var TwitterLiveNamespace = class extends LiveNamespace {
+  async searchPosts(query, options = {}) {
+    return this.page(TWITTER_LIVE_ROUTES.posts, {
+      q: query,
+      since: options.since,
+      until: options.until,
+      lang: options.lang,
+      countryCode: options.countryCode,
+      sortBy: options.sortBy,
+      fields: csvFields(options.fields),
+      cursor: options.cursor
+    });
+  }
+  async getPostsByUser(username, options = {}) {
+    return this.page(TWITTER_LIVE_ROUTES.userPosts(username), {
+      since: options.since,
+      until: options.until,
+      fields: csvFields(options.fields),
+      cursor: options.cursor
+    });
+  }
+  async getPost(postId, options = {}) {
+    return this.single(TWITTER_LIVE_ROUTES.post(postId), {
+      fields: csvFields(options.fields)
+    });
+  }
+  async getComments(postId, options = {}) {
+    return this.page(TWITTER_LIVE_ROUTES.postComments(postId), {
+      fields: csvFields(options.fields),
+      cursor: options.cursor
+    });
+  }
+  async getQuotes(postId, options = {}) {
+    return this.page(TWITTER_LIVE_ROUTES.postQuotes(postId), {
+      fields: csvFields(options.fields),
+      cursor: options.cursor
+    });
+  }
+  async getPostInteractingUsers(postId, interactionType, options = {}) {
+    return this.page(TWITTER_LIVE_ROUTES.postInteractingUsers(postId), {
+      interactionType,
+      fields: csvFields(options.fields),
+      cursor: options.cursor
+    });
+  }
+  async searchUsers(query, options = {}) {
+    return this.page(TWITTER_LIVE_ROUTES.users, {
+      q: query,
+      fields: csvFields(options.fields),
+      cursor: options.cursor
+    });
+  }
+  async getUser(username, options = {}) {
+    return this.single(TWITTER_LIVE_ROUTES.user(username), {
+      fields: csvFields(options.fields)
+    });
+  }
+  async getUserConnections(username, connectionType, options = {}) {
+    return this.page(TWITTER_LIVE_ROUTES.userConnections(username), {
+      connectionType,
+      fields: csvFields(options.fields),
+      cursor: options.cursor
+    });
+  }
+};
+
 // src/mcp/polling.ts
 async function waitForResult(callTool, operationId, timeoutMs = DEFAULT_TIMEOUT_MS) {
   const start = Date.now();
@@ -768,28 +866,36 @@ var BaseNamespace = class {
   }
 };
 
+// src/concurrency.ts
+var DEFAULT_CONCURRENCY = 10;
+async function parallelMap(items, fn, concurrency = DEFAULT_CONCURRENCY) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      results[index] = await fn(items[index]);
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}
+
 // src/config/tools.ts
-var GET_TWITTER_POSTS_BY_IDS = "getTwitterPostsByIds";
 var GET_TWITTER_POSTS_BY_AUTHOR = "getTwitterPostsByAuthor";
 var SEARCH_TWITTER_POSTS = "getTwitterPostsByKeywords";
 var GET_TWITTER_RETWEETS = "getTwitterPostRetweets";
-var GET_TWITTER_QUOTES = "getTwitterPostQuotes";
-var GET_TWITTER_COMMENTS = "getTwitterPostComments";
-var GET_TWITTER_POST_INTERACTING_USERS = "getTwitterPostInteractingUsers";
 var COUNT_TWEETS = "countTweets";
 var GET_TWITTER_USER = "getTwitterUser";
 var GET_TWITTER_USERS = "getTwitterUsers";
-var SEARCH_TWITTER_USERS = "searchTwitterUsers";
 var GET_TWITTER_USER_CONNECTIONS = "getTwitterUserConnections";
 var GET_TWITTER_USERS_BY_KEYWORDS = "getTwitterUsersByKeywords";
-var GET_INSTAGRAM_POSTS_BY_IDS = "getInstagramPostsByIds";
 var GET_INSTAGRAM_POSTS_BY_USER = "getInstagramPostsByUser";
 var SEARCH_INSTAGRAM_POSTS = "getInstagramPostsByKeywords";
-var GET_INSTAGRAM_COMMENTS = "getInstagramCommentsByPostId";
-var GET_INSTAGRAM_USER = "getInstagramUser";
-var SEARCH_INSTAGRAM_USERS = "searchInstagramUsers";
-var GET_INSTAGRAM_USER_CONNECTIONS = "getInstagramUserConnections";
-var GET_INSTAGRAM_POST_INTERACTING_USERS = "getInstagramPostInteractingUsers";
 var GET_INSTAGRAM_USERS_BY_KEYWORDS = "getInstagramUsersByKeywords";
 var SEARCH_REDDIT_POSTS = "getRedditPostsByKeywords";
 var GET_REDDIT_POST_WITH_COMMENTS = "getRedditPostWithCommentsById";
@@ -826,33 +932,79 @@ function parseUser(item) {
   return item;
 }
 var TwitterNamespace = class extends BaseNamespace {
+  rest;
+  constructor(callTool, timeoutMs, restTransport) {
+    super(callTool, timeoutMs);
+    this.rest = restTransport;
+  }
+  cursorToPaginatedResult(response, fetchNext, pageNumber = 1) {
+    const items = response.results ?? [];
+    const hasMore = Boolean(response.has_more);
+    const nextCursor = response.next_page_cursor ?? null;
+    const pagination = {
+      tableName: null,
+      totalRows: 0,
+      totalPages: hasMore ? pageNumber + 1 : pageNumber,
+      pageNumber,
+      pageSize: items.length,
+      resultsCount: items.length
+    };
+    const fetchPage = async () => {
+      if (!nextCursor) {
+        throw new RangeError("No more pages available");
+      }
+      const nextResponse = await fetchNext(nextCursor);
+      return this.cursorToPaginatedResult(nextResponse, fetchNext, pageNumber + 1);
+    };
+    return new PaginatedResult({
+      data: items,
+      pagination,
+      tableName: null,
+      exportOperationId: null,
+      fetchPage: () => fetchPage(),
+      fetchExport: null
+    });
+  }
   async getPostsByIds(postIds, options = {}) {
-    const args = this.buildArgs({ postIds, ...options });
-    const result = await this.callAndMaybePoll(
-      GET_TWITTER_POSTS_BY_IDS,
-      args
-    );
-    return (result["results"] ?? []).map(parseTwitterPost);
+    const fieldsCsv = csvFields(options.fields);
+    const results = await parallelMap(postIds, async (postId) => {
+      const response = await this.rest.get(
+        TWITTER_LIVE_ROUTES.post(postId),
+        { fields: fieldsCsv }
+      );
+      return (response.results ?? [])[0] ?? null;
+    });
+    return results.filter((post) => post !== null);
   }
   async getPostsByAuthor(identifier, options = {}) {
-    const args = this.buildArgs({
-      username: identifier,
-      fields: options.fields,
-      startDate: options.startDate,
-      endDate: options.endDate,
-      forceLatest: options.forceLatest,
-      responseType: options.responseType,
-      limit: options.limit
-    });
-    const result = await this.callAndMaybePoll(
-      GET_TWITTER_POSTS_BY_AUTHOR,
-      args
+    if (options.responseType === "csv" /* Csv */) {
+      const args = this.buildArgs({
+        username: identifier,
+        fields: options.fields,
+        startDate: options.startDate,
+        endDate: options.endDate,
+        forceLatest: options.forceLatest,
+        responseType: options.responseType,
+        limit: options.limit
+      });
+      const result = await this.callAndMaybePoll(GET_TWITTER_POSTS_BY_AUTHOR, args);
+      return this.buildPaginatedResult(result, parseTwitterPost, GET_TWITTER_POSTS_BY_AUTHOR, args);
+    }
+    const params = {
+      since: options.startDate,
+      until: options.endDate,
+      fields: csvFields(options.fields)
+    };
+    const response = await this.rest.get(
+      TWITTER_LIVE_ROUTES.userPosts(identifier),
+      params
     );
-    return this.buildPaginatedResult(
-      result,
-      parseTwitterPost,
-      GET_TWITTER_POSTS_BY_AUTHOR,
-      args
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        TWITTER_LIVE_ROUTES.userPosts(identifier),
+        { ...params, cursor }
+      )
     );
   }
   async searchPosts(query, options = {}) {
@@ -908,39 +1060,48 @@ var TwitterNamespace = class extends BaseNamespace {
     );
   }
   async getQuotes(postId, options = {}) {
-    const args = this.buildArgs({ postId, ...options });
-    const result = await this.callAndMaybePoll(GET_TWITTER_QUOTES, args);
-    return this.buildPaginatedResult(
-      result,
-      parseTwitterPost,
-      GET_TWITTER_QUOTES,
-      args
+    const params = { fields: csvFields(options.fields) };
+    const response = await this.rest.get(
+      TWITTER_LIVE_ROUTES.postQuotes(postId),
+      params
+    );
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        TWITTER_LIVE_ROUTES.postQuotes(postId),
+        { ...params, cursor }
+      )
     );
   }
   async getComments(postId, options = {}) {
-    const args = this.buildArgs({ postId, ...options });
-    const result = await this.callAndMaybePoll(
-      GET_TWITTER_COMMENTS,
-      args
+    const params = { fields: csvFields(options.fields) };
+    const response = await this.rest.get(
+      TWITTER_LIVE_ROUTES.postComments(postId),
+      params
     );
-    return this.buildPaginatedResult(
-      result,
-      parseTwitterPost,
-      GET_TWITTER_COMMENTS,
-      args
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        TWITTER_LIVE_ROUTES.postComments(postId),
+        { ...params, cursor }
+      )
     );
   }
   async getPostInteractingUsers(postId, interactionType, options = {}) {
-    const args = this.buildArgs({ postId, interactionType, ...options });
-    const result = await this.callAndMaybePoll(
-      GET_TWITTER_POST_INTERACTING_USERS,
-      args
+    const params = {
+      interactionType,
+      fields: csvFields(options.fields)
+    };
+    const response = await this.rest.get(
+      TWITTER_LIVE_ROUTES.postInteractingUsers(postId),
+      params
     );
-    return this.buildPaginatedResult(
-      result,
-      parseUser,
-      GET_TWITTER_POST_INTERACTING_USERS,
-      args
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        TWITTER_LIVE_ROUTES.postInteractingUsers(postId),
+        { ...params, cursor }
+      )
     );
   }
   async countPosts(phrase, options = {}) {
@@ -958,48 +1119,81 @@ var TwitterNamespace = class extends BaseNamespace {
     return Number(count);
   }
   async getUsers(identifiers, options = {}) {
-    const args = this.buildArgs({
-      identifiers,
-      identifierType: options.identifierType ?? "username",
-      fields: options.fields,
-      forceLatest: options.forceLatest
+    if ((options.identifierType ?? "username") === "id") {
+      const args = this.buildArgs({
+        identifiers,
+        identifierType: "id",
+        fields: options.fields,
+        forceLatest: options.forceLatest
+      });
+      const result = await this.callAndMaybePoll(GET_TWITTER_USERS, args);
+      return (result["results"] ?? []).map(parseUser);
+    }
+    const fieldsCsv = csvFields(options.fields);
+    const results = await parallelMap(identifiers, async (username) => {
+      const response = await this.rest.get(
+        TWITTER_LIVE_ROUTES.user(username),
+        { fields: fieldsCsv }
+      );
+      return (response.results ?? [])[0] ?? null;
     });
-    const result = await this.callAndMaybePoll(GET_TWITTER_USERS, args);
-    return (result["results"] ?? []).map(parseUser);
+    return results.filter((user) => user !== null);
   }
   async getUser(identifier, options = {}) {
-    const args = this.buildArgs({
-      identifier,
-      identifierType: options.identifierType ?? "username",
-      fields: options.fields,
-      forceLatest: options.forceLatest
-    });
-    const result = await this.callAndMaybePoll(GET_TWITTER_USER, args);
-    const results = result["results"];
-    if (Array.isArray(results) && results.length > 0) {
-      return results[0];
+    if ((options.identifierType ?? "username") === "id") {
+      const args = this.buildArgs({
+        identifier,
+        identifierType: "id",
+        fields: options.fields,
+        forceLatest: options.forceLatest
+      });
+      const result = await this.callAndMaybePoll(GET_TWITTER_USER, args);
+      const results = result["results"];
+      if (Array.isArray(results) && results.length > 0) {
+        return results[0];
+      }
+      return result;
     }
-    return result;
+    const response = await this.rest.get(
+      TWITTER_LIVE_ROUTES.user(identifier),
+      { fields: csvFields(options.fields) }
+    );
+    if (response.results && response.results.length > 0) {
+      return response.results[0];
+    }
+    throw new Error(`User not found: ${identifier}`);
   }
   async searchUsers(name, options = {}) {
-    const args = this.buildArgs({ name, ...options });
-    const result = await this.callAndMaybePoll(
-      SEARCH_TWITTER_USERS,
-      args
+    const response = await this.rest.get(
+      TWITTER_LIVE_ROUTES.users,
+      { q: name, fields: csvFields(options.fields) }
     );
-    return (result["results"] ?? []).map(parseUser);
+    const users = response.results ?? [];
+    if (options.limit && options.limit > 0) {
+      return users.slice(0, options.limit);
+    }
+    return users;
   }
   async getUserConnections(username, connectionType, options = {}) {
-    const args = this.buildArgs({ username, connectionType, ...options });
-    const result = await this.callAndMaybePoll(
-      GET_TWITTER_USER_CONNECTIONS,
-      args
+    if (options.responseType === "csv" /* Csv */) {
+      const args = this.buildArgs({ username, connectionType, ...options });
+      const result = await this.callAndMaybePoll(GET_TWITTER_USER_CONNECTIONS, args);
+      return this.buildPaginatedResult(result, parseUser, GET_TWITTER_USER_CONNECTIONS, args);
+    }
+    const params = {
+      connectionType,
+      fields: csvFields(options.fields)
+    };
+    const response = await this.rest.get(
+      TWITTER_LIVE_ROUTES.userConnections(username),
+      params
     );
-    return this.buildPaginatedResult(
-      result,
-      parseUser,
-      GET_TWITTER_USER_CONNECTIONS,
-      args
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        TWITTER_LIVE_ROUTES.userConnections(username),
+        { ...params, cursor }
+      )
     );
   }
   async getUsersByKeywords(query, options = {}) {
@@ -1024,92 +1218,187 @@ function parsePost(item) {
 function parseUser2(item) {
   return item;
 }
-function parseComment(item) {
-  return item;
-}
 var InstagramNamespace = class extends BaseNamespace {
+  rest;
+  constructor(callTool, timeoutMs, restTransport) {
+    super(callTool, timeoutMs);
+    this.rest = restTransport;
+  }
+  cursorToPaginatedResult(response, fetchNext, pageNumber = 1) {
+    const items = response.results ?? [];
+    const hasMore = Boolean(response.has_more);
+    const nextCursor = response.next_page_cursor ?? null;
+    const pagination = {
+      tableName: null,
+      totalRows: 0,
+      totalPages: hasMore ? pageNumber + 1 : pageNumber,
+      pageNumber,
+      pageSize: items.length,
+      resultsCount: items.length
+    };
+    const fetchPage = async () => {
+      if (!nextCursor) {
+        throw new RangeError("No more pages available");
+      }
+      const nextResponse = await fetchNext(nextCursor);
+      return this.cursorToPaginatedResult(nextResponse, fetchNext, pageNumber + 1);
+    };
+    return new PaginatedResult({
+      data: items,
+      pagination,
+      tableName: null,
+      exportOperationId: null,
+      fetchPage: () => fetchPage(),
+      fetchExport: null
+    });
+  }
   async getPostsByIds(postIds, options = {}) {
-    const args = this.buildArgs({ postIds, ...options });
-    const result = await this.callAndMaybePoll(GET_INSTAGRAM_POSTS_BY_IDS, args);
-    return (result["results"] ?? []).map(parsePost);
+    const fieldsCsv = csvFields(options.fields);
+    const results = await parallelMap(postIds, async (postId) => {
+      const response = await this.rest.get(
+        INSTAGRAM_LIVE_ROUTES.post(postId),
+        { fields: fieldsCsv }
+      );
+      return (response.results ?? [])[0] ?? null;
+    });
+    return results.filter((post) => post !== null);
   }
   async getPostsByUser(identifier, options = {}) {
-    const args = this.buildArgs({
-      identifier,
-      identifierType: options.identifierType ?? "username",
-      fields: options.fields,
-      startDate: options.startDate,
-      endDate: options.endDate,
-      forceLatest: options.forceLatest,
-      responseType: options.responseType,
-      limit: options.limit
-    });
-    const result = await this.callAndMaybePoll(GET_INSTAGRAM_POSTS_BY_USER, args);
-    return this.buildPaginatedResult(
-      result,
-      parsePost,
-      GET_INSTAGRAM_POSTS_BY_USER,
-      args
+    if (options.responseType === "csv" /* Csv */) {
+      const args = this.buildArgs({
+        identifier,
+        identifierType: options.identifierType ?? "username",
+        fields: options.fields,
+        startDate: options.startDate,
+        endDate: options.endDate,
+        forceLatest: options.forceLatest,
+        responseType: options.responseType,
+        limit: options.limit
+      });
+      const result = await this.callAndMaybePoll(GET_INSTAGRAM_POSTS_BY_USER, args);
+      return this.buildPaginatedResult(result, parsePost, GET_INSTAGRAM_POSTS_BY_USER, args);
+    }
+    const params = {
+      fields: csvFields(options.fields)
+    };
+    const response = await this.rest.get(
+      INSTAGRAM_LIVE_ROUTES.userPosts(identifier),
+      params
+    );
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        INSTAGRAM_LIVE_ROUTES.userPosts(identifier),
+        { ...params, cursor }
+      )
     );
   }
   async searchPosts(query, options = {}) {
-    const args = this.buildArgs({
-      query,
-      fields: options.fields,
-      startDate: options.startDate,
-      endDate: options.endDate,
-      forceLatest: options.forceLatest,
-      responseType: options.responseType,
-      limit: options.limit
-    });
-    const result = await this.callAndMaybePoll(SEARCH_INSTAGRAM_POSTS, args);
-    return this.buildPaginatedResult(result, parsePost, SEARCH_INSTAGRAM_POSTS, args);
+    if (options.responseType === "csv" /* Csv */) {
+      const args = this.buildArgs({
+        query,
+        fields: options.fields,
+        startDate: options.startDate,
+        endDate: options.endDate,
+        forceLatest: options.forceLatest,
+        responseType: options.responseType,
+        limit: options.limit
+      });
+      const result = await this.callAndMaybePoll(SEARCH_INSTAGRAM_POSTS, args);
+      return this.buildPaginatedResult(result, parsePost, SEARCH_INSTAGRAM_POSTS, args);
+    }
+    const params = {
+      q: query,
+      fields: csvFields(options.fields)
+    };
+    const response = await this.rest.get(
+      INSTAGRAM_LIVE_ROUTES.posts,
+      params
+    );
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        INSTAGRAM_LIVE_ROUTES.posts,
+        { ...params, cursor }
+      )
+    );
   }
   async getComments(postId, options = {}) {
-    const args = this.buildArgs({ postId, ...options });
-    const result = await this.callAndMaybePoll(GET_INSTAGRAM_COMMENTS, args);
-    return this.buildPaginatedResult(result, parseComment, GET_INSTAGRAM_COMMENTS, args);
+    const params = {
+      fields: csvFields(options.fields)
+    };
+    const response = await this.rest.get(
+      INSTAGRAM_LIVE_ROUTES.postComments(postId),
+      params
+    );
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        INSTAGRAM_LIVE_ROUTES.postComments(postId),
+        { ...params, cursor }
+      )
+    );
   }
   async getUser(identifier, options = {}) {
-    const args = this.buildArgs({
-      identifier,
-      identifierType: options.identifierType ?? "username",
-      fields: options.fields,
-      forceLatest: options.forceLatest
-    });
-    const result = await this.callAndMaybePoll(GET_INSTAGRAM_USER, args);
-    const results = result["results"];
-    if (Array.isArray(results) && results.length > 0) {
-      return results[0];
+    const response = await this.rest.get(
+      INSTAGRAM_ROUTES.user(identifier),
+      {
+        identifierType: options.identifierType ?? "username",
+        fields: csvFields(options.fields),
+        forceLatest: true
+      }
+    );
+    if (response.results.length > 0) {
+      return response.results[0];
     }
-    return result;
+    throw new Error(`User not found: ${identifier}`);
   }
   async searchUsers(name, options = {}) {
-    const args = this.buildArgs({ name, ...options });
-    const result = await this.callAndMaybePoll(SEARCH_INSTAGRAM_USERS, args);
-    return (result["results"] ?? []).map(parseUser2);
+    const response = await this.rest.get(
+      INSTAGRAM_LIVE_ROUTES.users,
+      {
+        name,
+        fields: csvFields(options.fields)
+      }
+    );
+    const users = response.results ?? [];
+    if (options.limit && options.limit > 0) {
+      return users.slice(0, options.limit);
+    }
+    return users;
   }
   async getUserConnections(username, connectionType, options = {}) {
-    const args = this.buildArgs({ username, connectionType, ...options });
-    const result = await this.callAndMaybePoll(GET_INSTAGRAM_USER_CONNECTIONS, args);
-    return this.buildPaginatedResult(
-      result,
-      parseUser2,
-      GET_INSTAGRAM_USER_CONNECTIONS,
-      args
+    const params = {
+      connectionType,
+      fields: csvFields(options.fields)
+    };
+    const response = await this.rest.get(
+      INSTAGRAM_LIVE_ROUTES.userConnections(username),
+      params
+    );
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        INSTAGRAM_LIVE_ROUTES.userConnections(username),
+        { ...params, cursor }
+      )
     );
   }
   async getPostInteractingUsers(postId, interactionType, options = {}) {
-    const args = this.buildArgs({ postId, interactionType, ...options });
-    const result = await this.callAndMaybePoll(
-      GET_INSTAGRAM_POST_INTERACTING_USERS,
-      args
+    const params = {
+      interactionType,
+      fields: csvFields(options.fields)
+    };
+    const response = await this.rest.get(
+      INSTAGRAM_LIVE_ROUTES.postInteractingUsers(postId),
+      params
     );
-    return this.buildPaginatedResult(
-      result,
-      parseUser2,
-      GET_INSTAGRAM_POST_INTERACTING_USERS,
-      args
+    return this.cursorToPaginatedResult(
+      response,
+      (cursor) => this.rest.get(
+        INSTAGRAM_LIVE_ROUTES.postInteractingUsers(postId),
+        { ...params, cursor }
+      )
     );
   }
   async getUsersByKeywords(query, options = {}) {
@@ -1131,7 +1420,7 @@ function parsePost2(item) {
 function parseUser3(item) {
   return item;
 }
-function parseComment2(item) {
+function parseComment(item) {
   return item;
 }
 function parseSubreddit(item) {
@@ -1151,7 +1440,7 @@ var RedditNamespace = class extends BaseNamespace {
   async searchComments(query, options = {}) {
     const args = this.buildArgs({ query, ...options });
     const result = await this.callAndMaybePoll(SEARCH_REDDIT_COMMENTS, args);
-    return this.buildPaginatedResult(result, parseComment2, SEARCH_REDDIT_COMMENTS, args);
+    return this.buildPaginatedResult(result, parseComment, SEARCH_REDDIT_COMMENTS, args);
   }
   async getCommentById(commentId, options = {}) {
     const args = this.buildArgs({ commentId, ...options });
@@ -1216,7 +1505,7 @@ var RedditNamespace = class extends BaseNamespace {
     const pagination = this.extractPagination(raw);
     return {
       post: postData,
-      comments: commentsData.map(parseComment2),
+      comments: commentsData.map(parseComment),
       commentsPagination: pagination.totalPages > 0 ? pagination : null,
       commentsTableName: pagination.tableName ?? null
     };
@@ -1245,7 +1534,7 @@ function parsePost3(item) {
 function parseUser4(item) {
   return item;
 }
-function parseComment3(item) {
+function parseComment2(item) {
   return item;
 }
 function parseSound(item) {
@@ -1292,7 +1581,7 @@ var TiktokNamespace = class extends BaseNamespace {
   async getComments(postId, options = {}) {
     const args = this.buildArgs({ postId, ...options });
     const result = await this.callAndMaybePoll(GET_TIKTOK_COMMENTS, args);
-    return this.buildPaginatedResult(result, parseComment3, GET_TIKTOK_COMMENTS, args);
+    return this.buildPaginatedResult(result, parseComment2, GET_TIKTOK_COMMENTS, args);
   }
   async getUser(identifier, options = {}) {
     const args = this.buildArgs({
@@ -1438,6 +1727,7 @@ var XpozClient = class {
   versionCheck;
   restTransport;
   instagramLiveNamespace;
+  twitterLiveNamespace;
   constructor(options = {}) {
     const apiKey = options.apiKey ?? process.env[ENV_API_KEY];
     if (!apiKey) {
@@ -1452,8 +1742,8 @@ var XpozClient = class {
     const apiUrl = options.apiUrl ?? process.env[ENV_API_URL] ?? DEFAULT_API_URL;
     this.restTransport = new RestTransport(apiUrl, apiKey);
     const callTool = this.transport.callTool.bind(this.transport);
-    this.twitter = new TwitterNamespace(callTool, timeoutMs);
-    this.instagram = new InstagramNamespace(callTool, timeoutMs);
+    this.twitter = new TwitterNamespace(callTool, timeoutMs, this.restTransport);
+    this.instagram = new InstagramNamespace(callTool, timeoutMs, this.restTransport);
     this.reddit = new RedditNamespace(callTool, timeoutMs);
     this.tiktok = new TiktokNamespace(callTool, timeoutMs);
     this.tracking = new TrackingNamespace(callTool, timeoutMs);
@@ -1465,6 +1755,12 @@ var XpozClient = class {
     }
     return this.instagramLiveNamespace;
   }
+  get twitterLive() {
+    if (!this.twitterLiveNamespace) {
+      this.twitterLiveNamespace = new TwitterLiveNamespace(this.restTransport);
+    }
+    return this.twitterLiveNamespace;
+  }
   async connect() {
     await this.transport.connect();
     if (this.versionCheck) {