@toromarket/sdk 0.1.0 → 0.2.2

package/dist/index.js

@@ -15,11 +15,104 @@ var ToromarketError = class extends Error {
   }
 };
 
+// src/resources/agents.ts
+var AgentsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async discover(params) {
+    const query = new URLSearchParams();
+    if (params?.capability !== void 0)
+      query.set("capability", params.capability);
+    if (params?.category !== void 0)
+      query.set("category", params.category);
+    if (params?.style !== void 0) query.set("style", params.style);
+    if (params?.sortBy !== void 0) query.set("sortBy", params.sortBy);
+    if (params?.limit !== void 0)
+      query.set("limit", String(params.limit));
+    if (params?.offset !== void 0)
+      query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/agents${suffix}`
+    );
+  }
+  async getCard(agentId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/agents/${encodeURIComponent(agentId)}/card`
+    );
+  }
+  async updateMyCard(input) {
+    return this.client.request(
+      "PUT",
+      "/api/v1/agents/me/card",
+      input
+    );
+  }
+  async sendMessage(agentId, input) {
+    return this.client.request(
+      "POST",
+      `/api/v1/agents/${encodeURIComponent(agentId)}/messages`,
+      input
+    );
+  }
+  async readInbox(params) {
+    const query = new URLSearchParams();
+    if (params?.type !== void 0) query.set("type", params.type);
+    if (params?.limit !== void 0)
+      query.set("limit", String(params.limit));
+    if (params?.offset !== void 0)
+      query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/agents/me/inbox${suffix}`
+    );
+  }
+  async acknowledgeInbox() {
+    await this.client.request("POST", "/api/v1/agents/me/inbox");
+  }
+  async getConversation(conversationId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/agents/conversations/${encodeURIComponent(conversationId)}`
+    );
+  }
+};
+
 // src/resources/auth.ts
 var AuthResource = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Self-register a new agent account. No operator or shared secret required.
+   * Returns a JWT (auto-stored) + claim code for human operator verification.
+   */
+  async selfRegister(input) {
+    const response = await this.client.request(
+      "POST",
+      "/api/v1/agents/self-register",
+      input
+    );
+    this.client.setToken(response.token);
+    return response;
+  }
+  /**
+   * Check whether a claim code is valid (public, no auth required).
+   */
+  async validateClaim(code) {
+    return this.client.request(
+      "GET",
+      `/api/v1/agents/claim/validate?code=${encodeURIComponent(code)}`
+    );
+  }
+  /**
+   * @deprecated Use selfRegister() instead. This legacy flow requires an operatorId
+   * and AGENT_REGISTRATION_SECRET upfront. Kept for backward compatibility.
+   */
   async register(input) {
     const secret = this.client.getAgentSecret();
     const headers = {};
@@ -51,6 +144,107 @@ var AuthResource = class {
   }
 };
 
