@one_deploy/sdk 1.0.3 → 1.0.5

package/dist/services/index.mjs

@@ -1063,6 +1063,43 @@ var OneEngineClient = class {
   async adminClearRateLimits(identifier) {
     return this.request(`/api/v1/admin/rate-limits/${identifier}`, { method: "DELETE" });
   }
+  // ========== AI Agent Configuration ==========
+  /**
+   * Get all AI agent configurations
+   * This returns the full agent setup including tiers, cycles, and trading parameters
+   */
+  async getAgentConfigs(options) {
+    const params = new URLSearchParams();
+    if (options?.includeInactive) params.set("includeInactive", "true");
+    if (options?.agentId) params.set("agentId", options.agentId);
+    const query = params.toString();
+    return this.request(`/api/v1/agents${query ? `?${query}` : ""}`, { method: "GET" });
+  }
+  /**
+   * Calculate subscription parameters for an agent
+   */
+  async calculateAgentParams(params) {
+    return this.request("/api/v1/agents/calculate", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get supported trading pairs from agents
+   */
+  async getTradingPairs() {
+    const result = await this.getAgentConfigs();
+    if (result.success && result.data?.agents) {
+      const allPairs = /* @__PURE__ */ new Set();
+      const byAgent = {};
+      for (const agent of result.data.agents) {
+        byAgent[agent.id] = agent.supported_pairs;
+        agent.supported_pairs.forEach((p) => allPairs.add(p));
+      }
+      return { success: true, data: { pairs: Array.from(allPairs), byAgent } };
+    }
+    return { success: false, error: result.error };
+  }
   // ========== AI Quant Trading ==========
   /**
    * Get all AI trading strategies
@@ -1201,6 +1238,67 @@ var OneEngineClient = class {
   async getCryptoMarketOverview() {
     return this.request("/api/v1/prices?type=overview", { method: "GET" });
   }
+  // ========== Project Management ==========
+  /**
+   * Get user's projects
+   */
+  async getProjects(options) {
+    const params = new URLSearchParams();
+    if (options?.isActive !== void 0) params.set("isActive", String(options.isActive));
+    const query = params.toString();
+    return this.request(`/api/v1/projects${query ? `?${query}` : ""}`, { method: "GET" });
+  }
+  /**
+   * Create a new project for ecosystem partners
+   */
+  async createProject(params) {
+    return this.request("/api/v1/projects", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get project details
+   */
+  async getProject(projectId) {
+    return this.request(`/api/v1/projects/${projectId}`, { method: "GET" });
+  }
+  /**
+   * Update project settings
+   */
+  async updateProject(projectId, updates) {
+    return this.request(`/api/v1/projects/${projectId}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+  }
+  /**
+   * Get project features status
+   */
+  async getProjectFeatures(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/features`, { method: "GET" });
+  }
+  /**
+   * Enable/disable features for a project
+   */
+  async updateProjectFeatures(projectId, features) {
+    return this.request(`/api/v1/projects/${projectId}/features`, {
+      method: "PATCH",
+      body: JSON.stringify(features)
+    });
+  }
+  /**
+   * Regenerate project API key
+   */
+  async regenerateProjectApiKey(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/api-key`, { method: "POST" });
+  }
+  /**
+   * Delete project
+   */
+  async deleteProject(projectId) {
+    return this.request(`/api/v1/projects/${projectId}`, { method: "DELETE" });
+  }
 };
 function createOneEngineClient(options) {
   return new OneEngineClient(options);
@@ -1453,6 +1551,159 @@ var PriceService = class {
 };
 var priceService = new PriceService();
 
-export { OneEngineClient, PriceService, SupabaseService, createOneEngineClient, createSupabaseClient, getSupabaseClient, priceService };
+// src/services/usage.ts
+var UsageService = class {
+  constructor(baseUrl) {
+    this.userId = null;
+    this.baseUrl = baseUrl || getConfig().oneEngineUrl || "";
+  }
+  /**
+   * Set the current user ID for tracking
+   */
+  setUserId(userId) {
+    this.userId = userId;
+  }
+  /**
+   * Record Personal Assistant usage (Thirdweb AI)
+   */
+  async trackPersonalAssistant(action, tokens, credits, metadata) {
+    return this.recordUsage({
+      userId: this.userId,
+      category: "ai_thirdweb",
+      action,
+      requestTokens: tokens?.request,
+      responseTokens: tokens?.response,
+      creditsUsed: credits,
+      metadata
+    });
+  }
+  /**
+   * Record Trading Agent usage (Engine AI)
+   */
+  async trackTradingAgent(action, credits, metadata) {
+    return this.recordUsage({
+      userId: this.userId,
+      category: "ai_trading_engine",
+      action,
+      creditsUsed: credits,
+      metadata
+    });
+  }
+  /**
+   * Record wallet operation usage
+   */
+  async trackWallet(action, metadata) {
+    return this.recordUsage({
+      userId: this.userId,
+      category: "wallet",
+      action,
+      metadata
+    });
+  }
+  /**
+   * Record payment usage
+   */
+  async trackPayment(action, metadata) {
+    return this.recordUsage({
+      userId: this.userId,
+      category: "payment",
+      action,
+      metadata
+    });
+  }
+  /**
+   * Record exchange usage (onramper)
+   */
+  async trackOnramper(action, metadata) {
+    return this.recordUsage({
+      userId: this.userId,
+      category: "exchange_onramper",
+      action,
+      metadata
+    });
+  }
+  /**
+   * Record exchange usage (swap)
+   */
+  async trackSwap(action, metadata) {
+    return this.recordUsage({
+      userId: this.userId,
+      category: "exchange_swap",
+      action,
+      metadata
+    });
+  }
+  /**
+   * Record any usage
+   */
+  async recordUsage(record) {
+    if (!record.userId) {
+      console.warn("[UsageService] No userId set, skipping usage tracking");
+      return false;
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/usage/user`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          userId: record.userId,
+          category: record.category,
+          action: record.action,
+          requestTokens: record.requestTokens || 0,
+          responseTokens: record.responseTokens || 0,
+          creditsUsed: record.creditsUsed || 0,
+          metadata: record.metadata || {}
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error("[UsageService] Failed to record usage:", error);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("[UsageService] Error recording usage:", error);
+      return false;
+    }
+  }
+  /**
+   * Get AI usage summary for current user
+   */
+  async getAIUsage(days = 30) {
+    if (!this.userId) {
+      console.warn("[UsageService] No userId set");
+      return null;
+    }
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/v1/usage/user?userId=${this.userId}&days=${days}`
+      );
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error("[UsageService] Failed to get usage:", error);
+        return null;
+      }
+      const result = await response.json();
+      return result.data;
+    } catch (error) {
+      console.error("[UsageService] Error getting usage:", error);
+      return null;
+    }
+  }
+};
+var usageServiceInstance = null;
+function getUsageService() {
+  if (!usageServiceInstance) {
+    usageServiceInstance = new UsageService();
+  }
+  return usageServiceInstance;
+}
+function createUsageService(baseUrl) {
+  return new UsageService(baseUrl);
+}
+
+export { OneEngineClient, PriceService, SupabaseService, UsageService, createOneEngineClient, createSupabaseClient, createUsageService, getSupabaseClient, getUsageService, priceService };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map