1499 lines
41 KiB
TypeScript
1499 lines
41 KiB
TypeScript
// API client for Taiji AI Platform
|
|
// Base URLs for different services
|
|
import { getAuthToken, clearAllTokens } from "@/lib/auth"
|
|
|
|
export const API_BASE_URLS = {
|
|
dataIngestion: process.env.NEXT_PUBLIC_DATA_INGESTION_URL || "http://135.171.216.9/api/data-ingestion",
|
|
mcpServer: process.env.NEXT_PUBLIC_MCP_SERVER_URL || "http://135.171.216.9/api/mcp",
|
|
gateway: process.env.NEXT_PUBLIC_API_GATEWAY_URL || "http://135.171.216.9/api",
|
|
}
|
|
|
|
// Helper function to get API key
|
|
function getApiKey(): string | null {
|
|
if (typeof window !== "undefined") {
|
|
return localStorage.getItem("api_key")
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Helper function to build headers and ensure authentication
|
|
function buildHeaders(contentType = "application/json", requireAuth = false): HeadersInit {
|
|
const headers: HeadersInit = {
|
|
Accept: "application/json",
|
|
}
|
|
|
|
if (contentType) {
|
|
headers["Content-Type"] = contentType
|
|
}
|
|
|
|
const token = getAuthToken()
|
|
const apiKey = getApiKey()
|
|
|
|
// 需要认证的请求必须有token或API key
|
|
if (requireAuth && !token && !apiKey) {
|
|
throw new Error(
|
|
"认证失败：未找到有效的token或API key。请重新登录。(Authentication failed: No valid token or API key found. Please log in again.)",
|
|
)
|
|
}
|
|
|
|
if (token) {
|
|
headers.Authorization = `Bearer ${token}`
|
|
} else if (apiKey) {
|
|
headers["X-API-Key"] = apiKey
|
|
}
|
|
|
|
return headers
|
|
}
|
|
|
|
// Helper function to check if user is authenticated
|
|
function requireAuth(): void {
|
|
const token = getAuthToken()
|
|
const apiKey = getApiKey()
|
|
|
|
if (!token && !apiKey) {
|
|
throw new Error(
|
|
"认证失败：未找到有效的token或API key。请重新登录。(Authentication failed: No valid token or API key found. Please log in again.)",
|
|
)
|
|
}
|
|
}
|
|
|
|
// API Response types
|
|
export interface APIResponse<T = any> {
|
|
success: boolean
|
|
data?: T
|
|
message?: string
|
|
error?: {
|
|
code?: string
|
|
message?: string
|
|
}
|
|
}
|
|
|
|
// Helper function to handle API responses
|
|
async function handleResponse<T = any>(response: Response): Promise<T> {
|
|
const contentType = response.headers.get("content-type")
|
|
|
|
// 先读取响应文本
|
|
const text = await response.text()
|
|
|
|
if (!response.ok) {
|
|
let errorMessage = `HTTP ${response.status}: ${response.statusText}`
|
|
|
|
// 尝试解析错误响应
|
|
if (contentType?.includes("application/json") && text) {
|
|
try {
|
|
const error = JSON.parse(text)
|
|
errorMessage = error.detail || error.message || errorMessage
|
|
} catch (e) {
|
|
console.error("Failed to parse error response as JSON:", e)
|
|
console.error("Response text:", text.substring(0, 200))
|
|
}
|
|
} else {
|
|
console.error("Non-JSON error response:", text.substring(0, 200))
|
|
}
|
|
|
|
throw new Error(errorMessage)
|
|
}
|
|
|
|
// 检查响应是否为JSON
|
|
if (!contentType?.includes("application/json")) {
|
|
console.error("Expected JSON but got:", contentType)
|
|
console.error("Response preview:", text.substring(0, 200))
|
|
throw new Error(`Server returned non-JSON response. Content-Type: ${contentType || 'unknown'}`)
|
|
}
|
|
|
|
// 解析JSON
|
|
try {
|
|
return JSON.parse(text) as T
|
|
} catch (e) {
|
|
console.error("Failed to parse JSON response:", e)
|
|
console.error("Response text:", text.substring(0, 300))
|
|
throw new Error("Invalid JSON response from server")
|
|
}
|
|
}
|
|
|
|
// Helper function to check if backend is reachable
|
|
async function checkBackendReachable(url: string): Promise<boolean> {
|
|
try {
|
|
const controller = new AbortController()
|
|
const timeoutId = setTimeout(() => controller.abort(), 5000) // 5 second timeout
|
|
const response = await fetch(url, {
|
|
method: "HEAD",
|
|
signal: controller.signal,
|
|
})
|
|
clearTimeout(timeoutId)
|
|
return response.ok || response.status < 500
|
|
} catch {
|
|
return false
|
|
}
|
|
}
|
|
|
|
export class TaijiAPIClient {
|
|
// ==================== 认证模块 API ====================
|
|
// Base URL: http://localhost:8002/api/auth
|
|
|
|
/**
|
|
* 用户登录
|
|
*/
|
|
static async login(
|
|
email: string,
|
|
password: string,
|
|
role: "user" | "channel" | "admin" | "super_admin" | "billing_admin" | "operations_admin" | "provider" = "user",
|
|
): Promise<APIResponse<{ token: string; refreshToken?: string; user?: any }>> {
|
|
try {
|
|
// 清除所有旧的token（防止多用户登录时token重复）
|
|
clearAllTokens()
|
|
|
|
// 直接尝试登录，让实际的登录请求来判断连接状态
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/auth/login`, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ email, password, role }),
|
|
signal: AbortSignal.timeout(10000), // 10 second timeout
|
|
})
|
|
const data = await handleResponse<APIResponse<{ token: string; refreshToken?: string; user?: any }>>(response)
|
|
if (data.success && data.data?.token && typeof window !== "undefined") {
|
|
// 根据role存储对应的token
|
|
const tokenKey = role === "channel" ? "channel_token" : role === "admin" ? "admin_token" : "auth_token"
|
|
localStorage.setItem(tokenKey, data.data.token)
|
|
|
|
// 同时保存到 cookie（用于服务器端中间件检查）
|
|
document.cookie = `${tokenKey}=${data.data.token}; path=/; max-age=${7 * 24 * 60 * 60}; SameSite=Lax`
|
|
|
|
if (data.data.refreshToken) {
|
|
localStorage.setItem("refresh_token", data.data.refreshToken)
|
|
}
|
|
if (data.data.user) {
|
|
localStorage.setItem("user", JSON.stringify(data.data.user))
|
|
}
|
|
}
|
|
return data
|
|
} catch (error: any) {
|
|
// 处理网络错误
|
|
if (error.name === "AbortError" || error.message?.includes("timeout")) {
|
|
throw new Error("请求超时，请检查网络连接或后端服务状态")
|
|
}
|
|
if (error.message?.includes("Failed to fetch") || error.name === "TypeError") {
|
|
throw new Error(
|
|
`无法连接到后端服务 (${API_BASE_URLS.mcpServer})。请确保 MCP Server 正在运行。`,
|
|
)
|
|
}
|
|
throw error
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 用户登出
|
|
*/
|
|
static async logout() {
|
|
try {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/auth/logout`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
})
|
|
await handleResponse(response)
|
|
} catch (error) {
|
|
// 即使API调用失败，也要清除本地存储
|
|
console.error("Logout API call failed:", error)
|
|
} finally {
|
|
// 清除所有本地存储的token和用户信息
|
|
clearAllTokens()
|
|
|
|
// 同时清除 cookie
|
|
if (typeof window !== "undefined") {
|
|
document.cookie = "auth_token=; path=/; max-age=0"
|
|
document.cookie = "channel_token=; path=/; max-age=0"
|
|
document.cookie = "admin_token=; path=/; max-age=0"
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 刷新Token
|
|
*/
|
|
static async refreshToken(): Promise<APIResponse<{ token: string; refreshToken?: string }>> {
|
|
try {
|
|
requireAuth()
|
|
} catch (error) {
|
|
throw new Error("无法刷新token：用户未认证。(Cannot refresh token: user not authenticated.)")
|
|
}
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/auth/refresh`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
})
|
|
const data = await handleResponse<APIResponse<{ token: string; refreshToken?: string }>>(response)
|
|
if (data.success && data.data?.token && typeof window !== "undefined") {
|
|
localStorage.setItem("auth_token", data.data.token)
|
|
if (data.data.refreshToken) {
|
|
localStorage.setItem("refresh_token", data.data.refreshToken)
|
|
}
|
|
}
|
|
return data
|
|
}
|
|
|
|
/**
|
|
* 修改密码
|
|
*/
|
|
static async changePassword(oldPassword: string, newPassword: string) {
|
|
try {
|
|
requireAuth()
|
|
} catch (error) {
|
|
throw new Error("无法修改密码：用户未认证。(Cannot change password: user not authenticated.)")
|
|
}
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/auth/password`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({ old_password: oldPassword, new_password: newPassword }),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取API密钥信息
|
|
*/
|
|
static async getApiKeyInfo() {
|
|
try {
|
|
requireAuth()
|
|
} catch (error) {
|
|
throw new Error("无法获取API密钥：用户未认证。(Cannot get API key: user not authenticated.)")
|
|
}
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/auth/keys/info`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 重新生成API密钥
|
|
*/
|
|
static async regenerateApiKey(): Promise<APIResponse<{ apiKey: string; message?: string }>> {
|
|
try {
|
|
requireAuth()
|
|
} catch (error) {
|
|
throw new Error("无法重新生成API密钥：用户未认证。(Cannot regenerate API key: user not authenticated.)")
|
|
}
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/auth/keys/regenerate`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
})
|
|
const data = await handleResponse<APIResponse<{ apiKey: string; message?: string }>>(response)
|
|
if (data.success && data.data?.apiKey && typeof window !== "undefined") {
|
|
localStorage.setItem("api_key", data.data.apiKey)
|
|
}
|
|
return data
|
|
}
|
|
|
|
// ==================== 用户侧平台 API ====================
|
|
// Base URL: http://localhost:8002/api/user
|
|
|
|
/**
|
|
* 获取仪表板统计
|
|
*/
|
|
static async getUserDashboardStats() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/dashboard/stats`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取Agent活动数据
|
|
*/
|
|
static async getUserAgentActivity(period: "7d" | "30d" | "90d" = "7d") {
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/user/agents/activity?period=${period}`,
|
|
{
|
|
headers: buildHeaders(),
|
|
},
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 选择网关类型
|
|
*/
|
|
static async selectGateway(gatewayType: "MCP" | "A2A" | "API") {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/gateway/select`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({ gatewayType }),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 创建网关API
|
|
*/
|
|
static async createGatewayAPI(name: string, method: "json" | "url", content: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/gateway/api/create`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({ name, method, content }),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取网关API列表
|
|
*/
|
|
static async getGatewayAPIs() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/gateway/apis`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取网关监控数据
|
|
*/
|
|
static async getGatewayMonitoring() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/gateway/monitoring`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 生成工具
|
|
*/
|
|
static async generateTool(data: {
|
|
name: string
|
|
description: string
|
|
frameworkTemplate: string
|
|
gateway: string
|
|
agentCount: number
|
|
cpu: number
|
|
memory: number
|
|
maxScale: number
|
|
model: string
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/tools/generate`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 创建数据模板
|
|
*/
|
|
static async createDataTemplate(data: {
|
|
name: string
|
|
type: "json_api" | "cloud_storage"
|
|
config: any
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/data-templates/create`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取平台Agent列表
|
|
*/
|
|
static async getPlatformAgents() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/agents/platform`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 部署Agent
|
|
*/
|
|
static async deployAgent(data: {
|
|
agentId: string
|
|
instances: number
|
|
model: string
|
|
gateway: "MCP" | "A2A" | "API"
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/agents/deploy`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 创建工作流
|
|
*/
|
|
static async createWorkflow(data: {
|
|
name: string
|
|
description?: string
|
|
gateway: "MCP" | "A2A" | "API"
|
|
nodes: Array<{
|
|
agentId: string
|
|
agentType: "platform" | "custom"
|
|
agentName: string
|
|
order: number
|
|
}>
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/workflows/create`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取余额信息
|
|
*/
|
|
static async getBillingBalance() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/billing/balance`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 充值余额
|
|
*/
|
|
static async rechargeBalance(amount: number, paymentMethod: "alipay" | "wechat" | "card" = "alipay") {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/user/billing/recharge`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({ amount, paymentMethod }),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取计费历史
|
|
*/
|
|
static async getBillingHistory(params: {
|
|
startTime: string
|
|
endTime: string
|
|
customerName?: string
|
|
minCalls?: number
|
|
maxCalls?: number
|
|
export?: "excel" | "csv" | "pdf"
|
|
page?: number
|
|
pageSize?: number
|
|
}) {
|
|
const queryParams = new URLSearchParams()
|
|
Object.entries(params).forEach(([key, value]) => {
|
|
if (value !== undefined) {
|
|
queryParams.append(key, value.toString())
|
|
}
|
|
})
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/user/billing/history?${queryParams}`,
|
|
{
|
|
headers: buildHeaders(),
|
|
},
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
// ==================== 渠道合作伙伴 API ====================
|
|
// Base URL: http://localhost:8002/api/channel
|
|
|
|
/**
|
|
* 获取租户列表
|
|
*/
|
|
static async getChannelTenants() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 创建租户
|
|
* 前端使用systemRole（系统权限），映射到后端的subscriptionTier
|
|
* 角色映射：tenant->free, admin->pro, billing-admin->enterprise, operations-admin->enterprise
|
|
*/
|
|
static async createChannelTenant(data: {
|
|
name: string
|
|
email: string
|
|
password: string
|
|
systemRole?: "tenant" | "admin" | "billing-admin" | "operations-admin"
|
|
subscriptionTier?: "free" | "pro" | "enterprise"
|
|
}) {
|
|
// 角色到订阅等级的映射
|
|
const roleToTierMap: Record<string, string> = {
|
|
"tenant": "free",
|
|
"admin": "pro",
|
|
"billing-admin": "enterprise",
|
|
"operations-admin": "enterprise"
|
|
}
|
|
|
|
// 构建发送到后端的数据
|
|
const apiData = {
|
|
name: data.name,
|
|
email: data.email,
|
|
password: data.password,
|
|
subscriptionTier: data.subscriptionTier || (data.systemRole ? roleToTierMap[data.systemRole] : "free")
|
|
}
|
|
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/create`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(apiData),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 分配租户资源
|
|
*/
|
|
static async allocateTenantResources(
|
|
tenantId: string,
|
|
data: {
|
|
agents?: Array<{ agentId: string; quantity: number }>
|
|
models?: Array<{ modelName: string; rpm: number; tpm: number }>
|
|
customAgentResources?: { cpu: number; memory: number }
|
|
},
|
|
) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/${tenantId}/resources`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 更新租户计费设置
|
|
*/
|
|
static async updateTenantBilling(tenantId: string, data: { subscriptionTier?: string; discount?: number }) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/${tenantId}/billing`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 更新租户状态
|
|
*/
|
|
static async updateTenantStatus(tenantId: string, status: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/${tenantId}/status`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({ status }),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 为租户充值
|
|
*/
|
|
static async rechargeTenant(tenantId: string, amount: number) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/${tenantId}/recharge`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({ amount }),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 设置租户授信额度
|
|
*/
|
|
static async setTenantCreditLimit(tenantId: string, creditLimit: number) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/${tenantId}/credit`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({ creditLimit }),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 禁用租户
|
|
*/
|
|
static async disableTenant(tenantId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/${tenantId}/disable`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 启用租户
|
|
*/
|
|
static async enableTenant(tenantId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/${tenantId}/enable`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 删除租户（软删除）
|
|
*/
|
|
static async deleteTenant(tenantId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/tenants/${tenantId}`, {
|
|
method: "DELETE",
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 申请资源
|
|
*/
|
|
static async applyForResources(data: {
|
|
type: "model" | "agent"
|
|
modelName?: string
|
|
rpm?: number
|
|
tpm?: number
|
|
agentType?: string
|
|
quantity?: number
|
|
reason: string
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/resources/apply`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取渠道计费统计
|
|
*/
|
|
static async getChannelBillingStats(params: {
|
|
startTime: string
|
|
endTime: string
|
|
tenantName?: string
|
|
minCalls?: number
|
|
maxCalls?: number
|
|
export?: "excel" | "csv" | "pdf"
|
|
}) {
|
|
const queryParams = new URLSearchParams()
|
|
Object.entries(params).forEach(([key, value]) => {
|
|
if (value !== undefined) {
|
|
queryParams.append(key, value.toString())
|
|
}
|
|
})
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/channel/billing/stats?${queryParams}`,
|
|
{
|
|
headers: buildHeaders(),
|
|
},
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取渠道可用供应商列表
|
|
* GET /api/channel/providers
|
|
* 获取所有可用的模型供应商列表，并标注渠道是否已获得使用授权
|
|
*/
|
|
static async getChannelProviders() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/providers`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 申请使用供应商
|
|
* POST /api/channel/providers/apply
|
|
*/
|
|
static async applyForProvider(data: {
|
|
providerId: string
|
|
requestedRpm?: number
|
|
requestedTpm?: number
|
|
reason: string
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/providers/apply`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取供应商申请列表
|
|
* GET /api/channel/providers/applications
|
|
*/
|
|
static async getChannelProviderApplications(status?: "pending" | "approved" | "rejected") {
|
|
const url = status
|
|
? `${API_BASE_URLS.mcpServer}/api/channel/providers/applications?status=${status}`
|
|
: `${API_BASE_URLS.mcpServer}/api/channel/providers/applications`
|
|
const response = await fetch(url, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取渠道下的管理员列表
|
|
* GET /api/channel/admins
|
|
*/
|
|
static async getChannelAdmins() {
|
|
const url = `${API_BASE_URLS.mcpServer}/api/channel/admins`
|
|
console.log("🌐 API请求: GET", url)
|
|
const headers = buildHeaders()
|
|
console.log("📋 请求头:", headers)
|
|
const response = await fetch(url, { headers })
|
|
console.log("📨 响应状态:", response.status, response.statusText)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 创建渠道下的管理员
|
|
* POST /api/channel/admins/create
|
|
*/
|
|
static async createChannelAdmin(data: {
|
|
name: string
|
|
email: string
|
|
password: string
|
|
role?: "billing_admin" | "operations_admin"
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/channel/admins/create`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
// ==================== 超级管理员 API ====================
|
|
// Base URL: http://localhost:8002/api/admin
|
|
|
|
/**
|
|
* 获取平台统计
|
|
*/
|
|
static async getAdminDashboardStats() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/dashboard/stats`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取管理员列表（仅超级管理员可用）
|
|
*/
|
|
static async getAdmins() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/admins`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 创建管理员（计费管理员/运营管理员）
|
|
*/
|
|
static async createAdmin(data: {
|
|
name: string
|
|
email: string
|
|
password: string
|
|
role: "billing_admin" | "operations_admin"
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/admins/create`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 删除管理员（软删除）
|
|
*/
|
|
static async deleteAdmin(adminId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/admins/${adminId}`, {
|
|
method: "DELETE",
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取渠道列表
|
|
*/
|
|
static async getAdminChannels() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/channels`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 创建渠道
|
|
*/
|
|
static async createAdminChannel(data: {
|
|
name: string
|
|
email: string
|
|
password: string
|
|
commissionRate: number
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/channels/create`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 更新渠道信息
|
|
*/
|
|
static async updateAdminChannel(channelId: string, data: {
|
|
name?: string
|
|
commissionRate?: number
|
|
isActive?: boolean
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/channels/${channelId}`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 删除渠道（软删除）
|
|
*/
|
|
static async deleteAdminChannel(channelId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/channels/${channelId}`, {
|
|
method: "DELETE",
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取渠道供应商授权列表
|
|
* GET /api/admin/providers/access
|
|
*/
|
|
static async getChannelProviderAccess(params?: {
|
|
channelId?: string
|
|
providerId?: string
|
|
status?: "active" | "suspended" | "expired"
|
|
}) {
|
|
const queryParams = new URLSearchParams()
|
|
if (params?.channelId) queryParams.append("channel_id", params.channelId)
|
|
if (params?.providerId) queryParams.append("provider_id", params.providerId)
|
|
if (params?.status) queryParams.append("status", params.status)
|
|
|
|
const url = queryParams.toString()
|
|
? `${API_BASE_URLS.mcpServer}/api/admin/providers/access?${queryParams}`
|
|
: `${API_BASE_URLS.mcpServer}/api/admin/providers/access`
|
|
|
|
const response = await fetch(url, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 更新渠道供应商授权
|
|
* PUT /api/admin/providers/access/{access_id}
|
|
*/
|
|
static async updateChannelProviderAccess(accessId: string, params: {
|
|
status?: "active" | "suspended" | "expired"
|
|
rpmLimit?: number
|
|
tpmLimit?: number
|
|
}) {
|
|
const queryParams = new URLSearchParams()
|
|
if (params.status) queryParams.append("status", params.status)
|
|
if (params.rpmLimit) queryParams.append("rpm_limit", params.rpmLimit.toString())
|
|
if (params.tpmLimit) queryParams.append("tpm_limit", params.tpmLimit.toString())
|
|
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/admin/providers/access/${accessId}?${queryParams}`,
|
|
{
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
}
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 撤销渠道供应商授权
|
|
* DELETE /api/admin/providers/access/{access_id}
|
|
*/
|
|
static async revokeChannelProviderAccess(accessId: string) {
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/admin/providers/access/${accessId}`,
|
|
{
|
|
method: "DELETE",
|
|
headers: buildHeaders(),
|
|
}
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 统一管理渠道资源
|
|
*/
|
|
static async manageChannelResources(
|
|
channelId: string,
|
|
data: {
|
|
models?: string[]
|
|
agents?: Array<{ agentId: string; quantity: number }>
|
|
customAgentResources?: { cpu: number; memory: number }
|
|
channelCredit?: number
|
|
},
|
|
) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/channels/${channelId}/resources`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取所有申请
|
|
*/
|
|
static async getAdminApplications() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/channels/applications`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 审批申请
|
|
*/
|
|
static async reviewApplication(applicationId: string, approved: boolean, reason?: string) {
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/admin/channels/applications/${applicationId}/review`,
|
|
{
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({ approved, reason }),
|
|
},
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取所有模型供应商
|
|
*/
|
|
static async getAdminModelProviders() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/resources/models`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取所有Agent资源
|
|
*/
|
|
static async getAdminAgentResources() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/resources/agents`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 删除Agent资源
|
|
*/
|
|
static async deleteAgentResource(agentId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/resources/agents/${agentId}`, {
|
|
method: "DELETE",
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 更新Agent资源配置
|
|
*/
|
|
static async updateAgentResourceConfig(agentId: string, data: {
|
|
name?: string
|
|
description?: string
|
|
price?: number
|
|
category?: string
|
|
frameworkTemplate?: string
|
|
isActive?: boolean
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/resources/agents/${agentId}/config`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 监控Agent健康状态
|
|
*/
|
|
static async getAdminAgentMonitoring() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/monitoring/agents`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取三维度计费统计
|
|
*/
|
|
static async getAdminBillingOverview(params: {
|
|
startTime: string
|
|
endTime: string
|
|
channelName?: string
|
|
tenantName?: string
|
|
minCalls?: number
|
|
maxCalls?: number
|
|
export?: "excel" | "csv" | "pdf"
|
|
}) {
|
|
const queryParams = new URLSearchParams()
|
|
Object.entries(params).forEach(([key, value]) => {
|
|
if (value !== undefined) {
|
|
queryParams.append(key, value.toString())
|
|
}
|
|
})
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/admin/billing/overview?${queryParams}`,
|
|
{
|
|
headers: buildHeaders(),
|
|
},
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取供应商统计信息
|
|
*/
|
|
static async getAdminProviderStats() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/providers/stats`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取渠道后台简易统计
|
|
*/
|
|
static async getAdminChannelsBackendStats() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/admin/channels/backend/stats`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
// ==================== 供应商管理 API ====================
|
|
// Base URL: http://localhost:8002/api/providers
|
|
|
|
/**
|
|
* 获取模型供应商列表
|
|
*/
|
|
static async getModelProviders() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/providers/models`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 创建模型供应商
|
|
*/
|
|
static async createModelProvider(data: {
|
|
name: string
|
|
provider: "openai" | "anthropic" | "azure" | "google" | "aws"
|
|
apiUrl: string
|
|
apiKey: string
|
|
supportedModels: string[]
|
|
rpm: number
|
|
tpm: number
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/providers/models/create`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取供应商详情
|
|
*/
|
|
static async getProviderDetails(providerId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/providers/models/${providerId}`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 更新供应商配置
|
|
*/
|
|
static async updateProvider(providerId: string, data: {
|
|
name?: string
|
|
provider?: string
|
|
apiUrl?: string
|
|
apiKey?: string
|
|
supportedModels?: string[]
|
|
rpm?: number
|
|
tpm?: number
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/providers/models/${providerId}`, {
|
|
method: "PUT",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 删除供应商
|
|
*/
|
|
static async deleteProvider(providerId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/providers/models/${providerId}`, {
|
|
method: "DELETE",
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 测试供应商连接
|
|
*/
|
|
static async testProviderConnection(providerId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/providers/models/${providerId}/test`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
// ==================== Data Ingestion 服务 API ====================
|
|
// Base URL: http://localhost:8001
|
|
|
|
/**
|
|
* 健康检查
|
|
*/
|
|
static async getHealth() {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/health`)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 同步 RapidAPI
|
|
*/
|
|
static async syncRapidAPI(category?: string, limit = 100) {
|
|
const params = new URLSearchParams()
|
|
if (category) params.append("category", category)
|
|
params.append("limit", limit.toString())
|
|
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/rapidapi/sync?${params}`, {
|
|
method: "POST",
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 测试 RapidAPI 端点
|
|
*/
|
|
static async testRapidAPI(data: {
|
|
endpoint: string
|
|
method: string
|
|
params?: any
|
|
headers?: any
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/rapidapi/test`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 解析 OpenAPI 规范
|
|
*/
|
|
static async parseOpenAPI(url: string) {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/openapi/parse?url=${encodeURIComponent(url)}`, {
|
|
method: "POST",
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* APILLAMA 处理 API 文档
|
|
*/
|
|
static async processAPILLAMA(
|
|
apiDoc: any,
|
|
context?: any,
|
|
outputFormat: "pydantic" | "json_schema" | "openapi" = "json_schema",
|
|
options?: {
|
|
include_examples?: boolean
|
|
enhance_descriptions?: boolean
|
|
validate_schema?: boolean
|
|
},
|
|
) {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/apillama/process`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify({
|
|
api_doc: apiDoc,
|
|
context,
|
|
output_format: outputFormat,
|
|
...options,
|
|
}),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 从 API 端点生成工具定义 (Data Ingestion 服务)
|
|
*/
|
|
static async generateToolFromEndpoint(data: {
|
|
url: string
|
|
method: string
|
|
name: string
|
|
description: string
|
|
parameters?: Array<{
|
|
name: string
|
|
type: string
|
|
location?: "query" | "path" | "header" | "body"
|
|
description?: string
|
|
required?: boolean
|
|
}>
|
|
request_body?: any
|
|
responses?: any
|
|
security?: any[]
|
|
tags?: string[]
|
|
deprecated?: boolean
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/tools/generate`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取工具列表
|
|
*/
|
|
static async getTools(category?: string, limit = 100, offset = 0) {
|
|
const params = new URLSearchParams({ limit: limit.toString(), offset: offset.toString() })
|
|
if (category) params.append("category", category)
|
|
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/tools?${params}`)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取特定工具定义
|
|
*/
|
|
static async getTool(toolName: string) {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/tools/${toolName}`)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 删除工具
|
|
*/
|
|
static async deleteTool(toolName: string) {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/tools/${toolName}`, {
|
|
method: "DELETE",
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取统计信息
|
|
*/
|
|
static async getStats() {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/stats`)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 清除缓存
|
|
*/
|
|
static async clearCache() {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/cache/clear`, {
|
|
method: "POST",
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取 Prometheus Metrics
|
|
*/
|
|
static async getMetrics() {
|
|
const response = await fetch(`${API_BASE_URLS.dataIngestion}/metrics`)
|
|
return response.text()
|
|
}
|
|
|
|
// ==================== MCP Server 服务 API ====================
|
|
// Base URL: http://localhost:8000
|
|
|
|
/**
|
|
* MCP Server 健康检查
|
|
*/
|
|
static async getMCPHealth() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/health`)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 注册 Agent
|
|
*/
|
|
static async registerAgent(data: {
|
|
name: string
|
|
description: string
|
|
role?: string
|
|
goal?: string
|
|
tools?: string[]
|
|
config?: any
|
|
capabilities?: string[]
|
|
}) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/agents`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(data),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取 Agent 列表
|
|
*/
|
|
static async getAgents(skip = 0, limit = 100) {
|
|
const params = new URLSearchParams({ skip: skip.toString(), limit: limit.toString() })
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/agents?${params}`)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取特定 Agent
|
|
*/
|
|
static async getAgent(agentId: string) {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/agents/${agentId}`)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 执行 Agent 工具
|
|
*/
|
|
static async executeAgentTool(agentId: string, data: {
|
|
jsonrpc?: string
|
|
id?: string
|
|
method: string
|
|
params: {
|
|
tool: { name: string; function_name?: string }
|
|
arguments: any
|
|
context?: any
|
|
}
|
|
}) {
|
|
// 构建请求体，如果data中已有jsonrpc和id则使用，否则使用默认值
|
|
const requestBody = {
|
|
jsonrpc: data.jsonrpc || "2.0",
|
|
id: data.id || `req-${Date.now()}`,
|
|
method: data.method,
|
|
params: data.params,
|
|
}
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/agents/${agentId}/execute`, {
|
|
method: "POST",
|
|
headers: buildHeaders(),
|
|
body: JSON.stringify(requestBody),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取工具列表 (MCP Server)
|
|
*/
|
|
static async getMCPTools() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/tools`)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取 MCP Prometheus Metrics
|
|
*/
|
|
static async getMCPMetrics() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/metrics`)
|
|
return response.text()
|
|
}
|
|
|
|
/**
|
|
* 获取系统性能指标
|
|
*/
|
|
static async getMonitoringMetrics() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/v1/monitoring/metrics`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取服务统计信息
|
|
*/
|
|
static async getMonitoringStats(service: "all" | "agents" | "executions" | "tools" | "users" = "all") {
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/v1/monitoring/stats?service=${service}`,
|
|
{
|
|
headers: buildHeaders(),
|
|
},
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取性能趋势数据
|
|
*/
|
|
static async getMonitoringTrends(params: {
|
|
metric?: "executions" | "eu_consumption"
|
|
period?: "24h" | "7d" | "30d"
|
|
interval?: "1h" | "6h" | "1d"
|
|
}) {
|
|
const queryParams = new URLSearchParams()
|
|
Object.entries(params).forEach(([key, value]) => {
|
|
if (value) {
|
|
queryParams.append(key, value)
|
|
}
|
|
})
|
|
const response = await fetch(
|
|
`${API_BASE_URLS.mcpServer}/api/v1/monitoring/trends?${queryParams}`,
|
|
{
|
|
headers: buildHeaders(),
|
|
},
|
|
)
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取系统告警
|
|
*/
|
|
static async getMonitoringAlerts(severity?: "info" | "warning" | "critical") {
|
|
const params = severity ? `?severity=${severity}` : ""
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/v1/monitoring/alerts${params}`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
/**
|
|
* 获取监控仪表盘聚合
|
|
*/
|
|
static async getMonitoringDashboard() {
|
|
const response = await fetch(`${API_BASE_URLS.mcpServer}/api/v1/monitoring/dashboard`, {
|
|
headers: buildHeaders(),
|
|
})
|
|
return handleResponse(response)
|
|
}
|
|
|
|
// ==================== WebSocket API ====================
|
|
|
|
/**
|
|
* 创建 Agent WebSocket 连接
|
|
*/
|
|
static createAgentWebSocket(agentIdOrName: string) {
|
|
const wsUrl = API_BASE_URLS.mcpServer.replace("http", "ws")
|
|
return new WebSocket(`${wsUrl}/ws/${agentIdOrName}`)
|
|
}
|
|
}
|