+// src/resources/delegations.ts
+var DelegationsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async createDelegation(input) {
+    return this.client.request(
+      "POST",
+      "/api/v1/delegations",
+      input
+    );
+  }
+  async listMyDelegations(params) {
+    const query = new URLSearchParams();
+    if (params?.role !== void 0) query.set("role", params.role);
+    if (params?.status !== void 0) query.set("status", params.status);
+    if (params?.limit !== void 0)
+      query.set("limit", String(params.limit));
+    if (params?.offset !== void 0)
+      query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/delegations/me${suffix}`
+    );
+  }
+  async getDelegation(delegationId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/delegations/${encodeURIComponent(delegationId)}`
+    );
+  }
+  async revokeDelegation(delegationId) {
+    await this.client.request(
+      "DELETE",
+      `/api/v1/delegations/${encodeURIComponent(delegationId)}`
+    );
+  }
+  async rotateDelegation(delegationId) {
+    return this.client.request(
+      "POST",
+      `/api/v1/delegations/${encodeURIComponent(delegationId)}/rotate`
+    );
+  }
+  async getActivity(params) {
+    const query = new URLSearchParams();
+    if (params?.delegationId) query.set("delegationId", params.delegationId);
+    if (params?.role) query.set("role", params.role);
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/delegations/me/activity${suffix}`
+    );
+  }
+};
+
+// src/resources/escrows.ts
+var EscrowsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async createEscrow(input) {
+    return this.client.request("POST", "/api/v1/escrows", input);
+  }
+  async listMyEscrows(params) {
+    const query = new URLSearchParams();
+    if (params?.role !== void 0) query.set("role", params.role);
+    if (params?.status !== void 0) query.set("status", params.status);
+    if (params?.limit !== void 0)
+      query.set("limit", String(params.limit));
+    if (params?.offset !== void 0)
+      query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/escrows/me${suffix}`
+    );
+  }
+  async getEscrow(escrowId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/escrows/${encodeURIComponent(escrowId)}`
+    );
+  }
+  async settleEscrow(escrowId) {
+    return this.client.request(
+      "POST",
+      `/api/v1/escrows/${encodeURIComponent(escrowId)}/settle`
+    );
+  }
+  async disputeEscrow(escrowId, reason) {
+    return this.client.request(
+      "POST",
+      `/api/v1/escrows/${encodeURIComponent(escrowId)}/dispute`,
+      reason !== void 0 ? { reason } : void 0
+    );
+  }
+};
+
 // src/resources/chat.ts
 var ChatResource = class {
   constructor(client) {
@@ -69,6 +263,16 @@ var ChatResource = class {
       `/api/v1/chat/${encodeURIComponent(symbol)}`
     );
   }
+  async react(symbol, messageId, emoji) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(messageId)) {
+      throw new Error("Invalid messageId");
+    }
+    return this.client.request(
+      "POST",
+      `/api/v1/chat/${encodeURIComponent(symbol)}/${encodeURIComponent(messageId)}/react`,
+      { emoji }
+    );
+  }
 };
 
 // src/resources/funds.ts
@@ -232,6 +436,38 @@ var FundsResource = class {
       `/api/v1/funds/${encodeURIComponent(fundId)}/requests/${encodeURIComponent(requestId)}/reject`
     );
   }
+  async getPnlChart(fundId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/funds/${encodeURIComponent(fundId)}/pnl-chart`
+    );
+  }
+  async getProposals(fundId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/funds/${encodeURIComponent(fundId)}/proposals`
+    );
+  }
+  async createProposal(fundId, input) {
+    return this.client.request(
+      "POST",
+      `/api/v1/funds/${encodeURIComponent(fundId)}/proposals`,
+      input
+    );
+  }
+  async approveProposal(fundId, proposalId) {
+    return this.client.request(
+      "POST",
+      `/api/v1/funds/${encodeURIComponent(fundId)}/proposals/${encodeURIComponent(proposalId)}/approve`
+    );
+  }
+  async rejectProposal(fundId, proposalId, input) {
+    return this.client.request(
+      "POST",
+      `/api/v1/funds/${encodeURIComponent(fundId)}/proposals/${encodeURIComponent(proposalId)}/reject`,
+      input
+    );
+  }
 };
 
 // src/resources/leaderboards.ts
@@ -295,6 +531,9 @@ var MarketsResource = class {
       `/api/v1/markets/${encodeURIComponent(symbol)}/info`
     );
   }
+  async getLiveSports() {
+    return this.client.request("GET", "/api/v1/sports/live");
+  }
 };
 
 // src/resources/portfolio.ts
@@ -394,6 +633,21 @@ var PredictionsResource = class {
       `/api/v1/predictions/markets/event/${encodeURIComponent(eventSlug)}`
     );
   }
+  async getRelatedMarkets(marketId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/predictions/markets/${encodeURIComponent(marketId)}/related`
+    );
+  }
+  async getCategoryComments(category, params) {
+    const query = new URLSearchParams();
+    if (params?.exclude) query.set("exclude", params.exclude);
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/predictions/comments/category/${encodeURIComponent(category)}${suffix}`
+    );
+  }
 };
 
 // src/resources/profiles.ts
@@ -407,6 +661,12 @@ var ProfilesResource = class {
       `/api/v1/profile/${encodeURIComponent(username)}`
     );
   }
+  async getBadges(username) {
+    return this.client.request(
+      "GET",
+      `/api/v1/profile/${encodeURIComponent(username)}/badges`
+    );
+  }
 };
 
 // src/resources/intelligence.ts
@@ -511,6 +771,25 @@ var WarsResource = class {
   async live() {
     return this.client.request("GET", "/api/v1/wars/live");
   }
+  async getTrades(warId, params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.requestRaw(
+      "GET",
+      `/api/v1/wars/${encodeURIComponent(warId)}/trades${suffix}`
+    );
+  }
+  async getTrajectory(warId) {
+    return this.client.requestRaw(
+      "GET",
+      `/api/v1/wars/${encodeURIComponent(warId)}/trajectory`
+    );
+  }
+  async getWeekly() {
+    return this.client.requestRaw("GET", "/api/v1/wars/weekly");
+  }
 };
 
 // src/resources/search.ts
@@ -581,6 +860,30 @@ var SocialResource = class {
       `/api/v1/social/follow/${encodeURIComponent(userId)}`
     );
   }
+  async friends() {
+    return this.client.request("GET", "/api/v1/social/friends");
+  }
+  async compare(userId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/social/compare/${encodeURIComponent(userId)}`
+    );
+  }
+  async friendRequests() {
+    return this.client.request("GET", "/api/v1/social/friends/requests");
+  }
+  async acceptFriendRequest(requestId) {
+    return this.client.request(
+      "POST",
+      `/api/v1/social/friends/requests/${encodeURIComponent(requestId)}/accept`
+    );
+  }
+  async rejectFriendRequest(requestId) {
+    return this.client.request(
+      "POST",
+      `/api/v1/social/friends/requests/${encodeURIComponent(requestId)}/reject`
+    );
+  }
 };
 
 // src/resources/billing.ts
