@xpoz/xpoz 0.1.0

package/dist/index.js

@@ -0,0 +1,914 @@
+// src/mcp/transport.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/transform/responseParser.ts
+function parseResponseText(text) {
+  if (!text.trim()) return {};
+  if (text.trimStart().startsWith("{")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+    }
+  }
+  const lines = text.split("\n");
+  if (lines[0].startsWith("operationId:")) {
+    return parseFlatKv(lines);
+  }
+  const result = {};
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim()) {
+      i++;
+      continue;
+    }
+    const arrayMatch = line.match(/^data\[(\d+)\]\{(.+)\}:/);
+    if (arrayMatch) {
+      const fields = arrayMatch[2].split(",").map((f) => f.trim());
+      i++;
+      result["results"] = parseCsvRows(lines, i, 2, fields);
+      i += countIndented(lines, i, 2);
+      continue;
+    }
+    const yamlListMatch = line.match(/^data\[(\d+)\]:/);
+    if (yamlListMatch) {
+      i++;
+      result["results"] = parseYamlList(lines, i, 2);
+      i += countIndented(lines, i, 2);
+      continue;
+    }
+    if (line === "data:") {
+      i++;
+      const [data, consumed] = parseDataBlock(lines, i);
+      Object.assign(result, data);
+      i += consumed;
+      continue;
+    }
+    if (line.startsWith("success:")) {
+      i++;
+      continue;
+    }
+    const kvMatch = line.match(/^(\S+?):\s*(.*)/);
+    if (kvMatch) {
+      result[kvMatch[1]] = coerce(kvMatch[2]);
+    }
+    i++;
+  }
+  return result;
+}
+function parseFlatKv(lines) {
+  const result = {};
+  for (const line of lines) {
+    const m = line.match(/^(\S+?):\s*(.*)/);
+    if (m) {
+      result[m[1]] = coerce(m[2]);
+    }
+  }
+  return result;
+}
+function parseDataBlock(lines, start) {
+  return parseBlock(lines, start, 2);
+}
+function parseBlock(lines, start, indent) {
+  const result = {};
+  const prefix = " ".repeat(indent);
+  let i = start;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.startsWith(prefix)) break;
+    if (line.length > prefix.length && line[prefix.length] === " ") break;
+    const stripped = line.slice(indent);
+    const arrayMatch = stripped.match(/^(\w+)\[(\d+)\]\{(.+)\}:/);
+    if (arrayMatch) {
+      const key = arrayMatch[1];
+      const fields = arrayMatch[3].split(",").map((f) => f.trim());
+      i++;
+      result[key] = parseCsvRows(lines, i, indent + 2, fields);
+      i += countIndented(lines, i, indent + 2);
+      continue;
+    }
+    const yamlListMatch = stripped.match(/^(\w+)\[(\d+)\]:/);
+    if (yamlListMatch) {
+      const key = yamlListMatch[1];
+      i++;
+      result[key] = parseYamlList(lines, i, indent + 2);
+      i += countIndented(lines, i, indent + 2);
+      continue;
+    }
+    const kvMatch = stripped.match(/^(\S+?):\s*(.*)/);
+    if (kvMatch) {
+      const key = kvMatch[1];
+      const val = kvMatch[2];
+      if (val) {
+        result[key] = coerce(val);
+        i++;
+      } else {
+        const childPrefix = " ".repeat(indent + 2);
+        if (i + 1 < lines.length && lines[i + 1].startsWith(childPrefix)) {
+          i++;
+          const [nested, consumed] = parseBlock(lines, i, indent + 2);
+          result[key] = nested;
+          i += consumed;
+        } else {
+          result[key] = null;
+          i++;
+        }
+      }
+      continue;
+    }
+    i++;
+  }
+  return [result, i - start];
+}
+function parseYamlList(lines, start, indent) {
+  const rows = [];
+  const prefix = " ".repeat(indent);
+  const itemPrefix = prefix + "- ";
+  const continuationPrefix = prefix + "  ";
+  let i = start;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.startsWith(prefix)) break;
+    if (!line.trim()) {
+      i++;
+      continue;
+    }
+    if (line.startsWith(itemPrefix)) {
+      const row = {};
+      const firstKv = line.slice(itemPrefix.length);
+      const m = firstKv.match(/^(\S+?):\s*(.*)/);
+      if (m) {
+        row[m[1]] = coerce(m[2]);
+      }
+      i++;
+      while (i < lines.length) {
+        const cline = lines[i];
+        if (!cline.startsWith(continuationPrefix)) break;
+        if (cline.startsWith(itemPrefix)) break;
+        const stripped = cline.slice(continuationPrefix.length);
+        const cm = stripped.match(/^(\S+?):\s*(.*)/);
+        if (cm) {
+          row[cm[1]] = coerce(cm[2]);
+        }
+        i++;
+      }
+      rows.push(row);
+    } else {
+      i++;
+    }
+  }
+  return rows;
+}
+function parseCsvRows(lines, start, indent, fields) {
+  const rows = [];
+  const prefix = " ".repeat(indent);
+  let i = start;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.startsWith(prefix)) break;
+    const rawRow = line.slice(indent);
+    if (!rawRow.trim()) {
+      i++;
+      continue;
+    }
+    const values = splitToonRow(rawRow);
+    const row = {};
+    for (let j = 0; j < fields.length; j++) {
+      row[fields[j]] = j < values.length ? coerce(values[j]) : null;
+    }
+    rows.push(row);
+    i++;
+  }
+  return rows;
+}
+function splitToonRow(line) {
+  const values = [];
+  let buf = "";
+  let inQuotes = false;
+  let i = 0;
+  while (i < line.length) {
+    const ch = line[i];
+    if (ch === "\\" && inQuotes && i + 1 < line.length) {
+      buf += ch + line[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      buf += ch;
+      i++;
+      continue;
+    }
+    if (ch === "," && !inQuotes) {
+      values.push(buf.trim());
+      buf = "";
+      i++;
+      continue;
+    }
+    buf += ch;
+    i++;
+  }
+  if (buf || values.length) {
+    values.push(buf.trim());
+  }
+  return values;
+}
+function countIndented(lines, start, indent) {
+  const prefix = " ".repeat(indent);
+  let count = 0;
+  let i = start;
+  while (i < lines.length) {
+    if (!lines[i].startsWith(prefix) && lines[i].trim()) break;
+    count++;
+    i++;
+  }
+  return count;
+}
+function coerce(value) {
+  if (!value) return null;
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null" || value === "None") return null;
+  const intVal = parseInt(value, 10);
+  if (!isNaN(intVal) && String(intVal) === value) {
+    if (intVal >= -9007199254740991 && intVal <= 9007199254740991) {
+      return intVal;
+    }
+    return value;
+  }
+  const floatVal = parseFloat(value);
+  if (!isNaN(floatVal) && String(floatVal) === value) {
+    return floatVal;
+  }
+  return value;
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/mcp/transport.ts
+var USER_AGENT = `xpoz-ts-sdk/${VERSION}`;
+var McpTransport = class {
+  serverUrl;
+  apiKey;
+  client = null;
+  transport = null;
+  constructor(serverUrl, apiKey) {
+    this.serverUrl = serverUrl;
+    this.apiKey = apiKey;
+  }
+  async connect() {
+    const headers = {
+      "User-Agent": USER_AGENT,
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    this.transport = new StreamableHTTPClientTransport(new URL(this.serverUrl), {
+      requestInit: { headers }
+    });
+    this.client = new Client(
+      { name: "xpoz-ts-sdk", version: VERSION },
+      { capabilities: {} }
+    );
+    await this.client.connect(this.transport);
+  }
+  async close() {
+    if (this.client) {
+      try {
+        await this.client.close();
+      } catch {
+      }
+      this.client = null;
+      this.transport = null;
+    }
+  }
+  async callTool(name, args) {
+    if (!this.client) {
+      throw new Error("Transport not connected. Call connect() first.");
+    }
+    const result = await this.client.callTool({ name, arguments: args });
+    if (result.isError) {
+      let errorText = "";
+      for (const block of result.content) {
+        if (block.text !== void 0) {
+          errorText += block.text;
+        }
+      }
+      throw new Error(`MCP tool error (${name}): ${errorText}`);
+    }
+    let combinedText = "";
+    for (const block of result.content) {
+      if (block.text !== void 0) {
+        combinedText += block.text;
+      }
+    }
+    return parseResponseText(combinedText);
+  }
+};
+
+// src/errors.ts
+var XpozError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "XpozError";
+  }
+};
+var AuthenticationError = class extends XpozError {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var XpozConnectionError = class extends XpozError {
+  constructor(message) {
+    super(message);
+    this.name = "XpozConnectionError";
+  }
+};
+var OperationTimeoutError = class extends XpozError {
+  operationId;
+  elapsedMs;
+  constructor(operationId, elapsedMs) {
+    super(`Operation ${operationId} timed out after ${Math.round(elapsedMs / 1e3)}s`);
+    this.name = "OperationTimeoutError";
+    this.operationId = operationId;
+    this.elapsedMs = elapsedMs;
+  }
+};
+var OperationFailedError = class extends XpozError {
+  operationId;
+  operationError;
+  constructor(operationId, error) {
+    super(`Operation ${operationId} failed: ${error}`);
+    this.name = "OperationFailedError";
+    this.operationId = operationId;
+    this.operationError = error;
+  }
+};
+var OperationCancelledError = class extends XpozError {
+  operationId;
+  constructor(operationId) {
+    super(`Operation ${operationId} was cancelled`);
+    this.name = "OperationCancelledError";
+    this.operationId = operationId;
+  }
+};
+
+// src/config/constants.ts
+var DEFAULT_SERVER_URL = "https://mcp.xpoz.ai/mcp";
+var ENV_API_KEY = "XPOZ_API_KEY";
+var ENV_SERVER_URL = "XPOZ_SERVER_URL";
+var POLL_INTERVAL_MS = 5e3;
+var DEFAULT_TIMEOUT_MS = 3e5;
+
+// src/mcp/polling.ts
+async function waitForResult(callTool, operationId, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const start = Date.now();
+  while (true) {
+    const result = await callTool("checkOperationStatus", { operationId });
+    const status = result["status"];
+    if (status === "failed") {
+      const error = result["error"] ?? "Unknown error";
+      throw new OperationFailedError(operationId, String(error));
+    }
+    if (status === "cancelled") {
+      throw new OperationCancelledError(operationId);
+    }
+    if (status === "completed" || "results" in result || "downloadUrl" in result) {
+      return result;
+    }
+    const elapsed = Date.now() - start;
+    if (elapsed >= timeoutMs) {
+      throw new OperationTimeoutError(operationId, elapsed);
+    }
+    await sleep(POLL_INTERVAL_MS);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/pagination.ts
+var PaginatedResult = class {
+  data;
+  pagination;
+  _tableName;
+  _exportOperationId;
+  _fetchPage;
+  _fetchExport;
+  constructor(options) {
+    this.data = options.data;
+    this.pagination = options.pagination;
+    this._tableName = options.tableName;
+    this._exportOperationId = options.exportOperationId;
+    this._fetchPage = options.fetchPage;
+    this._fetchExport = options.fetchExport;
+  }
+  hasNextPage() {
+    return this.pagination.pageNumber < this.pagination.totalPages;
+  }
+  async nextPage() {
+    if (!this.hasNextPage()) {
+      throw new RangeError("No more pages available");
+    }
+    return this._fetchPageResult(this.pagination.pageNumber + 1);
+  }
+  async getPage(pageNumber) {
+    if (pageNumber < 1 || pageNumber > this.pagination.totalPages) {
+      throw new RangeError(
+        `Page ${pageNumber} out of range (1-${this.pagination.totalPages})`
+      );
+    }
+    return this._fetchPageResult(pageNumber);
+  }
+  async exportCsv() {
+    if (!this._fetchExport || !this._exportOperationId) {
+      throw new Error("CSV export not available for this result");
+    }
+    return this._fetchExport(this._exportOperationId);
+  }
+  _fetchPageResult(pageNumber) {
+    return this._fetchPage(pageNumber, this._tableName);
+  }
+  toString() {
+    return `PaginatedResult(items=${this.data.length}, page=${this.pagination.pageNumber}/${this.pagination.totalPages}, total=${this.pagination.totalRows})`;
+  }
+};
+
+// src/namespaces/base.ts
+function extractPagination(raw) {
+  const pag = raw["pagination"] ?? {};
+  return {
+    tableName: pag["tableName"] ?? null,
+    totalRows: pag["totalRows"] ?? 0,
+    totalPages: pag["totalPages"] ?? 0,
+    pageNumber: pag["pageNumber"] ?? 1,
+    pageSize: pag["pageSize"] ?? 100,
+    resultsCount: pag["resultsCount"] ?? 0
+  };
+}
+function extractResults(raw) {
+  return raw["results"] ?? [];
+}
+function extractExportOpId(raw) {
+  return raw["dataDumpExportOperationId"] ?? null;
+}
+var BaseNamespace = class {
+  callTool;
+  timeoutMs;
+  constructor(callTool, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.callTool = callTool;
+    this.timeoutMs = timeoutMs;
+  }
+  async callAndMaybePoll(toolName, args) {
+    const result = await this.callTool(toolName, args);
+    const operationId = result["operationId"];
+    if (operationId) {
+      return waitForResult(this.callTool, operationId, this.timeoutMs);
+    }
+    return result;
+  }
+  buildPaginatedResult(raw, parseItem, toolName, baseArgs) {
+    const items = extractResults(raw).map(parseItem);
+    const pagination = extractPagination(raw);
+    const tableName = pagination.tableName;
+    const exportOpId = extractExportOpId(raw);
+    const fetchPage = async (pageNumber, tbl) => {
+      const args = { ...baseArgs, pageNumber };
+      if (tbl) args["tableName"] = tbl;
+      const pageRaw = await this.callAndMaybePoll(toolName, args);
+      return this.buildPaginatedResult(pageRaw, parseItem, toolName, baseArgs);
+    };
+    const fetchExport = async (opId) => {
+      const pollResult = await waitForResult(this.callTool, opId, this.timeoutMs);
+      return pollResult["downloadUrl"] ?? "";
+    };
+    return new PaginatedResult({
+      data: items,
+      pagination,
+      tableName,
+      exportOperationId: exportOpId,
+      fetchPage,
+      fetchExport
+    });
+  }
+  buildArgs(args) {
+    const result = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (value !== void 0 && value !== null) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  extractPagination(raw) {
+    return extractPagination(raw);
+  }
+  extractResults(raw) {
+    return extractResults(raw);
+  }
+};
+
+// 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 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";
+var SEARCH_REDDIT_COMMENTS = "getRedditCommentsByKeywords";
+var GET_REDDIT_USER = "getRedditUser";
+var SEARCH_REDDIT_USERS = "searchRedditUsers";
+var GET_REDDIT_USERS_BY_KEYWORDS = "getRedditUsersByKeywords";
+var SEARCH_REDDIT_SUBREDDITS = "searchRedditSubreddits";
+var GET_REDDIT_SUBREDDIT_WITH_POSTS = "getRedditSubredditWithPostsByName";
+var GET_REDDIT_SUBREDDITS_BY_KEYWORDS = "getRedditSubredditsByKeywords";
+
+// src/namespaces/twitter.ts
+function parseTwitterPost(item) {
+  return item;
+}
+function parseUser(item) {
+  return item;
+}
+var TwitterNamespace = class extends BaseNamespace {
+  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);
+  }
+  async getPostsByAuthor(identifier, options = {}) {
+    const args = this.buildArgs({
+      identifier,
+      identifierType: options.identifierType ?? "username",
+      fields: options.fields,
+      startDate: options.startDate,
+      endDate: options.endDate,
+      forceLatest: options.forceLatest
+    });
+    const result = await this.callAndMaybePoll(GET_TWITTER_POSTS_BY_AUTHOR, args);
+    return this.buildPaginatedResult(result, parseTwitterPost, GET_TWITTER_POSTS_BY_AUTHOR, args);
+  }
+  async searchPosts(query, options = {}) {
+    const args = this.buildArgs({
+      query,
+      fields: options.fields,
+      startDate: options.startDate,
+      endDate: options.endDate,
+      authorUsername: options.authorUsername,
+      authorId: options.authorId,
+      language: options.language,
+      forceLatest: options.forceLatest,
+      responseType: options.responseType
+    });
+    if (options.responseType === "csv") {
+      const raw = await this.callTool(SEARCH_TWITTER_POSTS, args);
+      const exportOpId = raw["operationId"] ?? raw["dataDumpExportOperationId"] ?? null;
+      const csvRaw = { results: [], dataDumpExportOperationId: exportOpId };
+      return this.buildPaginatedResult(csvRaw, parseTwitterPost, SEARCH_TWITTER_POSTS, args);
+    }
+    const result = await this.callAndMaybePoll(SEARCH_TWITTER_POSTS, args);
+    return this.buildPaginatedResult(result, parseTwitterPost, SEARCH_TWITTER_POSTS, args);
+  }
+  async getRetweets(postId, options = {}) {
+    const args = this.buildArgs({ postId, ...options });
+    const result = await this.callAndMaybePoll(GET_TWITTER_RETWEETS, args);
+    return this.buildPaginatedResult(result, parseTwitterPost, GET_TWITTER_RETWEETS, args);
+  }
+  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);
+  }
+  async getComments(postId, options = {}) {
+    const args = this.buildArgs({ postId, ...options });
+    const result = await this.callAndMaybePoll(GET_TWITTER_COMMENTS, args);
+    return this.buildPaginatedResult(result, parseTwitterPost, GET_TWITTER_COMMENTS, args);
+  }
+  async getPostInteractingUsers(postId, interactionType, options = {}) {
+    const args = this.buildArgs({ postId, interactionType, ...options });
+    const result = await this.callAndMaybePoll(GET_TWITTER_POST_INTERACTING_USERS, args);
+    return this.buildPaginatedResult(
+      result,
+      parseUser,
+      GET_TWITTER_POST_INTERACTING_USERS,
+      args
+    );
+  }
+  async countPosts(phrase, options = {}) {
+    const args = this.buildArgs({ phrase, ...options });
+    const result = await this.callAndMaybePoll(COUNT_TWEETS, args);
+    const count = result["results"] ?? result["count"] ?? 0;
+    if (Array.isArray(count)) {
+      if (count.length === 0) return 0;
+      const first = count[0];
+      if (first !== null && typeof first === "object") {
+        return Number(Object.values(first)[0]);
+      }
+      return Number(first);
+    }
+    return Number(count);
+  }
+  async getUser(identifier, options = {}) {
+    const args = this.buildArgs({
+      identifier,
+      identifierType: options.identifierType ?? "username",
+      fields: options.fields
+    });
+    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;
+  }
+  async searchUsers(name, options = {}) {
+    const args = this.buildArgs({ name, ...options });
+    const result = await this.callAndMaybePoll(SEARCH_TWITTER_USERS, args);
+    return (result["results"] ?? []).map(parseUser);
+  }
+  async getUserConnections(username, connectionType, options = {}) {
+    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
+    );
+  }
+  async getUsersByKeywords(query, options = {}) {
+    const args = this.buildArgs({ query, ...options });
+    const result = await this.callAndMaybePoll(GET_TWITTER_USERS_BY_KEYWORDS, args);
+    return this.buildPaginatedResult(
+      result,
+      parseUser,
+      GET_TWITTER_USERS_BY_KEYWORDS,
+      args
+    );
+  }
+};
+
+// src/namespaces/instagram.ts
+function parsePost(item) {
+  return item;
+}
+function parseUser2(item) {
+  return item;
+}
+function parseComment(item) {
+  return item;
+}
+var InstagramNamespace = class extends BaseNamespace {
+  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);
+  }
+  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
+    });
+    const result = await this.callAndMaybePoll(GET_INSTAGRAM_POSTS_BY_USER, args);
+    return this.buildPaginatedResult(
+      result,
+      parsePost,
+      GET_INSTAGRAM_POSTS_BY_USER,
+      args
+    );
+  }
+  async searchPosts(query, options = {}) {
+    const args = this.buildArgs({ query, ...options });
+    const result = await this.callAndMaybePoll(SEARCH_INSTAGRAM_POSTS, args);
+    return this.buildPaginatedResult(result, parsePost, SEARCH_INSTAGRAM_POSTS, args);
+  }
+  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);
+  }
+  async getUser(identifier, options = {}) {
+    const args = this.buildArgs({
+      identifier,
+      identifierType: options.identifierType ?? "username",
+      fields: options.fields
+    });
+    const result = await this.callAndMaybePoll(GET_INSTAGRAM_USER, args);
+    const results = result["results"];
+    if (Array.isArray(results) && results.length > 0) {
+      return results[0];
+    }
+    return result;
+  }
+  async searchUsers(name, options = {}) {
+    const args = this.buildArgs({ name, ...options });
+    const result = await this.callAndMaybePoll(SEARCH_INSTAGRAM_USERS, args);
+    return (result["results"] ?? []).map(parseUser2);
+  }
+  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
+    );
+  }
+  async getPostInteractingUsers(postId, interactionType, options = {}) {
+    const args = this.buildArgs({ postId, interactionType, ...options });
+    const result = await this.callAndMaybePoll(
+      GET_INSTAGRAM_POST_INTERACTING_USERS,
+      args
+    );
+    return this.buildPaginatedResult(
+      result,
+      parseUser2,
+      GET_INSTAGRAM_POST_INTERACTING_USERS,
+      args
+    );
+  }
+  async getUsersByKeywords(query, options = {}) {
+    const args = this.buildArgs({ query, ...options });
+    const result = await this.callAndMaybePoll(GET_INSTAGRAM_USERS_BY_KEYWORDS, args);
+    return this.buildPaginatedResult(
+      result,
+      parseUser2,
+      GET_INSTAGRAM_USERS_BY_KEYWORDS,
+      args
+    );
+  }
+};
+
+// src/namespaces/reddit.ts
+function parsePost2(item) {
+  return item;
+}
+function parseUser3(item) {
+  return item;
+}
+function parseComment2(item) {
+  return item;
+}
+function parseSubreddit(item) {
+  return item;
+}
+var RedditNamespace = class extends BaseNamespace {
+  async searchPosts(query, options = {}) {
+    const args = this.buildArgs({ query, ...options });
+    const result = await this.callAndMaybePoll(SEARCH_REDDIT_POSTS, args);
+    return this.buildPaginatedResult(result, parsePost2, SEARCH_REDDIT_POSTS, args);
+  }
+  async getPostWithComments(postId, options = {}) {
+    const args = this.buildArgs({ postId, ...options });
+    const result = await this.callAndMaybePoll(GET_REDDIT_POST_WITH_COMMENTS, args);
+    return this._parsePostWithComments(result);
+  }
+  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);
+  }
+  async getUser(username, options = {}) {
+    const args = this.buildArgs({ username, ...options });
+    const result = await this.callAndMaybePoll(GET_REDDIT_USER, args);
+    const results = result["results"];
+    if (Array.isArray(results) && results.length > 0) {
+      return results[0];
+    }
+    return result;
+  }
+  async searchUsers(name, options = {}) {
+    const args = this.buildArgs({ name, ...options });
+    const result = await this.callAndMaybePoll(SEARCH_REDDIT_USERS, args);
+    return (result["results"] ?? []).map(parseUser3);
+  }
+  async getUsersByKeywords(query, options = {}) {
+    const args = this.buildArgs({ query, ...options });
+    const result = await this.callAndMaybePoll(GET_REDDIT_USERS_BY_KEYWORDS, args);
+    return this.buildPaginatedResult(
+      result,
+      parseUser3,
+      GET_REDDIT_USERS_BY_KEYWORDS,
+      args
+    );
+  }
+  async searchSubreddits(query, options = {}) {
+    const args = this.buildArgs({ query, ...options });
+    const result = await this.callAndMaybePoll(SEARCH_REDDIT_SUBREDDITS, args);
+    return (result["results"] ?? []).map(parseSubreddit);
+  }
+  async getSubredditWithPosts(subredditName, options = {}) {
+    const args = this.buildArgs({ subredditName, ...options });
+    const result = await this.callAndMaybePoll(GET_REDDIT_SUBREDDIT_WITH_POSTS, args);
+    return this._parseSubredditWithPosts(result);
+  }
+  async getSubredditsByKeywords(query, options = {}) {
+    const args = this.buildArgs({ query, ...options });
+    const result = await this.callAndMaybePoll(GET_REDDIT_SUBREDDITS_BY_KEYWORDS, args);
+    return this.buildPaginatedResult(
+      result,
+      parseSubreddit,
+      GET_REDDIT_SUBREDDITS_BY_KEYWORDS,
+      args
+    );
+  }
+  _parsePostWithComments(raw) {
+    let results = raw["results"] ?? {};
+    if (Array.isArray(results)) {
+      results = results.length > 0 ? results[0] : {};
+    }
+    const postData = results["post"] ?? results;
+    const commentsData = results["comments"] ?? [];
+    const pagination = this.extractPagination(raw);
+    return {
+      post: postData,
+      comments: commentsData.map(parseComment2),
+      commentsPagination: pagination.totalPages > 0 ? pagination : null,
+      commentsTableName: pagination.tableName ?? null
+    };
+  }
+  _parseSubredditWithPosts(raw) {
+    let results = raw["results"] ?? {};
+    if (Array.isArray(results)) {
+      results = results.length > 0 ? results[0] : {};
+    }
+    const subredditData = results["subreddit"] ?? results;
+    const postsData = results["posts"] ?? [];
+    const pagination = this.extractPagination(raw);
+    return {
+      subreddit: subredditData,
+      posts: postsData.map(parsePost2),
+      postsPagination: pagination.totalPages > 0 ? pagination : null,
+      postsTableName: pagination.tableName ?? null
+    };
+  }
+};
+
+// src/client.ts
+var XpozClient = class {
+  twitter;
+  instagram;
+  reddit;
+  transport;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? process.env[ENV_API_KEY];
+    if (!apiKey) {
+      throw new AuthenticationError(
+        `API key required. Get your token at http://xpoz.ai/get-token?utm_source=ts_sdk&utm_medium=sdk (login \u2192 copy token), then pass it as apiKey or set the ${ENV_API_KEY} environment variable.`
+      );
+    }
+    const serverUrl = options.serverUrl ?? process.env[ENV_SERVER_URL] ?? DEFAULT_SERVER_URL;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.transport = new McpTransport(serverUrl, apiKey);
+    const callTool = this.transport.callTool.bind(this.transport);
+    this.twitter = new TwitterNamespace(callTool, timeoutMs);
+    this.instagram = new InstagramNamespace(callTool, timeoutMs);
+    this.reddit = new RedditNamespace(callTool, timeoutMs);
+  }
+  async connect() {
+    await this.transport.connect();
+  }
+  async close() {
+    await this.transport.close();
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+};
+export {
+  AuthenticationError,
+  OperationCancelledError,
+  OperationFailedError,
+  OperationTimeoutError,
+  PaginatedResult,
+  VERSION,
+  XpozClient,
+  XpozConnectionError,
+  XpozError
+};