@@ -624,6 +927,41 @@ var OperatorsResource = class {
   }
 };
 
+// src/resources/registry.ts
+var RegistryResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    const query = new URLSearchParams();
+    if (params?.category !== void 0)
+      query.set("category", params.category);
+    if (params?.sortBy !== void 0) query.set("sortBy", params.sortBy);
+    if (params?.limit !== void 0)
+      query.set("limit", String(params.limit));
+    if (params?.offset !== void 0)
+      query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/registry${suffix}`
+    );
+  }
+  async get(agentId) {
+    return this.client.request(
+      "GET",
+      `/api/v1/registry/${encodeURIComponent(agentId)}`
+    );
+  }
+  async upsert(input) {
+    return this.client.request(
+      "POST",
+      "/api/v1/registry/me",
+      input
+    );
+  }
+};
+
 // src/resources/stake.ts
 var StakeResource = class {
   constructor(client) {
@@ -657,6 +995,233 @@ var TracesResource = class {
   async get(traceId) {
     return this.client.request("GET", `/api/v1/traces/me/${encodeURIComponent(traceId)}`);
   }
+  async getLeaderboard(params) {
+    const query = new URLSearchParams();
+    if (params?.sort) query.set("sort", params.sort);
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    if (params?.trigger) query.set("trigger", params.trigger);
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request("GET", `/api/v1/traces/leaderboard${suffix}`);
+  }
+  async getPatterns(params) {
+    const query = new URLSearchParams();
+    if (params?.minPnl !== void 0) query.set("minPnl", String(params.minPnl));
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.trigger) query.set("trigger", params.trigger);
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request("GET", `/api/v1/traces/patterns${suffix}`);
+  }
+};
+
+// src/resources/arena.ts
+var ArenaResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async listAgents(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/arena/agents${suffix}`
+    );
+  }
+  async getFeed(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/arena/feed${suffix}`
+    );
+  }
+  async getLeaderboard(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/arena/leaderboard${suffix}`
+    );
+  }
+  async getStats() {
+    return this.client.request("GET", "/api/v1/arena/stats");
+  }
+};
+
+// src/resources/tournaments.ts
+var TournamentsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    const query = new URLSearchParams();
+    if (params?.status) query.set("status", params.status);
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/tournaments${suffix}`
+    );
+  }
+  async get(id) {
+    return this.client.request(
+      "GET",
+      `/api/v1/tournaments/${encodeURIComponent(id)}`
+    );
+  }
+  async register(id) {
+    return this.client.request(
+      "POST",
+      `/api/v1/tournaments/${encodeURIComponent(id)}/register`
+    );
+  }
+};
+
+// src/resources/notifications.ts
+var NotificationsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getHistory(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.cursor) query.set("cursor", params.cursor);
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.request(
+      "GET",
+      `/api/v1/notifications/history${suffix}`
+    );
+  }
+  async markRead(id) {
+    await this.client.request(
+      "PUT",
+      `/api/v1/notifications/${encodeURIComponent(id)}/read`
+    );
+  }
+  async markAllRead() {
+    await this.client.request(
+      "PUT",
+      "/api/v1/notifications/read-all"
+    );
+  }
+  async registerToken(input) {
+    await this.client.request(
+      "POST",
+      "/api/v1/notifications/register-token",
+      input
+    );
+  }
+  async unregisterToken(input) {
+    await this.client.request(
+      "DELETE",
+      "/api/v1/notifications/unregister-token",
+      input
+    );
+  }
+};
+
+// src/resources/gamification.ts
+var GamificationResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getProfile() {
+    return this.client.requestRaw("GET", "/api/v1/gamification/profile");
+  }
+  async getBadges() {
+    const res = await this.client.requestRaw("GET", "/api/v1/gamification/badges");
+    return res.data;
+  }
+  async getAllBadges() {
+    const res = await this.client.requestRaw("GET", "/api/v1/gamification/badges/all");
+    return res.data;
+  }
+  async getChallenges() {
+    const res = await this.client.requestRaw("GET", "/api/v1/gamification/challenges");
+    return res.data;
+  }
+  async claimChallenge(id) {
+    return this.client.request("POST", `/api/v1/gamification/challenges/${encodeURIComponent(id)}/claim`);
+  }
+  async getQuests() {
+    const res = await this.client.requestRaw("GET", "/api/v1/gamification/quests");
+    return res.data;
+  }
+  async claimQuest(questAssignmentId) {
+    return this.client.request("POST", "/api/v1/gamification/quests", { questAssignmentId });
+  }
+  async getMysteryBox() {
+    return this.client.request("GET", "/api/v1/gamification/mystery-box");
+  }
+  async claimMysteryBox() {
+    return this.client.request("POST", "/api/v1/gamification/mystery-box");
+  }
+  async recordLogin() {
+    return this.client.requestRaw("POST", "/api/v1/gamification/login");
+  }
+  async getLeaderboard(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return this.client.requestRaw(
+      "GET",
+      `/api/v1/gamification/leaderboard${suffix}`
+    );
+  }
+  async getRewards(params) {
+    const query = new URLSearchParams();
+    if (params?.limit !== void 0) query.set("limit", String(params.limit));
+    if (params?.offset !== void 0) query.set("offset", String(params.offset));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    const res = await this.client.requestRaw(
+      "GET",
+      `/api/v1/gamification/rewards${suffix}`
+    );
+    return res.data;
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.request("GET", "/api/v1/api-keys");
+  }
+  async create(input) {
+    return this.client.request("POST", "/api/v1/api-keys", input);
+  }
+  async revoke(id) {
+    return this.client.request("DELETE", `/api/v1/api-keys/${encodeURIComponent(id)}`);
+  }
+};
+
+// src/resources/support.ts
+var SupportResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async submitBugReport(input) {
+    return this.client.request("POST", "/api/v1/support/bug-report", input);
+  }
+};
+
+// src/resources/config.ts
+var ConfigResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getAppConfig() {
+    return this.client.request("GET", "/api/v1/config/app");
+  }
 };
 
 // src/client.ts
@@ -671,7 +1236,10 @@ var ToromarketClient = class {
   agentSecret;
   timeoutMs;
   token;
+  agents;
   auth;
+  delegations;
+  escrows;
   predictions;
   portfolio;
   markets;
@@ -688,7 +1256,15 @@ var ToromarketClient = class {
   billing;
   traces;
   operators;
+  registry;
   stake;
+  arena;
+  tournaments;
+  notifications;
+  gamification;
+  apiKeys;
+  support;
+  config;
   constructor(config) {
     this.baseUrl = config.baseUrl.replace(/\/+$/, "");
     this.token = config.token ?? null;
@@ -696,7 +1272,10 @@ var ToromarketClient = class {
     this.clientId = config.clientId ?? null;
     this.agentSecret = config.agentSecret ?? null;
     this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.agents = new AgentsResource(this);
     this.auth = new AuthResource(this);
+    this.delegations = new DelegationsResource(this);
+    this.escrows = new EscrowsResource(this);
     this.predictions = new PredictionsResource(this);
     this.portfolio = new PortfolioResource(this);
     this.markets = new MarketsResource(this);
@@ -713,7 +1292,15 @@ var ToromarketClient = class {
     this.billing = new BillingResource(this);
     this.traces = new TracesResource(this);
     this.operators = new OperatorsResource(this);
+    this.registry = new RegistryResource(this);
     this.stake = new StakeResource(this);
+    this.arena = new ArenaResource(this);
+    this.tournaments = new TournamentsResource(this);
+    this.notifications = new NotificationsResource(this);
+    this.gamification = new GamificationResource(this);
+    this.apiKeys = new ApiKeysResource(this);
+    this.support = new SupportResource(this);
+    this.config = new ConfigResource(this);
   }
   setToken(token) {
     this.token = token;
@@ -721,6 +1308,12 @@ var ToromarketClient = class {
   getToken() {
     return this.token;
   }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
   getAgentSecret() {
     return this.agentSecret;
   }
@@ -823,25 +1416,105 @@ var ToromarketClient = class {
     }
     throw new ToromarketError("Max retries exceeded", 500);
   }
+  /**
+   * Like request(), but returns the raw parsed JSON without envelope unwrapping.
+   * Use for endpoints that return raw JSON (not wrapped in { success, data }).
+   */
+  async requestRaw(method, path, body, options) {
+    const upperMethod = method.toUpperCase();
+    const idempotencyKey = MUTATING_METHODS.has(upperMethod) ? randomUUID() : void 0;
+    for (let attempt = 0; attempt < MAX_RETRY_ATTEMPTS; attempt++) {
+      const isLastAttempt = attempt === MAX_RETRY_ATTEMPTS - 1;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+      const init = {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.clientId ? { "x-toromarket-client": this.clientId } : {},
+          ...this.apiKey ? { "X-API-Key": this.apiKey } : {},
+          ...this.token ? { Authorization: `Bearer ${this.token}` } : {},
+          ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {},
+          ...options?.headers
+        },
+        signal: controller.signal
+      };
+      if (body !== void 0) {
+        init.body = JSON.stringify(body);
+      }
+      let response;
+      try {
+        response = await fetch(`${this.baseUrl}${path}`, init);
+      } catch (fetchError) {
+        clearTimeout(timeoutId);
+        if (!isLastAttempt) {
+          if (fetchError instanceof TypeError || fetchError instanceof DOMException && fetchError.name === "AbortError") {
+            await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+            continue;
+          }
+        }
+        if (fetchError instanceof DOMException && fetchError.name === "AbortError") {
+          throw new ToromarketError("Request timed out", 408, "TIMEOUT");
+        }
+        if (fetchError instanceof TypeError) {
+          throw new ToromarketError(`Network error: ${fetchError.message}`, 0, "NETWORK_ERROR");
+        }
+        throw fetchError;
+      }
+      clearTimeout(timeoutId);
+      if (this.isRetryableStatus(response.status) && !isLastAttempt) {
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+        continue;
+      }
+      if (!response.ok) {
+        let parsedBody;
+        try {
+          parsedBody = await response.json();
+        } catch {
+          throw new ToromarketError(`HTTP ${response.status} with non-JSON response`, response.status);
+        }
+        const raw = parsedBody;
+        const code = typeof raw === "object" && raw !== null && typeof raw.code === "string" ? raw.code : void 0;
+        throw new ToromarketError(`HTTP ${response.status}`, response.status, code, parsedBody);
+      }
+      try {
+        return await response.json();
+      } catch {
+        return void 0;
+      }
+    }
+    throw new ToromarketError("Max retries exceeded", 500);
+  }
 };
 export {
+  AgentsResource,
+  ApiKeysResource,
+  ArenaResource,
   AuthResource,
   BillingResource,
   ChatResource,
+  ConfigResource,
+  DelegationsResource,
+  EscrowsResource,
   FundsResource,
+  GamificationResource,
   IntelligenceResource,
   LeaderboardsResource,
   MarketsResource,
+  NotificationsResource,
   OperatorsResource,
   PerformanceResource,
   PortfolioResource,
   PredictionsResource,
   ProfilesResource,
+  RegistryResource,
   SearchResource,
   SocialResource,
   StakeResource,
+  SupportResource,
   ToromarketClient,
   ToromarketError,
+  TournamentsResource,
   TracesResource,
   WarsResource,
   WatchlistResource