From 9acc69d4c7128ef9753e5c557352d6ca22aacd4c Mon Sep 17 00:00:00 2001 From: WangLX <519407855@qq.com> Date: Mon, 28 Sep 2026 04:55:00 +0800 Subject: [PATCH] fix: classify upstream failures and prevent empty billed responses --- .../gateway/ChatStreamCollector.java | 51 ++- .../gateway/GatewayController.java | 37 ++- .../controlplane/gateway/GatewayGuard.java | 96 ++++-- .../provider/OpenAiCompatibleProvider.java | 54 +++- .../task/AsyncProviderClient.java | 15 +- .../controlplane/task/AsyncTaskService.java | 128 +++++--- .../controlplane/usage/UsageAuditService.java | 79 ++++- .../src/main/resources/application.yml | 1 + .../V26__async_task_poll_deadlines.sql | 10 + .../src/main/resources/redis/acquire-pair.lua | 14 +- .../gateway/ChatStreamingTest.java | 28 +- .../gateway/GatewayDeploymentTest.java | 85 +++++ .../ProviderErrorClassificationTest.java | 21 ++ .../task/AsyncProviderClientTest.java | 77 +++++ .../task/AsyncTaskPostgresTest.java | 186 +++++++++++ .../usage/UsageCapacityPostgresTest.java | 83 +++++ infra/moyi/.env.cloud.example | 3 + infra/moyi/admin_credentials.py | 10 +- infra/moyi/deploy.py | 10 + infra/moyi/docker-compose.cloud.yml | 1 + infra/moyi/tests/test_deploy.py | 19 ++ prototype/src/services/catalog.ts | 15 +- prototype/src/services/model-catalog.ts | 57 +++- prototype/src/views/AdminConsole.vue | 39 ++- prototype/src/views/UserConsole.vue | 37 ++- prototype/tests/model-catalog.test.mjs | 53 ++- scripts/live-catalog-audit.py | 306 ++++++++++++++++++ scripts/test_live_catalog_audit.py | 65 ++++ 28 files changed, 1449 insertions(+), 131 deletions(-) create mode 100644 control-plane-java/src/main/resources/db/migration/V26__async_task_poll_deadlines.sql create mode 100644 control-plane-java/src/test/java/com/moyi/controlplane/task/AsyncProviderClientTest.java create mode 100644 control-plane-java/src/test/java/com/moyi/controlplane/task/AsyncTaskPostgresTest.java create mode 100644 control-plane-java/src/test/java/com/moyi/controlplane/usage/UsageCapacityPostgresTest.java create mode 100644 scripts/live-catalog-audit.py create mode 100644 scripts/test_live_catalog_audit.py diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/gateway/ChatStreamCollector.java b/control-plane-java/src/main/java/com/moyi/controlplane/gateway/ChatStreamCollector.java index 4f939e4..fee4b76 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/gateway/ChatStreamCollector.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/gateway/ChatStreamCollector.java @@ -20,7 +20,10 @@ final class ChatStreamCollector { if(!(raw instanceof Map choice)) continue; if(choice.get("finish_reason")!=null) finish=choice.get("finish_reason"); if(choice.get("delta") instanceof Map delta) { - append(content,delta.get("content")); append(reasoning,delta.get("reasoning_content")); + appendContent(delta.get("content")); + appendReasoning(delta.get("reasoning_content")); + appendReasoning(delta.get("reasoning")); + appendReasoning(delta.get("thinking")); if(delta.get("tool_calls") instanceof List calls) for(Object item:calls) { if(!(item instanceof Map call) || !(call.get("index") instanceof Number index)) continue; int i=index.intValue(); @@ -35,14 +38,55 @@ final class ChatStreamCollector { } } } - if(firstToken==null && ((delta.get("content") instanceof String s && !s.isEmpty()) || (delta.get("reasoning_content") instanceof String r && !r.isEmpty()) || delta.get("tool_calls")!=null)) firstToken=(int)(System.currentTimeMillis()-started); + if(firstToken==null && (hasText(delta.get("content")) || hasText(delta.get("reasoning_content")) + || hasText(delta.get("reasoning")) || hasText(delta.get("thinking")) + || (delta.get("tool_calls") instanceof List calls && !calls.isEmpty()))) + firstToken=(int)(System.currentTimeMillis()-started); } } } - private void append(StringBuilder target,Object value) { if(value instanceof String s && target.length()<8000) target.append(s,0,Math.min(s.length(),8000-target.length())); } + private void appendContent(Object value) { + if(value instanceof String) { append(content,value); return; } + if(value instanceof List parts) for(Object part:parts) { + if(part instanceof Map map) { + Object type=map.get("type"); + if(isReasoningType(type)) { + appendReasoning(firstString(map,"text","thinking","content","reasoning")); + } else { + append(content,firstString(map,"text","content")); + } + } else append(content,part); + } + } + private void appendReasoning(Object value) { append(reasoning,value); } + private void append(StringBuilder target,Object value) { + if(value instanceof String s && target.length()<8000) target.append(s,0,Math.min(s.length(),8000-target.length())); + } + private boolean hasText(Object value) { + if(value instanceof String text) return !text.isBlank(); + if(value instanceof List parts) for(Object part:parts) { + if(part instanceof Map map) { + if(isReasoningType(map.get("type"))) { + if(hasText(firstString(map,"text","thinking","content","reasoning"))) return true; + } else if(hasText(firstString(map,"text","content"))) return true; + } else if(hasText(part)) return true; + } + return false; + } + private boolean isReasoningType(Object type) { + if(type==null) return false; + String normalized=String.valueOf(type).toLowerCase(Locale.ROOT); + return normalized.equals("thinking") || normalized.equals("reasoning") || normalized.equals("reasoning_content"); + } + private String firstString(Map map,String... names) { + for(String name:names) if(map.get(name) instanceof String text) return text; + return ""; + } Integer firstTokenMs() { return firstToken; } Map result() { if(finish==null) throw new ApiException("UPSTREAM_STREAM_INCOMPLETE","上游未完成输出,本次未扣费",502); + if(content.toString().isBlank() && reasoning.toString().isBlank() && !hasToolOutput()) + throw new ApiException("UPSTREAM_RESPONSE_INVALID","上游未返回完整的聊天结果,本次未扣费",502); var message=new LinkedHashMap(); message.put("role","assistant"); message.put("content",content.toString()); if(!reasoning.isEmpty()) message.put("reasoning_content",reasoning.toString()); if(!tools.isEmpty()) message.put("tool_calls",List.copyOf(tools.values())); @@ -50,4 +94,5 @@ final class ChatStreamCollector { result.put("usage",usage); result.put("choices",List.of(Map.of("index",0,"message",message,"finish_reason",finish))); return result; } + private boolean hasToolOutput() { return tools.values().stream().anyMatch(tool -> !tool.isEmpty()); } } diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/gateway/GatewayController.java b/control-plane-java/src/main/java/com/moyi/controlplane/gateway/GatewayController.java index 37661a9..498cc3e 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/gateway/GatewayController.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/gateway/GatewayController.java @@ -162,9 +162,44 @@ public class GatewayController { private int elapsed(long started) { return (int)Math.min(Integer.MAX_VALUE,System.currentTimeMillis()-started); } private void requireCompletion(Map body) { if(body.containsKey("error") || !(body.get("choices") instanceof List choices) || choices.isEmpty() - || !(choices.getFirst() instanceof Map choice) || choice.get("finish_reason")==null) + || !(choices.getFirst() instanceof Map choice) || choice.get("finish_reason")==null || !hasAssistantOutput(choice.get("message"))) throw new ApiException("UPSTREAM_RESPONSE_INVALID","上游未返回完整的聊天结果,本次未扣费",502); } + + /** + * Reasoning models may finish with an empty final content field while + * returning reasoning_content. That is a valid, billable upstream result + * and the UI renders the reasoning separately. A response with neither + * content, reasoning, nor tool calls is a genuine empty response and must + * not be settled as a successful paid call. + */ + private boolean hasAssistantOutput(Object rawMessage) { + if (!(rawMessage instanceof Map message)) return false; + if (hasAssistantValue(message.get("content"))) return true; + for (String field : List.of("reasoning_content", "reasoning", "thinking")) { + if (hasText(message.get(field))) return true; + } + if (message.get("tool_calls") instanceof List calls) { + return calls.stream().anyMatch(call -> call instanceof Map item && !item.isEmpty()); + } + return false; + } + + private boolean hasAssistantValue(Object value) { + if (hasText(value)) return true; + if (!(value instanceof List parts)) return false; + return parts.stream().anyMatch(part -> { + if (!(part instanceof Map map)) return hasText(part); + for (String field : List.of("text", "content", "thinking", "reasoning", "reasoning_content")) { + if (hasText(map.get(field))) return true; + } + return false; + }); + } + + private boolean hasText(Object value) { + return value instanceof String text && !text.isBlank(); + } private Map mockResponse(String modelId,Map input) { String prompt = extractPrompt(input.get("messages")); String content = "MOYI Java Mock 已收到:" + (prompt.isBlank() ? "(空消息)" : prompt); diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/gateway/GatewayGuard.java b/control-plane-java/src/main/java/com/moyi/controlplane/gateway/GatewayGuard.java index 434838d..ac4ef94 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/gateway/GatewayGuard.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/gateway/GatewayGuard.java @@ -1,6 +1,8 @@ package com.moyi.controlplane.gateway; import java.util.List; +import java.util.ArrayList; +import java.util.LinkedHashMap; import java.util.Map; import java.util.UUID; import java.util.concurrent.atomic.AtomicBoolean; @@ -21,6 +23,15 @@ public class GatewayGuard { private static final DefaultRedisScript RATE = script("redis/rate-limit.lua"); private static final DefaultRedisScript ACQUIRE = script("redis/acquire-slot.lua"); private static final DefaultRedisScript ACQUIRE_PAIR = script("redis/acquire-pair.lua"); + private static final DefaultRedisScript CAPACITY = new DefaultRedisScript<>(""" + local time = redis.call('TIME') + local now = tonumber(time[1]) * 1000 + math.floor(tonumber(time[2]) / 1000) + local counts = {} + for i, key in ipairs(KEYS) do + counts[i] = redis.call('ZCOUNT', key, '(' .. now, '+inf') + end + return counts + """, List.class); private static final DefaultRedisScript RELEASE = new DefaultRedisScript<>("return redis.call('ZREM', KEYS[1], ARGV[1])", Long.class); private final StringRedisTemplate redis; private final int requestsPerMinute; @@ -118,29 +129,64 @@ public class GatewayGuard { public long queueWaitMs() { return queueWaitMs; } + public int defaultModelConcurrency() { return defaultModelConcurrency; } + public int defaultKeyConcurrency() { return defaultKeyConcurrency; } + + public record Capacity(long running, long queued) {} + public record CapacitySnapshot(boolean available, Map groups) {} + + /** Reads live leases rather than historical usage rows. Expired workers do not count as running. */ + public CapacitySnapshot capacitySnapshot(List modelIds) { + if (modelIds.isEmpty()) return new CapacitySnapshot(true, Map.of()); + List buckets = new ArrayList<>(); + for (String id : modelIds) { + buckets.add(redisPrefix + "gateway:slots:model:" + id); + buckets.add(redisPrefix + "gateway:waiting:model:" + id); + } + try { + List counts = redis.execute(CAPACITY, buckets); + if (counts == null || counts.size() != buckets.size()) return new CapacitySnapshot(false, Map.of()); + Map groups = new LinkedHashMap<>(); + for (int index = 0; index < modelIds.size(); index++) { + groups.put(modelIds.get(index), new Capacity(((Number) counts.get(index * 2)).longValue(), ((Number) counts.get(index * 2 + 1)).longValue())); + } + return new CapacitySnapshot(true, groups); + } catch (DataAccessException exception) { + log.warn("Gateway capacity snapshot unavailable ({})", exception.getClass().getSimpleName()); + return new CapacitySnapshot(false, Map.of()); + } + } + /** Atomically reserves the model and API-Key slots, so queued requests do not hold one scarce slot while waiting for the other. */ public Admission acquire(Map model, UUID keyId, long requestedWaitMs) { String modelBucket = redisPrefix + "gateway:slots:model:" + model.get("id"); String keyBucket = redisPrefix + "gateway:slots:key:" + keyId; + String waitingBucket = redisPrefix + "gateway:waiting:model:" + model.get("id"); String token = UUID.randomUUID().toString(); long waitMs = Math.max(0, Math.min(queueWaitMs, requestedWaitMs > 0 ? requestedWaitMs : queueWaitMs)); long deadline = System.nanoTime() + java.util.concurrent.TimeUnit.MILLISECONDS.toNanos(waitMs); - long lastBusyCode = 0; - while (true) { - long acquired = executePair(modelBucket, keyBucket, Integer.toString(modelConcurrency(model)), Integer.toString(defaultKeyConcurrency), Long.toString(SLOT_TTL_MS), token); - if (acquired == 1) return new Admission(modelBucket, keyBucket, token); - lastBusyCode = acquired; - if (waitMs == 0 || System.nanoTime() >= deadline) { - boolean keyBusy = lastBusyCode == 2; - throw new GatewayLimitException(keyBusy ? "KEY_BUSY" : "MODEL_BUSY", keyBusy ? "当前 API Key 并发已满,已排队等待但仍未获得资源" : "当前模型分组并发已满,已排队等待但仍未获得资源", 429, Math.max(1, (int) Math.ceil(queuePollMs / 1000.0))); - } - try { - long remaining = java.util.concurrent.TimeUnit.NANOSECONDS.toMillis(deadline - System.nanoTime()); - Thread.sleep(Math.max(1, Math.min(queuePollMs, remaining))); - } catch (InterruptedException exception) { - Thread.currentThread().interrupt(); - throw new GatewayLimitException("MODEL_BUSY", "排队被中断,请稍后重试", 429, 1); + boolean admitted = false; + try { + while (true) { + long remaining = Math.max(0, java.util.concurrent.TimeUnit.NANOSECONDS.toMillis(deadline - System.nanoTime())); + long acquired = executePair(modelBucket, keyBucket, waitingBucket, Integer.toString(modelConcurrency(model)), Integer.toString(defaultKeyConcurrency), Long.toString(SLOT_TTL_MS), token, Long.toString(remaining), Long.toString(Math.max(SLOT_TTL_MS, waitMs + 1000))); + if (acquired == 1) { + admitted = true; // The acquisition script also removed the waiting entry. + return new Admission(modelBucket, keyBucket, token); + } + if (waitMs == 0 || System.nanoTime() >= deadline) { + boolean keyBusy = acquired == 2; + throw new GatewayLimitException(keyBusy ? "KEY_BUSY" : "MODEL_BUSY", keyBusy ? "当前 API Key 并发已满,已排队等待但仍未获得资源" : "当前模型分组并发已满,已排队等待但仍未获得资源", 429, Math.max(1, (int) Math.ceil(queuePollMs / 1000.0))); + } + try { + Thread.sleep(Math.max(1, Math.min(queuePollMs, remaining))); + } catch (InterruptedException exception) { + Thread.currentThread().interrupt(); + throw new GatewayLimitException("MODEL_BUSY", "排队被中断,请稍后重试", 429, 1); + } } + } finally { + if (!admitted && waitMs > 0) releaseQuietly(waitingBucket, token); } } @@ -174,9 +220,9 @@ public class GatewayGuard { throw new GatewayLimitException("GATEWAY_GUARD_UNAVAILABLE", "网关流量控制暂不可用,请稍后重试", 503, 3); } - private long executePair(String modelKey, String keyKey, String modelLimit, String keyLimit, String ttl, String token) { + private long executePair(String modelKey, String keyKey, String waitingKey, String modelLimit, String keyLimit, String ttl, String token, String waitMs, String waitingTtl) { try { - Long value = redis.execute(ACQUIRE_PAIR, List.of(modelKey, keyKey), modelLimit, keyLimit, ttl, token); + Long value = redis.execute(ACQUIRE_PAIR, List.of(modelKey, keyKey, waitingKey), modelLimit, keyLimit, ttl, token, waitMs, waitingTtl); if (value != null) return value; } catch (DataAccessException exception) { log.warn("Gateway pair admission Redis operation failed ({})", exception.getClass().getSimpleName()); @@ -184,6 +230,14 @@ public class GatewayGuard { throw new GatewayLimitException("GATEWAY_GUARD_UNAVAILABLE", "网关流量控制暂不可用,请稍后重试", 503, 3); } + private void releaseQuietly(String bucket, String token) { + try { + execute(RELEASE, bucket, token); + } catch (GatewayLimitException exception) { + log.warn("Gateway concurrency entry release failed; waiting for lease expiry"); + } + } + public final class Admission implements AutoCloseable { private final Slot modelSlot; private final Slot keySlot; @@ -212,12 +266,8 @@ public class GatewayGuard { @Override public void close() { if (!closed.compareAndSet(false, true)) return; - try { - execute(RELEASE, key, token); - } catch (GatewayLimitException exception) { - // A failed release expires automatically and must not replace the upstream response. - log.warn("Gateway concurrency slot release failed; waiting for lease expiry"); - } + // A failed release expires automatically and must not replace the upstream response. + releaseQuietly(key, token); } } } diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/provider/OpenAiCompatibleProvider.java b/control-plane-java/src/main/java/com/moyi/controlplane/provider/OpenAiCompatibleProvider.java index 06fb055..b880e9f 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/provider/OpenAiCompatibleProvider.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/provider/OpenAiCompatibleProvider.java @@ -5,9 +5,11 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.moyi.controlplane.common.ApiException; import com.moyi.controlplane.security.SecretCipher; import java.net.URI; +import java.net.SocketTimeoutException; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; +import java.net.http.HttpTimeoutException; import java.io.*; import java.nio.charset.StandardCharsets; import java.time.Duration; @@ -67,8 +69,13 @@ public class OpenAiCompatibleProvider { try(var response=open(providerId,upstreamModel,input,false)) { byte[] bytes=response.body.readNBytes(4*1024*1024+1); if(bytes.length>4*1024*1024) throw new ApiException("UPSTREAM_RESPONSE_TOO_LARGE","上游响应超过限制",502); - return objectMapper.readValue(bytes, new com.fasterxml.jackson.core.type.TypeReference<>() {}); + Map body=objectMapper.readValue(bytes, new com.fasterxml.jackson.core.type.TypeReference<>() {}); + if(body.containsKey("error")) throw classifyUpstreamError(200,writeJson(body)); + return body; } catch(ApiException e) { throw e; } + catch(HttpTimeoutException | SocketTimeoutException e) { + throw new ApiException("UPSTREAM_PROVIDER_TIMEOUT","上游模型供应商响应超时",504); + } catch(Exception e) { throw classifyUpstreamError(502, ""); } } @@ -109,6 +116,8 @@ public class OpenAiCompatibleProvider { return new StreamResponse(response.body(),Math.max(1,timeoutSeconds*1000L-TimeUnit.NANOSECONDS.toMillis(System.nanoTime()-started))); } catch (ApiException exception) { throw exception; + } catch (HttpTimeoutException | SocketTimeoutException exception) { + throw new ApiException("UPSTREAM_PROVIDER_TIMEOUT", "上游模型供应商响应超时", 504); } catch (InterruptedException exception) { Thread.currentThread().interrupt(); throw new ApiException("UPSTREAM_PROVIDER_TIMEOUT", "上游模型供应商请求被中断", 502); @@ -131,23 +140,28 @@ public class OpenAiCompatibleProvider { StringBuilder event=new StringBuilder(), line=new StringBuilder(); long total=0; int c; - // Bound both individual frames and the whole response before allocating unbounded strings. - while((c=reader.read())!=-1) { + try { + // Bound both individual frames and the whole response before allocating unbounded strings. + while((c=reader.read())!=-1) { + if(expired.get()) throw new ApiException("UPSTREAM_PROVIDER_TIMEOUT","上游响应超时,本次未扣费",504); + if(++total>4*1024*1024 || line.length()>262144 || event.length()>262144) throw new ApiException("UPSTREAM_RESPONSE_TOO_LARGE","上游响应超过限制",502); + if(c=='\n') { + String text=line.toString(); line.setLength(0); + if(text.endsWith("\r")) text=text.substring(0,text.length()-1); + if(text.isEmpty()) { + if(!event.isEmpty()) { + String data=event.substring(0,event.length()-1); event.setLength(0); + if("[DONE]".equals(data)) return; + Map chunk=objectMapper.readValue(data,new com.fasterxml.jackson.core.type.TypeReference<>(){}); + if(chunk.containsKey("error")) throw classifyUpstreamError(502, writeJson(chunk)); + consumer.accept(chunk); + } + } else if(text.startsWith("data:")) event.append(text.substring(5).stripLeading()).append('\n'); + } else line.append((char)c); + } + } catch(IOException exception) { if(expired.get()) throw new ApiException("UPSTREAM_PROVIDER_TIMEOUT","上游响应超时,本次未扣费",504); - if(++total>4*1024*1024 || line.length()>262144 || event.length()>262144) throw new ApiException("UPSTREAM_RESPONSE_TOO_LARGE","上游响应超过限制",502); - if(c=='\n') { - String text=line.toString(); line.setLength(0); - if(text.endsWith("\r")) text=text.substring(0,text.length()-1); - if(text.isEmpty()) { - if(!event.isEmpty()) { - String data=event.substring(0,event.length()-1); event.setLength(0); - if("[DONE]".equals(data)) return; - Map chunk=objectMapper.readValue(data,new com.fasterxml.jackson.core.type.TypeReference<>(){}); - if(chunk.containsKey("error")) throw classifyUpstreamError(502, writeJson(chunk)); - consumer.accept(chunk); - } - } else if(text.startsWith("data:")) event.append(text.substring(5).stripLeading()).append('\n'); - } else line.append((char)c); + throw exception; } throw new ApiException(expired.get()?"UPSTREAM_PROVIDER_TIMEOUT":"UPSTREAM_STREAM_INCOMPLETE","上游流式响应中断,本次未扣费",502); } @@ -169,6 +183,9 @@ public class OpenAiCompatibleProvider { */ static ApiException classifyUpstreamError(int status, String body) { String details = body == null ? "" : body.toLowerCase(java.util.Locale.ROOT); + if (status == 408 || status == 504 || details.matches(".*(request|gateway|upstream).{0,12}(timed out|timeout|超时).*")) { + return new ApiException("UPSTREAM_PROVIDER_TIMEOUT", "上游模型供应商响应超时", 504); + } if (status == 401 || status == 403 || details.matches(".*(invalid.{0,8}(api[ _-]?key|token)|unauthori[sz]ed|forbidden|无效.*(key|凭据)|无权限|认证失败).*")) { return new ApiException("UPSTREAM_AUTH_FAILED", "上游渠道凭据无效或无权限", 502); } @@ -178,6 +195,9 @@ public class OpenAiCompatibleProvider { if (status == 429 || details.matches(".*(rate.?limit|too many requests|concurr|并发|频率过高|请求过于频繁|限流).*")) { return new ApiException("UPSTREAM_RATE_LIMITED", "上游渠道限流或并发已满,请稍后重试", 429); } + if (status == 404 || details.matches(".*(no available channel|model.{0,16}(not found|does not exist|unavailable)|not_found|unsupported model|没有可用渠道|模型不存在|模型不可用).*")) { + return new ApiException("UPSTREAM_MODEL_UNAVAILABLE", "上游渠道没有可用的模型路由", 502); + } return new ApiException("UPSTREAM_PROVIDER_ERROR", "上游模型供应商请求失败", 502); } diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/task/AsyncProviderClient.java b/control-plane-java/src/main/java/com/moyi/controlplane/task/AsyncProviderClient.java index b99257d..3cccd56 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/task/AsyncProviderClient.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/task/AsyncProviderClient.java @@ -73,12 +73,21 @@ public class AsyncProviderClient { if ("POST".equals(method)) builder.POST(HttpRequest.BodyPublishers.ofString(write(body))); else builder.GET(); HttpResponse response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString()); - if (response.statusCode() < 200 || response.statusCode() >= 300) throw new ApiException("UPSTREAM_PROVIDER_ERROR", message + "(HTTP " + response.statusCode() + ")", 502); + if (response.statusCode() < 200 || response.statusCode() >= 300) { + String code = switch (response.statusCode()) { + case 401, 403 -> "UPSTREAM_AUTH_FAILED"; + case 402 -> "UPSTREAM_CREDIT_INSUFFICIENT"; + case 429 -> "UPSTREAM_RATE_LIMITED"; + default -> "UPSTREAM_PROVIDER_ERROR"; + }; + throw new ApiException(code, message + "(HTTP " + response.statusCode() + ")", 502); + } Map parsed = mapper.readValue(response.body(), new TypeReference<>() {}); Object code = parsed.get("code"); if (parsed.containsKey("error") || code instanceof Number number && number.intValue() != 0) { - String detail = parsed.get("message") == null ? message : String.valueOf(parsed.get("message")); - throw new ApiException("UPSTREAM_PROVIDER_ERROR", detail, 502); + // Upstream messages can echo credentials or account details. + // Only locally defined diagnostics may reach task history/UI. + throw new ApiException("UPSTREAM_PROVIDER_ERROR", message, 502); } return parsed; } catch (ApiException exception) { throw exception; } diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/task/AsyncTaskService.java b/control-plane-java/src/main/java/com/moyi/controlplane/task/AsyncTaskService.java index e997bde..7f1a311 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/task/AsyncTaskService.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/task/AsyncTaskService.java @@ -35,6 +35,7 @@ public class AsyncTaskService { private final int maxQueuedPerModel; private final int defaultModelConcurrency; private final int defaultKeyConcurrency; + private final long providerTimeoutMs; private final GatewayGuard gatewayGuard; private final UsageAuditService usage; private final AsyncProviderClient providerClient; @@ -43,7 +44,7 @@ public class AsyncTaskService { /** Compatibility constructor for isolated gateway tests that only exercise mock tasks. */ public AsyncTaskService(JdbcTemplate jdbc, ObjectMapper objectMapper, CatalogService catalogService, int maxQueuedPerModel, GatewayGuard gatewayGuard, UsageAuditService usage) { - this(jdbc, objectMapper, catalogService, maxQueuedPerModel, 4, 4, gatewayGuard, usage, null, null); + this(jdbc, objectMapper, catalogService, maxQueuedPerModel, 4, 4, 3_600_000, gatewayGuard, usage, null, null); } @org.springframework.beans.factory.annotation.Autowired @@ -54,18 +55,21 @@ public class AsyncTaskService { @Value("${moyi.tasks.max-queued-per-model:100}") int maxQueuedPerModel, @Value("${moyi.gateway.default-model-concurrency:4}") int defaultModelConcurrency, @Value("${moyi.gateway.default-key-concurrency:4}") int defaultKeyConcurrency, + @Value("${moyi.tasks.provider-timeout-ms:3600000}") long providerTimeoutMs, GatewayGuard gatewayGuard, UsageAuditService usage, AsyncProviderClient providerClient, PlatformTransactionManager transactionManager ) { if (maxQueuedPerModel < 1 || defaultModelConcurrency < 1 || defaultKeyConcurrency < 1) throw new IllegalArgumentException("Task queue and concurrency limits must be positive"); + if (providerTimeoutMs < 1_000) throw new IllegalArgumentException("Provider task timeout must be at least one second"); this.jdbc = jdbc; this.objectMapper = objectMapper; this.catalogService = catalogService; this.maxQueuedPerModel = maxQueuedPerModel; this.defaultModelConcurrency = defaultModelConcurrency; this.defaultKeyConcurrency = defaultKeyConcurrency; + this.providerTimeoutMs = providerTimeoutMs; this.gatewayGuard = gatewayGuard; this.usage = usage; this.providerClient = providerClient; @@ -155,7 +159,7 @@ public class AsyncTaskService { "{\"format\":\"mp4\",\"url\":\"https://mock.moyi.ai/tasks/result.mp4\"}", now(), now() ); taskIds.forEach(taskId -> usage.updateTask(taskId, "succeeded", Map.of("format", "result", "url", "https://mock.moyi.ai/tasks/" + taskId + "/result"), null, null)); - List> pending = jdbc.queryForList("SELECT t.id, t.provider_task_id, m.provider_id FROM model_tasks t JOIN model_catalog m ON m.id=t.model_id WHERE t.status IN ('queued','running') AND t.provider_task_id <> 'mock' ORDER BY t.created_at LIMIT 50"); + List> pending = jdbc.queryForList("SELECT t.id, t.provider_task_id, t.provider_deadline_at, t.created_at, m.provider_id FROM model_tasks t JOIN model_catalog m ON m.id=t.model_id WHERE t.status IN ('queued','running') AND t.provider_task_id <> 'mock' AND (t.updated_at < now() - INTERVAL '5 seconds' OR t.provider_deadline_at <= now()) ORDER BY t.updated_at LIMIT 50"); for (Map row : pending) pollProviderTask(row); dispatchQueuedTasks(); } @@ -185,9 +189,12 @@ public class AsyncTaskService { String.valueOf(task.get("task_type")), String.valueOf(task.get("prompt")) ); - jdbc.update("UPDATE model_tasks SET provider_task_id=?, updated_at=? WHERE id=? AND status='running'", providerTaskId(upstream), now(), taskId); + OffsetDateTime submittedAt = now(); + jdbc.update("UPDATE model_tasks SET provider_task_id=?, provider_deadline_at=?, updated_at=? WHERE id=? AND status='running'", providerTaskId(upstream), submittedAt.plus(java.time.Duration.ofMillis(providerTimeoutMs)), submittedAt, taskId); } catch (RuntimeException exception) { - failTask(taskId, "UPSTREAM_TASK_SUBMIT_FAILED", exception.getMessage() == null ? "上游异步任务创建失败" : exception.getMessage()); + String code = exception instanceof ApiException error ? error.getCode() : "UPSTREAM_TASK_SUBMIT_FAILED"; + String message = exception instanceof ApiException error ? error.getMessage() : "上游异步任务创建失败"; + failTask(taskId, code, message); } } } @@ -236,12 +243,24 @@ public class AsyncTaskService { } private void failTask(String taskId, String code, String message) { - int changed = jdbc.update( - "UPDATE model_tasks SET status='failed', error=CAST(? AS jsonb), updated_at=?, completed_at=? WHERE id=? AND status IN ('queued','running')", - writeJson(Map.of("code", code, "message", message)), now(), now(), taskId); - if (changed == 0) return; - releaseTask(taskId); - usage.updateTask(taskId, "failed", null, code, message); + finishTask(taskId, "failed", 0, null, code, message); + } + + private void finishTask(String taskId, String status, int progress, Map result, String code, String message) { + // The terminal state and wallet change must commit together. Otherwise a + // crash after marking failed/succeeded leaves a hold that polling never + // revisits. The conditional update also prevents duplicate settlement. + inTransaction(() -> { + int changed = jdbc.update( + "UPDATE model_tasks SET status=?, progress=?, result=CAST(? AS jsonb), error=CAST(? AS jsonb), updated_at=?, completed_at=? WHERE id=? AND status IN ('queued','running')", + status, progress, result == null ? null : writeJson(result), + code == null ? null : writeJson(Map.of("code", code, "message", message)), now(), now(), taskId); + if (changed == 0) return null; + if ("succeeded".equals(status)) settleTaskInTransaction(taskId); + else releaseTaskInTransaction(taskId); + usage.updateTask(taskId, status, result, code, message); + return null; + }); } private Map requireKey(String authorization) { @@ -286,27 +305,59 @@ public class AsyncTaskService { private void pollProviderTask(Map row) { String taskId = String.valueOf(row.get("id")); - try { - Map response = providerClient.poll(String.valueOf(row.get("provider_id")), String.valueOf(row.get("provider_task_id"))); - String status = normalizedStatus(response); - int progress = progress(response, status); - Map result = result(response); - if ("succeeded".equals(status) || "failed".equals(status) || "cancelled".equals(status)) { - jdbc.update("UPDATE model_tasks SET status=?, progress=?, result=CAST(? AS jsonb), error=CAST(? AS jsonb), updated_at=?, completed_at=? WHERE id=? AND status IN ('queued','running')", status, progress, result == null ? null : writeJson(result), "failed".equals(status) ? writeJson(Map.of("message", "上游异步任务失败")) : null, now(), now(), taskId); - if ("succeeded".equals(status)) settleTask(taskId); - else releaseTask(taskId); - usage.updateTask(taskId, status, result, "failed".equals(status) ? "UPSTREAM_TASK_FAILED" : null, "failed".equals(status) ? "上游异步任务失败" : null); - } else { - jdbc.update("UPDATE model_tasks SET status=?, progress=?, updated_at=? WHERE id=? AND status IN ('queued','running')", status, progress, now(), taskId); - } - } catch (Exception exception) { - jdbc.update("UPDATE model_tasks SET status='failed', error=CAST(? AS jsonb), updated_at=?, completed_at=? WHERE id=? AND status IN ('queued','running')", writeJson(Map.of("message", "上游异步任务查询失败")), now(), now(), taskId); - // A polling failure is terminal for this task. Release the - // reserved wallet amount as part of the same failure path so a - // transient/provider error cannot permanently lock user credit. - releaseTask(taskId); - usage.updateTask(taskId, "failed", null, "UPSTREAM_TASK_POLL_FAILED", "上游异步任务查询失败"); + OffsetDateTime deadline = taskTimestamp(row.get("provider_deadline_at")); + if (deadline == null) { + // Defensive fallback for pre-migration tasks. The migration also + // persists deadlines so restarting cannot reset their timeout. + OffsetDateTime createdAt = taskTimestamp(row.get("created_at")); + if (createdAt == null) throw new IllegalStateException("Persisted task timestamp is missing"); + deadline = createdAt.plus(java.time.Duration.ofMillis(providerTimeoutMs)); } + if (!now().isBefore(deadline)) { + failTask(taskId, "UPSTREAM_TASK_TIMEOUT", "异步任务查询已超时,执行结果未知;平台冻结额度已释放。上游可能仍在执行,请先核实后再提交"); + return; + } + Map response; + try { + response = providerClient.poll(String.valueOf(row.get("provider_id")), String.valueOf(row.get("provider_task_id"))); + } catch (RuntimeException exception) { + // Even a permanent authentication/configuration error only proves + // that polling failed, not that an already accepted job stopped. + // Keep its hold and retry until the persisted deadline. + String message = exception instanceof ApiException error && "UPSTREAM_AUTH_FAILED".equals(error.getCode()) + ? "上游查询鉴权异常,执行结果尚未确认;正在重试" + : "暂时无法查询上游任务,执行结果尚未确认;正在重试"; + updatePollingState(taskId, null, "UPSTREAM_TASK_POLL_RETRY", message); + return; + } + String status = normalizedStatus(response); + int progress = progress(response, status); + Map result = result(response); + if ("succeeded".equals(status) || "failed".equals(status) || "cancelled".equals(status)) { + // Persistence failures must roll back and remain pollable, rather + // than being mistaken for upstream failures and refunded. + finishTask(taskId, status, progress, result, + "failed".equals(status) ? "UPSTREAM_TASK_FAILED" : null, + "failed".equals(status) ? "上游异步任务失败" : null); + } else { + updatePollingState(taskId, progress, null, null); + } + } + + private void updatePollingState(String taskId, Integer progress, String code, String message) { + inTransaction(() -> { + int changed = jdbc.update("UPDATE model_tasks SET status='running', progress=COALESCE(?,progress), error=CAST(? AS jsonb), updated_at=? WHERE id=? AND status IN ('queued','running')", + progress, code == null ? null : writeJson(Map.of("code", code, "message", message, "retryable", true)), now(), taskId); + if (changed > 0) usage.updateTask(taskId, "running", null, code, message); + return null; + }); + } + + private OffsetDateTime taskTimestamp(Object value) { + if (value == null) return null; + if (value instanceof OffsetDateTime timestamp) return timestamp; + if (value instanceof java.sql.Timestamp timestamp) return timestamp.toInstant().atOffset(ZoneOffset.UTC); + throw new IllegalStateException("Persisted task timestamp is missing"); } private String normalizedStatus(Map response) { @@ -381,14 +432,6 @@ public class AsyncTaskService { if (amount.signum() > 0) jdbc.update("UPDATE user_wallets SET reserved_balance=GREATEST(0,reserved_balance-?),updated_at=now() WHERE user_id=?", amount, userId); } - private void settleTask(String taskId) { - if (transactions == null) { - settleTaskInTransaction(taskId); - return; - } - transactions.executeWithoutResult(status -> settleTaskInTransaction(taskId)); - } - private void settleTaskInTransaction(String taskId) { Map task = jdbc.queryForMap("SELECT user_id,reserved_amount,cost_amount FROM model_tasks WHERE id=? FOR UPDATE", taskId); BigDecimal amount = (BigDecimal) task.get("reserved_amount"); @@ -403,20 +446,13 @@ public class AsyncTaskService { jdbc.update("UPDATE usage_events SET cost_amount=? WHERE provider_task_id=? AND event_kind='task'", amount, taskId); } - private void releaseTask(String taskId) { - if (transactions == null) { - releaseTaskInTransaction(taskId); - return; - } - transactions.executeWithoutResult(status -> releaseTaskInTransaction(taskId)); - } - private void releaseTaskInTransaction(String taskId) { Map task = jdbc.queryForMap("SELECT user_id,reserved_amount,cost_amount FROM model_tasks WHERE id=? FOR UPDATE", taskId); BigDecimal amount = (BigDecimal) task.get("reserved_amount"); if (amount != null && amount.signum() > 0 && task.get("cost_amount") == null) { releaseWallet((UUID) task.get("user_id"), amount); jdbc.update("UPDATE model_tasks SET cost_amount=0 WHERE id=?", taskId); + jdbc.update("UPDATE usage_events SET cost_amount=0 WHERE provider_task_id=? AND event_kind='task'", taskId); } } diff --git a/control-plane-java/src/main/java/com/moyi/controlplane/usage/UsageAuditService.java b/control-plane-java/src/main/java/com/moyi/controlplane/usage/UsageAuditService.java index 02f37f6..68a01fc 100644 --- a/control-plane-java/src/main/java/com/moyi/controlplane/usage/UsageAuditService.java +++ b/control-plane-java/src/main/java/com/moyi/controlplane/usage/UsageAuditService.java @@ -7,6 +7,7 @@ import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; import com.moyi.controlplane.auth.AuthService; import com.moyi.controlplane.common.ApiException; +import com.moyi.controlplane.gateway.GatewayGuard; import java.nio.charset.StandardCharsets; import java.sql.ResultSet; import java.sql.SQLException; @@ -21,16 +22,31 @@ import org.springframework.dao.EmptyResultDataAccessException; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; @Service public class UsageAuditService { private static final int MAX_PAYLOAD_CHARS = 32_000; private final JdbcTemplate jdbc; private final ObjectMapper objectMapper; + private final GatewayGuard gatewayGuard; + private final int asyncQueueLimit; + private final long asyncWorkerIntervalMs; public UsageAuditService(JdbcTemplate jdbc, ObjectMapper objectMapper) { + this(jdbc, objectMapper, null, 100, 1000); + } + + @Autowired + public UsageAuditService(JdbcTemplate jdbc, ObjectMapper objectMapper, GatewayGuard gatewayGuard, + @Value("${moyi.tasks.max-queued-per-model:100}") int asyncQueueLimit, + @Value("${moyi.tasks.worker-interval-ms:1000}") long asyncWorkerIntervalMs) { this.jdbc = jdbc; this.objectMapper = objectMapper; + this.gatewayGuard = gatewayGuard; + this.asyncQueueLimit = asyncQueueLimit; + this.asyncWorkerIntervalMs = asyncWorkerIntervalMs; } public void startChat(UUID id, UUID userId, UUID keyId, Map model, Map input) { @@ -105,7 +121,6 @@ public class UsageAuditService { Map result = new LinkedHashMap<>(); result.put("callsToday", count("SELECT COUNT(*) FROM usage_events WHERE deleted_at IS NULL AND event_kind = 'call' AND created_at >= CURRENT_DATE")); result.put("callsThisMonth", count("SELECT COUNT(*) FROM usage_events WHERE deleted_at IS NULL AND event_kind = 'call' AND created_at >= date_trunc('month', now())")); - result.put("waiting", count("SELECT COUNT(*) FROM usage_events WHERE deleted_at IS NULL AND status IN ('queued','running')")); result.put("costToday", decimal("SELECT COALESCE(SUM(cost_amount),0) FROM usage_events WHERE deleted_at IS NULL AND status = 'succeeded' AND created_at >= CURRENT_DATE")); result.put("costThisMonth", decimal("SELECT COALESCE(SUM(cost_amount),0) FROM usage_events WHERE deleted_at IS NULL AND status = 'succeeded' AND created_at >= date_trunc('month', now())")); result.put("series", jdbc.query( @@ -114,26 +129,70 @@ public class UsageAuditService { "LEFT JOIN usage_events ue ON ue.deleted_at IS NULL AND ue.created_at >= day AND ue.created_at < day + INTERVAL '1 day' " + "GROUP BY day ORDER BY day", (rs, row) -> Map.of("date", rs.getString("day"), "count", rs.getLong("count")))); - result.put("capacityGroups", jdbc.query( - "SELECT m.id, m.public_name, COALESCE(m.max_concurrency, 0) AS max_concurrency, " + - "COUNT(*) FILTER (WHERE ue.status = 'running') AS running, " + - "COUNT(*) FILTER (WHERE ue.status IN ('queued','running')) AS queued " + - "FROM model_catalog m LEFT JOIN usage_events ue ON ue.model_id = m.id " + - "AND ue.deleted_at IS NULL AND ue.created_at >= now() - INTERVAL '10 minutes' " + - "WHERE m.deleted_at IS NULL AND m.status = 'active' " + - "GROUP BY m.id, m.public_name, m.max_concurrency ORDER BY m.public_name LIMIT 100", + int defaultModelLimit = gatewayGuard == null ? 4 : gatewayGuard.defaultModelConcurrency(); + List> groups = jdbc.query(""" + WITH pending AS ( + SELECT model_id, + COUNT(*) FILTER (WHERE status='running') AS running, + COUNT(*) FILTER (WHERE status='queued') AS queued + FROM model_tasks WHERE status IN ('queued','running') GROUP BY model_id + ) + SELECT m.id, m.public_name, m.source_label, p.name AS provider_name, m.call_mode, + COALESCE(NULLIF(m.max_concurrency, 0), ?) AS max_concurrency, + (m.status='active' AND m.deleted_at IS NULL AND p.status='active' AND p.deleted_at IS NULL + AND d.status='active' AND d.deleted_at IS NULL) AS route_enabled, + COALESCE(pending.running, 0) AS running, COALESCE(pending.queued, 0) AS queued + FROM model_catalog m JOIN model_providers p ON p.id=m.provider_id + JOIN model_definitions d ON d.id=m.logical_model_id + LEFT JOIN pending ON pending.model_id=m.id + ORDER BY m.public_name, m.source_label, m.id + """, (rs, row) -> { Map group = new LinkedHashMap<>(); group.put("id", rs.getString("id")); group.put("name", rs.getString("public_name")); + group.put("sourceLabel", rs.getString("source_label")); + group.put("providerName", rs.getString("provider_name")); + group.put("mode", rs.getString("call_mode")); + group.put("routeEnabled", rs.getBoolean("route_enabled")); group.put("limit", rs.getInt("max_concurrency")); group.put("running", rs.getLong("running")); group.put("queued", rs.getLong("queued")); return group; - })); + }, defaultModelLimit); + List synchronousIds = groups.stream().filter(group -> !"async".equals(group.get("mode"))).map(group -> group.get("id").toString()).toList(); + GatewayGuard.CapacitySnapshot snapshot = gatewayGuard == null + ? new GatewayGuard.CapacitySnapshot(false, Map.of()) : gatewayGuard.capacitySnapshot(synchronousIds); + for (Map group : groups) { + if ("async".equals(group.get("mode"))) continue; + GatewayGuard.Capacity current = snapshot.groups().get(group.get("id").toString()); + group.put("running", current == null ? null : current.running()); + group.put("queued", current == null ? null : current.queued()); + } + // Keep disabled groups visible while their queued or running work still exists. + groups = groups.stream().filter(group -> Boolean.TRUE.equals(group.get("routeEnabled")) + || positive(group.get("running")) || positive(group.get("queued"))).toList(); + result.put("capacityGroups", groups); + result.put("running", totalCapacity(groups, "running")); + result.put("waiting", totalCapacity(groups, "queued")); + result.put("capacityConfig", Map.of( + "queueWaitMs", gatewayGuard == null ? 30000 : gatewayGuard.queueWaitMs(), + "defaultModelConcurrency", defaultModelLimit, + "defaultKeyConcurrency", gatewayGuard == null ? 4 : gatewayGuard.defaultKeyConcurrency(), + "asyncQueueLimit", asyncQueueLimit, + "asyncWorkerIntervalMs", asyncWorkerIntervalMs, + "synchronousSnapshotAvailable", snapshot.available() + )); return result; } + private boolean positive(Object value) { return value instanceof Number number && number.longValue() > 0; } + + private Long totalCapacity(List> groups, String field) { + if (groups.stream().anyMatch(group -> group.get(field) == null)) return null; + return groups.stream().mapToLong(group -> ((Number) group.get(field)).longValue()).sum(); + } + private long count(String sql) { Number value = jdbc.queryForObject(sql, Number.class); return value == null ? 0L : value.longValue(); diff --git a/control-plane-java/src/main/resources/application.yml b/control-plane-java/src/main/resources/application.yml index 4d11ab8..d7f4d36 100644 --- a/control-plane-java/src/main/resources/application.yml +++ b/control-plane-java/src/main/resources/application.yml @@ -50,6 +50,7 @@ moyi: tasks: max-queued-per-model: ${TASK_MAX_QUEUED_PER_MODEL:100} worker-interval-ms: ${MOYI_TASK_WORKER_INTERVAL_MS:1000} + provider-timeout-ms: ${MOYI_TASK_PROVIDER_TIMEOUT_MS:3600000} web: cors-origins: ${CONTROL_PLANE_CORS_ORIGINS:http://localhost:5173,http://127.0.0.1:5173} auth: diff --git a/control-plane-java/src/main/resources/db/migration/V26__async_task_poll_deadlines.sql b/control-plane-java/src/main/resources/db/migration/V26__async_task_poll_deadlines.sql new file mode 100644 index 0000000..2447dbb --- /dev/null +++ b/control-plane-java/src/main/resources/db/migration/V26__async_task_poll_deadlines.sql @@ -0,0 +1,10 @@ +-- Persist the polling deadline: process restarts must not reset the timeout. +ALTER TABLE model_tasks ADD COLUMN provider_deadline_at timestamptz; + +-- Existing accepted tasks also need a finite deadline. Unsubmitted queued +-- tasks receive theirs only after the upstream accepts their submission. +UPDATE model_tasks + SET provider_deadline_at = created_at + INTERVAL '1 hour' + WHERE status IN ('queued', 'running') + AND provider_task_id IS NOT NULL + AND provider_task_id <> 'mock'; diff --git a/control-plane-java/src/main/resources/redis/acquire-pair.lua b/control-plane-java/src/main/resources/redis/acquire-pair.lua index 910f2a2..eaf1dc7 100644 --- a/control-plane-java/src/main/resources/redis/acquire-pair.lua +++ b/control-plane-java/src/main/resources/redis/acquire-pair.lua @@ -2,8 +2,18 @@ local time = redis.call('TIME') local now = tonumber(time[1]) * 1000 + math.floor(tonumber(time[2]) / 1000) redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', now) redis.call('ZREMRANGEBYSCORE', KEYS[2], '-inf', now) -if redis.call('ZCARD', KEYS[1]) >= tonumber(ARGV[1]) then return 0 end -if redis.call('ZCARD', KEYS[2]) >= tonumber(ARGV[2]) then return 2 end +redis.call('ZREMRANGEBYSCORE', KEYS[3], '-inf', now) +local busy = nil +if redis.call('ZCARD', KEYS[1]) >= tonumber(ARGV[1]) then busy = 0 +elseif redis.call('ZCARD', KEYS[2]) >= tonumber(ARGV[2]) then busy = 2 end +if busy ~= nil then + if tonumber(ARGV[5]) > 0 then + redis.call('ZADD', KEYS[3], now + tonumber(ARGV[5]), ARGV[4]) + redis.call('PEXPIRE', KEYS[3], ARGV[6]) + end + return busy +end +redis.call('ZREM', KEYS[3], ARGV[4]) redis.call('ZADD', KEYS[1], now + tonumber(ARGV[3]), ARGV[4]) redis.call('ZADD', KEYS[2], now + tonumber(ARGV[3]), ARGV[4]) redis.call('PEXPIRE', KEYS[1], ARGV[3]) diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/gateway/ChatStreamingTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/gateway/ChatStreamingTest.java index 9a03f5b..45bd9e9 100644 --- a/control-plane-java/src/test/java/com/moyi/controlplane/gateway/ChatStreamingTest.java +++ b/control-plane-java/src/test/java/com/moyi/controlplane/gateway/ChatStreamingTest.java @@ -68,7 +68,8 @@ class ChatStreamingTest { // Leave the body open: the client hard deadline must terminate the read. }); server.start(); long started=System.nanoTime(); - assertThrows(Exception.class,()->{ try(var stream=provider.stream("provider-deepseek","alias",request)) { stream.events(chunk->{}); } }); + var error=assertThrows(ApiException.class,()->{ try(var stream=provider.stream("provider-deepseek","alias",request)) { stream.events(chunk->{}); } }); + assertEquals("UPSTREAM_PROVIDER_TIMEOUT",error.getCode()); assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime()-started)<4000); } @Test void upstreamHttpFailureNeverBecomesSuccessfulStream() { @@ -84,6 +85,31 @@ class ChatStreamingTest { assertThrows(ApiException.class,()->ChatMeter.tokens(Map.of("usage",Map.of("prompt_tokens",1.5,"completion_tokens",2)))); assertThrows(ApiException.class,()->ChatMeter.tokens(Map.of("usage",Map.of("prompt_tokens",1,"completion_tokens",2,"prompt_cache_hit_tokens",3)))); } + + @Test void reasoningAliasAndContentPartsAreCollectedSeparately() { + var collector=new ChatStreamCollector("public-route",System.currentTimeMillis()); + collector.accept(Map.of("choices",List.of(Map.of("delta",Map.of( + "content",List.of(Map.of("type","text","text","OK")), + "reasoning", "thinking" + ))))); + collector.accept(Map.of("choices",List.of(Map.of("delta",Map.of(),"finish_reason","stop")))); + var message=(Map)((Map)((List)collector.result().get("choices")).getFirst()).get("message"); + assertEquals("OK",message.get("content")); + assertEquals("thinking",message.get("reasoning_content")); + } + + @Test void finishedWhitespaceOnlyStreamIsRejectedBeforeSettlement() { + var collector=new ChatStreamCollector("public-route",System.currentTimeMillis()); + collector.accept(Map.of("choices",List.of(Map.of("delta",Map.of("content"," \n"))))); + collector.accept(Map.of("choices",List.of(Map.of("delta",Map.of(),"finish_reason","stop")))); + var error=assertThrows(ApiException.class,collector::result); + assertEquals("UPSTREAM_RESPONSE_INVALID",error.getCode()); + } + @Test void completedStreamWithoutContentOrReasoningIsNotBillable() { + var collector=new ChatStreamCollector("public-route",System.currentTimeMillis()); + collector.accept(Map.of("choices",List.of(Map.of("index",0,"delta",Map.of(),"finish_reason","stop")))); + assertEquals("UPSTREAM_RESPONSE_INVALID",assertThrows(ApiException.class,collector::result).getCode()); + } @Test void tokenBoundsAndUnsupportedMultimodalAreRejectedBeforeUpstream() { assertThrows(ApiException.class,()->ChatMeter.request(Map.of("messages",List.of(Map.of("role","user","content",List.of(Map.of("type","image_url"))))),json)); assertThrows(ApiException.class,()->ChatMeter.request(Map.of("messages",List.of(Map.of("role","user","content","test")),"max_tokens",0),json)); diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/gateway/GatewayDeploymentTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/gateway/GatewayDeploymentTest.java index 2d9a003..ebfe95d 100644 --- a/control-plane-java/src/test/java/com/moyi/controlplane/gateway/GatewayDeploymentTest.java +++ b/control-plane-java/src/test/java/com/moyi/controlplane/gateway/GatewayDeploymentTest.java @@ -20,6 +20,32 @@ import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; class GatewayDeploymentTest { + @Test + void capacitySnapshotReadsBothLiveAndWaitingBucketsAndDoesNotInventZeroOnFailure() { + StringRedisTemplate redis = mock(StringRedisTemplate.class); + doReturn(List.of(2L, 3L, 0L, 1L)).when(redis).execute(any(RedisScript.class), anyList()); + GatewayGuard guard = new GatewayGuard(redis, 60, 300, 4, "moyi:test:"); + var snapshot = guard.capacitySnapshot(List.of("model-a", "model-b")); + assertTrue(snapshot.available()); + assertEquals(new GatewayGuard.Capacity(2, 3), snapshot.groups().get("model-a")); + assertEquals(new GatewayGuard.Capacity(0, 1), snapshot.groups().get("model-b")); + verify(redis).execute(any(RedisScript.class), eq(List.of( + "moyi:test:gateway:slots:model:model-a", "moyi:test:gateway:waiting:model:model-a", + "moyi:test:gateway:slots:model:model-b", "moyi:test:gateway:waiting:model:model-b"))); + doThrow(new org.springframework.dao.DataAccessResourceFailureException("offline")).when(redis).execute(any(RedisScript.class), anyList()); + assertFalse(guard.capacitySnapshot(List.of("model-a")).available()); + assertTrue(guard.capacitySnapshot(List.of("model-a")).groups().isEmpty()); + } + + @Test + void queueTimeoutCleansItsWaitingEntry() { + StringRedisTemplate redis = mock(StringRedisTemplate.class); + doReturn(0L).when(redis).execute(any(RedisScript.class), anyList(), any(Object[].class)); + GatewayGuard guard = new GatewayGuard(redis, 60, 300, 1, 1, 15, 10, "moyi:test:"); + assertThrows(GatewayLimitException.class, () -> guard.acquire(Map.of("id", "model-a"), UUID.randomUUID(), 15)); + verify(redis).execute(any(RedisScript.class), eq(List.of("moyi:test:gateway:waiting:model:model-a")), any(Object[].class)); + } + @Test void redisRateKeysAreEnvironmentScoped() { StringRedisTemplate redis = mock(StringRedisTemplate.class); @@ -108,6 +134,65 @@ class GatewayDeploymentTest { assertEquals(200, controller.chatCompletions("Bearer test-key", Map.of("model", "mock","messages",List.of(Map.of("role","user","content","test"))),null,new MockHttpServletResponse()).getStatusCode().value()); } + @Test + void syncResponsePreservesReasoningAndFinishReasonWhenContentIsEmpty() { + CatalogService catalog = mock(CatalogService.class); + GatewayGuard guard = mock(GatewayGuard.class); + OpenAiCompatibleProvider provider = mock(OpenAiCompatibleProvider.class); + ChatBillingService billing = mock(ChatBillingService.class); + String userId = UUID.randomUUID().toString(); + Map key = Map.of("id", UUID.randomUUID().toString(), "userId", userId); + Map model = Map.of("id", "reasoning-route", "providerId", "provider-relay", "upstreamModel", "reasoning-model", "mode", "sync"); + when(catalog.authenticateKey("test-key")).thenReturn(key); + when(catalog.activeModel("reasoning-route")).thenReturn(model); + when(catalog.keyCanInvoke(key, "reasoning-route")).thenReturn(true); + when(provider.isConfigured("provider-relay")).thenReturn(true); + Map upstreamResponse = new java.util.LinkedHashMap<>(Map.of( + "id", "upstream-response", + "choices", List.of(Map.of("index", 0, "message", Map.of("role", "assistant", "content", "", "reasoning_content", "private reasoning"), "finish_reason", "length")), + "usage", Map.of("prompt_tokens", 2, "completion_tokens", 16, "total_tokens", 18) + )); + when(provider.chat(eq("provider-relay"), eq("reasoning-model"), anyMap())).thenReturn(upstreamResponse); + when(billing.reserve(anyMap(), anyMap(), any(), isNull())).thenReturn(new ChatBillingService.Ticket(UUID.randomUUID(), UUID.fromString(userId), ChatMeter.rates(null, true))); + when(billing.settle(any(), anyMap(), anyInt(), isNull())).thenReturn(java.math.BigDecimal.ZERO); + + GatewayController controller = new GatewayController(catalog, provider, guard, billing, new ObjectMapper()); + var response = controller.chatCompletions("Bearer test-key", Map.of("model", "reasoning-route", "messages", List.of(Map.of("role", "user", "content", "hello"))), null, new MockHttpServletResponse()); + assertEquals(200, response.getStatusCode().value()); + Map choice = (Map)((List)response.getBody().get("choices")).getFirst(); + Map message = (Map)choice.get("message"); + assertEquals("", message.get("content")); + assertEquals("private reasoning", message.get("reasoning_content")); + assertEquals("length", choice.get("finish_reason")); + } + + @Test + void trulyEmptySyncResponseIsRejectedBeforeSettlement() { + CatalogService catalog = mock(CatalogService.class); + GatewayGuard guard = mock(GatewayGuard.class); + OpenAiCompatibleProvider provider = mock(OpenAiCompatibleProvider.class); + ChatBillingService billing = mock(ChatBillingService.class); + String userId = UUID.randomUUID().toString(); + Map key = Map.of("id", UUID.randomUUID().toString(), "userId", userId); + Map model = Map.of("id", "empty-route", "providerId", "provider-relay", "upstreamModel", "empty-model", "mode", "sync"); + when(catalog.authenticateKey("test-key")).thenReturn(key); + when(catalog.activeModel("empty-route")).thenReturn(model); + when(catalog.keyCanInvoke(key, "empty-route")).thenReturn(true); + when(provider.isConfigured("provider-relay")).thenReturn(true); + Map upstreamResponse = new java.util.LinkedHashMap<>(Map.of( + "id", "upstream-empty", + "choices", List.of(Map.of("index", 0, "message", Map.of("role", "assistant", "content", ""), "finish_reason", "stop")) + )); + when(provider.chat(eq("provider-relay"), eq("empty-model"), anyMap())).thenReturn(upstreamResponse); + when(billing.reserve(anyMap(), anyMap(), any(), isNull())).thenReturn(new ChatBillingService.Ticket(UUID.randomUUID(), UUID.fromString(userId), ChatMeter.rates(null, true))); + GatewayController controller = new GatewayController(catalog, provider, guard, billing, new ObjectMapper()); + + ApiException error = assertThrows(ApiException.class, () -> controller.chatCompletions("Bearer test-key", Map.of("model", "empty-route", "messages", List.of(Map.of("role", "user", "content", "hello"))), null, new MockHttpServletResponse())); + assertEquals("UPSTREAM_RESPONSE_INVALID", error.getCode()); + verify(billing, never()).settle(any(), anyMap(), anyInt(), any()); + verify(billing).fail(any(), eq("UPSTREAM_RESPONSE_INVALID"), anyString(), anyInt()); + } + @Test void unimplementedMediaProviderDoesNotCreateFakeTask() { JdbcTemplate jdbc = mock(JdbcTemplate.class); diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/provider/ProviderErrorClassificationTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/provider/ProviderErrorClassificationTest.java index ec6e29e..4161c39 100644 --- a/control-plane-java/src/test/java/com/moyi/controlplane/provider/ProviderErrorClassificationTest.java +++ b/control-plane-java/src/test/java/com/moyi/controlplane/provider/ProviderErrorClassificationTest.java @@ -26,4 +26,25 @@ class ProviderErrorClassificationTest { assertEquals("UPSTREAM_RATE_LIMITED", error.getCode()); assertEquals(429, error.getStatus()); } + + @Test + void classifiesMissingUpstreamRouteWithoutEchoingProviderDetails() { + var error = OpenAiCompatibleProvider.classifyUpstreamError(502, "No available channel for model gemini-3-flash"); + assertEquals("UPSTREAM_MODEL_UNAVAILABLE", error.getCode()); + assertEquals(502, error.getStatus()); + assertEquals("上游渠道没有可用的模型路由", error.getMessage()); + } + + @Test + void classifiesErrorEnvelopeReturnedWithHttp200() { + var error = OpenAiCompatibleProvider.classifyUpstreamError(200, "{\"error\":{\"code\":\"invalid_api_key\",\"message\":\"unauthorized\"}}"); + assertEquals("UPSTREAM_AUTH_FAILED", error.getCode()); + } + + @Test + void classifiesTimeoutResponsesWithoutExposingProviderBody() { + var error = OpenAiCompatibleProvider.classifyUpstreamError(504, "gateway timeout at upstream"); + assertEquals("UPSTREAM_PROVIDER_TIMEOUT", error.getCode()); + assertEquals(504, error.getStatus()); + } } diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/task/AsyncProviderClientTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/task/AsyncProviderClientTest.java new file mode 100644 index 0000000..b014933 --- /dev/null +++ b/control-plane-java/src/test/java/com/moyi/controlplane/task/AsyncProviderClientTest.java @@ -0,0 +1,77 @@ +package com.moyi.controlplane.task; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.moyi.controlplane.common.ApiException; +import com.moyi.controlplane.security.SecretCipher; +import com.sun.net.httpserver.HttpServer; +import java.net.InetSocketAddress; +import java.nio.charset.StandardCharsets; +import java.util.Map; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.springframework.core.env.Environment; +import org.springframework.jdbc.core.JdbcTemplate; + +class AsyncProviderClientTest { + @Test + void upstreamErrorDoesNotExposeProviderMessage() throws Exception { + HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0); + server.createContext("/", exchange -> { + byte[] body = "{\"code\":1001,\"message\":\"secret account and API key details\"}".getBytes(StandardCharsets.UTF_8); + exchange.getResponseHeaders().set("Content-Type", "application/json"); + exchange.sendResponseHeaders(200, body.length); + try (var output = exchange.getResponseBody()) { output.write(body); } + }); + server.start(); + try { + String baseUrl = "http://127.0.0.1:" + server.getAddress().getPort() + "/tripo"; + AsyncProviderClient client = clientFor(baseUrl); + + ApiException error = assertThrows(ApiException.class, () -> client.submit("provider-vast", "v3.1-20260211", "3d", "chair")); + assertEquals("UPSTREAM_PROVIDER_ERROR", error.getCode()); + assertEquals("上游 3D 任务创建失败", error.getMessage()); + } finally { + server.stop(0); + } + } + + @ParameterizedTest + @CsvSource({"401,UPSTREAM_AUTH_FAILED", "403,UPSTREAM_AUTH_FAILED", "402,UPSTREAM_CREDIT_INSUFFICIENT", "429,UPSTREAM_RATE_LIMITED", "503,UPSTREAM_PROVIDER_ERROR"}) + void httpErrorsExposeOnlySafeCodes(int status, String code) throws Exception { + HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0); + server.createContext("/", exchange -> { + byte[] body = "private account details".getBytes(StandardCharsets.UTF_8); + exchange.sendResponseHeaders(status, body.length); + try (var output = exchange.getResponseBody()) { output.write(body); } + }); + server.start(); + try { + AsyncProviderClient client = clientFor("http://127.0.0.1:" + server.getAddress().getPort() + "/tripo"); + ApiException submit = assertThrows(ApiException.class, () -> client.submit("provider-vast", "v3.1-20260211", "3d", "chair")); + assertEquals(code, submit.getCode()); + assertEquals("上游 3D 任务创建失败(HTTP " + status + ")", submit.getMessage()); + ApiException poll = assertThrows(ApiException.class, () -> client.poll("provider-vast", "task-test")); + assertEquals(code, poll.getCode()); + assertEquals("上游异步任务查询失败(HTTP " + status + ")", poll.getMessage()); + } finally { + server.stop(0); + } + } + + private AsyncProviderClient clientFor(String baseUrl) { + JdbcTemplate jdbc = mock(JdbcTemplate.class); + SecretCipher cipher = new SecretCipher("test-encryption"); + when(jdbc.queryForMap(any(String.class), eq("provider-vast"))).thenReturn(Map.of( + "code", "vast-tripo", "base_url", baseUrl, "credential_ciphertext", cipher.encrypt("test-key") + )); + return new AsyncProviderClient(jdbc, cipher, new ObjectMapper(), mock(Environment.class)); + } +} diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/task/AsyncTaskPostgresTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/task/AsyncTaskPostgresTest.java new file mode 100644 index 0000000..1eced73 --- /dev/null +++ b/control-plane-java/src/test/java/com/moyi/controlplane/task/AsyncTaskPostgresTest.java @@ -0,0 +1,186 @@ +package com.moyi.controlplane.task; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.moyi.controlplane.catalog.CatalogService; +import com.moyi.controlplane.common.ApiException; +import com.moyi.controlplane.gateway.GatewayGuard; +import com.moyi.controlplane.usage.UsageAuditService; +import java.math.BigDecimal; +import java.time.Duration; +import java.time.OffsetDateTime; +import java.util.Map; +import java.util.UUID; +import org.flywaydb.core.Flyway; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.datasource.DataSourceTransactionManager; +import org.springframework.jdbc.datasource.DriverManagerDataSource; +import org.springframework.test.util.ReflectionTestUtils; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +@EnabledIfEnvironmentVariable(named="MOYI_AUTH_TEST_JDBC_URL", matches="jdbc:postgresql://127\\.0\\.0\\.1:[0-9]+/.+") +class AsyncTaskPostgresTest { + private final ObjectMapper json = new ObjectMapper().findAndRegisterModules(); + private final UUID userId = UUID.randomUUID(), keyId = UUID.randomUUID(); + private final String taskId = "async-transaction-test"; + private String schema; + private DriverManagerDataSource base; + private JdbcTemplate jdbc; + private UsageAuditService usage; + private AsyncProviderClient provider; + private AsyncTaskService tasks; + + @BeforeEach void setup() { + String url = System.getenv("MOYI_AUTH_TEST_JDBC_URL"); + schema = "async_task_test_" + UUID.randomUUID().toString().replace("-", ""); + base = new DriverManagerDataSource(url, "moyi_role_test", ""); + var source = new DriverManagerDataSource(url + "?currentSchema=" + schema, "moyi_role_test", ""); + Flyway.configure().dataSource(base).schemas(schema).defaultSchema(schema).target("25").load().migrate(); + jdbc = new JdbcTemplate(source); + usage = spy(new UsageAuditService(jdbc, json)); + provider = mock(AsyncProviderClient.class); + tasks = new AsyncTaskService(jdbc, json, mock(CatalogService.class), 100, 4, 4, 120_000, + mock(GatewayGuard.class), usage, provider, new DataSourceTransactionManager(source)); + jdbc.update("INSERT INTO users(id,account,account_kind,password_hash,display_name) VALUES (?,'async-test','username','not-a-password','Test')", userId); + jdbc.update("INSERT INTO platform_api_keys(id,user_id,name,key_prefix,key_hash) VALUES (?,?,'Test','test-prefix',?)", keyId, userId, "b".repeat(64)); + jdbc.update("INSERT INTO user_wallets(user_id,balance,reserved_balance) VALUES (?,10,1.44)", userId); + jdbc.update("INSERT INTO model_tasks(id,user_id,api_key_id,model_id,task_type,status,prompt,reserved_amount,provider_task_id) VALUES (?,?,?,'model-mock-3d','3d','running','chair',1.44,'upstream-task')", taskId,userId,keyId); + usage.recordTask(userId,keyId,"model-mock-3d","provider-vast",taskId,"running",Map.of("prompt","chair"),null,null,null); + Flyway.configure().dataSource(base).schemas(schema).defaultSchema(schema).load().migrate(); + } + + @AfterEach void cleanup() { + if (base != null && schema != null) new JdbcTemplate(base).execute("DROP SCHEMA IF EXISTS " + schema + " CASCADE"); + } + + private void fail() { + ReflectionTestUtils.invokeMethod(tasks,"failTask",taskId,"PROVIDER_NOT_CONFIGURED","异步渠道尚未配置 API Key"); + } + private void poll() { + Map row = jdbc.queryForMap("SELECT id,provider_task_id,provider_deadline_at,created_at FROM model_tasks WHERE id=?", taskId); + row.put("provider_id", "provider-vast"); + ReflectionTestUtils.invokeMethod(tasks,"pollProviderTask",row); + } + private BigDecimal wallet(String column) { + return jdbc.queryForObject("SELECT " + column + " FROM user_wallets WHERE user_id=?",BigDecimal.class,userId); + } + private String status() { + return jdbc.queryForObject("SELECT status FROM model_tasks WHERE id=?",String.class,taskId); + } + private BigDecimal cost() { + return jdbc.queryForObject("SELECT cost_amount FROM model_tasks WHERE id=?",BigDecimal.class,taskId); + } + + @ParameterizedTest + @ValueSource(strings={"PROVIDER_NOT_CONFIGURED", "UPSTREAM_AUTH_FAILED"}) + void submissionFailureReleasesExactlyOnceWithoutDebitingBalance(String code) { + jdbc.update("UPDATE model_tasks SET status='queued',provider_task_id=NULL WHERE id=?",taskId); + when(provider.submit(anyString(),anyString(),anyString(),anyString())).thenThrow(new ApiException(code,"上游任务未接受",503)); + tasks.completeMockTasks(); + tasks.completeMockTasks(); + assertEquals("failed",status()); + assertEquals(new BigDecimal("10.00000000"),wallet("balance")); + assertEquals(0,wallet("reserved_balance").signum()); + assertEquals(0,cost().signum()); + assertEquals(0,jdbc.queryForObject("SELECT cost_amount FROM usage_events WHERE provider_task_id=?",BigDecimal.class,taskId).signum()); + assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE user_id=?",Integer.class,userId)); + verify(provider,times(1)).submit(anyString(),anyString(),anyString(),anyString()); + } + + @Test void refundAndTaskStateRollBackTogetherWhenAuditFails() { + doThrow(new IllegalStateException("simulated database write failure")).when(usage).updateTask(eq(taskId),eq("failed"),isNull(),anyString(),anyString()); + assertThrows(IllegalStateException.class,this::fail); + assertEquals("running",status()); + assertEquals(new BigDecimal("1.44000000"),wallet("reserved_balance")); + assertNull(cost()); + doCallRealMethod().when(usage).updateTask(eq(taskId),eq("failed"),isNull(),anyString(),anyString()); + fail(); fail(); + assertEquals("failed",status()); + assertEquals(0,wallet("reserved_balance").signum()); + assertEquals(new BigDecimal("10.00000000"),wallet("balance")); + } + + @Test void successfulSettlementRollsBackForRetryAndCannotBeRefundedByLateFailure() { + when(provider.poll("provider-vast","upstream-task")).thenReturn(Map.of("data",Map.of("status","success","progress",100,"output",Map.of("model_url","https://example.test/model.glb")))); + doThrow(new IllegalStateException("simulated database write failure")).when(usage).updateTask(eq(taskId),eq("succeeded"),anyMap(),isNull(),isNull()); + assertThrows(IllegalStateException.class,this::poll); + assertEquals("running",status()); + assertEquals(new BigDecimal("10.00000000"),wallet("balance")); + assertEquals(new BigDecimal("1.44000000"),wallet("reserved_balance")); + assertNull(cost()); + assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE user_id=?",Integer.class,userId)); + doCallRealMethod().when(usage).updateTask(eq(taskId),eq("succeeded"),anyMap(),isNull(),isNull()); + poll(); poll(); fail(); + assertEquals("succeeded",status()); + assertEquals(new BigDecimal("8.56000000"),wallet("balance")); + assertEquals(0,wallet("reserved_balance").signum()); + assertEquals(new BigDecimal("1.44000000"),cost()); + assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE user_id=?",Integer.class,userId)); + } + + @ParameterizedTest + @ValueSource(strings={"UPSTREAM_PROVIDER_ERROR", "UPSTREAM_AUTH_FAILED", "UPSTREAM_RATE_LIMITED"}) + void pollingErrorsKeepTheHoldAndClearOnRecovery(String code) { + when(provider.poll("provider-vast","upstream-task")) + .thenThrow(new ApiException(code,"private upstream details",502)) + .thenReturn(Map.of("data",Map.of("status","running","progress",75))); + poll(); + assertEquals("running",status()); + assertEquals(new BigDecimal("1.44000000"),wallet("reserved_balance")); + assertEquals(new BigDecimal("10.00000000"),wallet("balance")); + assertNull(cost()); + String error = jdbc.queryForObject("SELECT error::text FROM model_tasks WHERE id=?",String.class,taskId); + assertTrue(error.contains("UPSTREAM_TASK_POLL_RETRY")); + assertFalse(error.contains("private upstream details")); + poll(); + assertEquals("running",status()); + assertEquals(75,jdbc.queryForObject("SELECT progress FROM model_tasks WHERE id=?",Integer.class,taskId)); + assertNull(jdbc.queryForObject("SELECT error::text FROM model_tasks WHERE id=?",String.class,taskId)); + assertNull(jdbc.queryForObject("SELECT error_code FROM usage_events WHERE provider_task_id=?",String.class,taskId)); + } + + @Test void deadlineReleasesHoldWithoutClaimingTheUpstreamFailed() { + jdbc.update("UPDATE model_tasks SET provider_deadline_at=now()-interval '1 second' WHERE id=?",taskId); + poll(); poll(); + assertEquals("failed",status()); + assertEquals(new BigDecimal("10.00000000"),wallet("balance")); + assertEquals(0,wallet("reserved_balance").signum()); + assertEquals(0,cost().signum()); + String error = jdbc.queryForObject("SELECT error::text FROM model_tasks WHERE id=?",String.class,taskId); + assertTrue(error.contains("UPSTREAM_TASK_TIMEOUT")); + assertTrue(error.contains("执行结果未知")); + verifyNoInteractions(provider); + } + + @Test void confirmedUpstreamFailureReleasesHoldImmediately() { + when(provider.poll("provider-vast","upstream-task")).thenReturn(Map.of("data",Map.of("status","failed"))); + poll(); + assertEquals("failed",status()); + assertEquals(0,wallet("reserved_balance").signum()); + assertEquals(new BigDecimal("10.00000000"),wallet("balance")); + assertEquals(0,cost().signum()); + } + + @Test void migrationBackfillsOldAcceptedTasksAndNewSubmissionsUseConfiguredDeadline() { + OffsetDateTime createdAt = jdbc.queryForObject("SELECT created_at FROM model_tasks WHERE id=?",OffsetDateTime.class,taskId); + OffsetDateTime migratedDeadline = jdbc.queryForObject("SELECT provider_deadline_at FROM model_tasks WHERE id=?",OffsetDateTime.class,taskId); + assertEquals(Duration.ofHours(1),Duration.between(createdAt,migratedDeadline)); + jdbc.update("UPDATE model_tasks SET status='queued',provider_task_id=NULL,provider_deadline_at=NULL WHERE id=?",taskId); + when(provider.submit(anyString(),anyString(),anyString(),anyString())).thenReturn(Map.of("data",Map.of("task_id","upstream-task"))); + tasks.completeMockTasks(); + OffsetDateTime submittedAt = jdbc.queryForObject("SELECT updated_at FROM model_tasks WHERE id=?",OffsetDateTime.class,taskId); + OffsetDateTime deadline = jdbc.queryForObject("SELECT provider_deadline_at FROM model_tasks WHERE id=?",OffsetDateTime.class,taskId); + assertEquals(Duration.ofMinutes(2),Duration.between(submittedAt,deadline)); + tasks.completeMockTasks(); + verify(provider,times(1)).submit(anyString(),anyString(),anyString(),anyString()); + verify(provider,never()).poll(anyString(),anyString()); + assertEquals("running",status()); + } +} diff --git a/control-plane-java/src/test/java/com/moyi/controlplane/usage/UsageCapacityPostgresTest.java b/control-plane-java/src/test/java/com/moyi/controlplane/usage/UsageCapacityPostgresTest.java new file mode 100644 index 0000000..7de776b --- /dev/null +++ b/control-plane-java/src/test/java/com/moyi/controlplane/usage/UsageCapacityPostgresTest.java @@ -0,0 +1,83 @@ +package com.moyi.controlplane.usage; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.moyi.controlplane.auth.AuthService; +import com.moyi.controlplane.gateway.GatewayGuard; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import org.flywaydb.core.Flyway; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.datasource.DriverManagerDataSource; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Mockito.*; + +@EnabledIfEnvironmentVariable(named="MOYI_AUTH_TEST_JDBC_URL", matches="jdbc:postgresql://127\\.0\\.0\\.1:[0-9]+/.+") +class UsageCapacityPostgresTest { + private JdbcTemplate jdbc; + private JdbcTemplate base; + private String schema; + + @BeforeEach void setup() { + String url = System.getenv("MOYI_AUTH_TEST_JDBC_URL"); + schema = "capacity_test_" + UUID.randomUUID().toString().replace("-", ""); + var source = new DriverManagerDataSource(url, "moyi_role_test", ""); + base = new JdbcTemplate(source); + Flyway.configure().dataSource(source).schemas(schema).defaultSchema(schema).load().migrate(); + jdbc = new JdbcTemplate(new DriverManagerDataSource(url + "?currentSchema=" + schema, "moyi_role_test", "")); + jdbc.update("UPDATE model_providers SET status='disabled'"); + jdbc.update("INSERT INTO model_providers(id,code,name,protocol,status) VALUES ('capacity-provider','capacity-provider','Capacity provider','http','active')"); + jdbc.update("INSERT INTO model_definitions(id,public_name,model_type,call_mode) VALUES ('capacity-model','Capacity model','text','sync')"); + jdbc.update("INSERT INTO model_catalog(id,provider_id,logical_model_id,public_name,source_label,upstream_model,model_type,call_mode) SELECT 'capacity-route-'||n,'capacity-provider','capacity-model','Capacity model','Group '||n,'test','text','sync' FROM generate_series(1,105) n"); + jdbc.update("UPDATE model_catalog SET call_mode='async',model_type='3d' WHERE id='capacity-route-105'"); + UUID user = UUID.randomUUID(), key = UUID.randomUUID(); + jdbc.update("INSERT INTO users(id,account,account_kind,password_hash,display_name) VALUES (?,'capacity-user','username','not-loginable','Capacity user')", user); + jdbc.update("INSERT INTO platform_api_keys(id,user_id,name,key_prefix,key_hash) VALUES (?,?,'Capacity test','local-test',?)", key, user, "c".repeat(64)); + for (String state : List.of("running", "queued", "succeeded")) { + jdbc.update("INSERT INTO model_tasks(id,user_id,api_key_id,model_id,task_type,status,created_at) VALUES (?,?,?,'capacity-route-105','3d',?,now()-interval '1 day')", "task-" + state, user, key, state); + } + } + + @AfterEach void cleanup() { + if (base != null && schema != null) base.execute("DROP SCHEMA " + schema + " CASCADE"); + } + + @Test void liveCapacitySeparatesQueuedWorkAndKeepsEveryGroupAndLongRunningTask() { + GatewayGuard guard = mock(GatewayGuard.class); + when(guard.defaultModelConcurrency()).thenReturn(7); + when(guard.defaultKeyConcurrency()).thenReturn(3); + when(guard.queueWaitMs()).thenReturn(4500L); + when(guard.capacitySnapshot(anyList())).thenAnswer(invocation -> { + List ids = invocation.getArgument(0); + Map states = new LinkedHashMap<>(); + ids.forEach(id -> states.put(id, new GatewayGuard.Capacity(id.equals("capacity-route-1") ? 2 : 0, id.equals("capacity-route-1") ? 3 : 0))); + return new GatewayGuard.CapacitySnapshot(true, states); + }); + var service = new UsageAuditService(jdbc, new ObjectMapper(), guard, 77, 2500); + Map summary = service.adminSummary("test", mock(AuthService.class)); + List> groups = (List>) summary.get("capacityGroups"); + assertEquals(105, groups.size(), "Capacity listing must not truncate at 100 groups"); + Map async = groups.stream().filter(group -> group.get("id").equals("capacity-route-105")).findFirst().orElseThrow(); + assertEquals(1L, async.get("running"), "A task older than ten minutes must remain in live capacity"); + assertEquals(1L, async.get("queued"), "Running tasks must not also count as queued"); + assertEquals(7, async.get("limit"), "Null route limits use the real configured model default"); + assertEquals(3L, summary.get("running")); + assertEquals(4L, summary.get("waiting")); + Map config = (Map) summary.get("capacityConfig"); + assertEquals(4500L, config.get("queueWaitMs")); + assertEquals(3, config.get("defaultKeyConcurrency")); + assertEquals(77, config.get("asyncQueueLimit")); + assertEquals(2500L, config.get("asyncWorkerIntervalMs")); + + when(guard.capacitySnapshot(anyList())).thenReturn(new GatewayGuard.CapacitySnapshot(false, Map.of())); + var unavailable = service.adminSummary("test", mock(AuthService.class)); + assertNull(unavailable.get("running"), "Unavailable Redis must not be reported as zero load"); + assertNull(unavailable.get("waiting")); + } +} diff --git a/infra/moyi/.env.cloud.example b/infra/moyi/.env.cloud.example index a0f785f..f9077a9 100644 --- a/infra/moyi/.env.cloud.example +++ b/infra/moyi/.env.cloud.example @@ -46,6 +46,9 @@ GATEWAY_DEFAULT_MODEL_CONCURRENCY=4 GATEWAY_DEFAULT_KEY_CONCURRENCY=4 TASK_MAX_QUEUED_PER_MODEL=100 MOYI_TASK_WORKER_INTERVAL_MS=1000 +# Accepted async tasks retry polling for up to this duration, then release +# their wallet hold with an unknown-result timeout (upstream is not cancelled). +MOYI_TASK_PROVIDER_TIMEOUT_MS=3600000 # Registration requires a valid invitation AND an email/SMS verification code. # Unconfigured channels fail closed; admins can still create user accounts. diff --git a/infra/moyi/admin_credentials.py b/infra/moyi/admin_credentials.py index c50a95f..e3a6df7 100644 --- a/infra/moyi/admin_credentials.py +++ b/infra/moyi/admin_credentials.py @@ -52,8 +52,14 @@ def updated_environment(original, account, password): require(password.strip() and not any(ord(char) < 32 or ord(char) == 127 for char in password), "Password must be nonblank and cannot contain control characters.") require(password != "admin123", "The development default password is not allowed.") - # Append effective overrides, then ask Compose to validate them. Do not parse - # or rewrite arbitrary existing dotenv values, which may be multiline/quoted. + # Replace the two owner settings in place before appending the effective + # values. Compose accepts later overrides, but duplicate assignments make + # the resulting dotenv file ambiguous and can silently mask a real secret. + # Do not parse or rewrite arbitrary existing dotenv values, which may be + # multiline/quoted. + lines = [line for line in original.splitlines() if not re.match( + r"^\s*(?:export\s+)?(?:ADMIN_ACCOUNT|ADMIN_PASSWORD)\s*=", line)] + original = "\n".join(lines) values = {"ADMIN_ACCOUNT": account, "ADMIN_PASSWORD": password} return original.rstrip("\r\n") + "\n\n# Owner credentials set by admin_credentials.py\n" + "".join( key + "=" + json.dumps(value, ensure_ascii=False).replace("$", "$$") + "\n" diff --git a/infra/moyi/deploy.py b/infra/moyi/deploy.py index 5dde775..fe04607 100644 --- a/infra/moyi/deploy.py +++ b/infra/moyi/deploy.py @@ -66,6 +66,16 @@ def load_config(env_file, mode): fail("Environment file missing. Run: python3 deploy.py init") if os.name != "nt" and stat.S_IMODE(env_file.stat().st_mode) & 0o077: fail("Environment file must be private. Run chmod 600 on it.") + # A later empty assignment silently overrides an earlier valid secret in + # Compose. Reject duplicates before resolving or starting any container. + seen = set() + for line in env_file.read_text(encoding="utf-8-sig").splitlines(): + match = re.match(r"^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=", line) + if match: + key = match.group(1) + if key in seen: + fail("Duplicate environment setting: " + key + ". Keep exactly one assignment; values are not printed.") + seen.add(key) config = execute(compose_command(env_file, mode) + ["config", "--format", "json"], capture=True) resolved = json.loads(config) # Compose serializes literal '$' as '$$' for re-parseable config output. diff --git a/infra/moyi/docker-compose.cloud.yml b/infra/moyi/docker-compose.cloud.yml index 69b3f03..0c79887 100644 --- a/infra/moyi/docker-compose.cloud.yml +++ b/infra/moyi/docker-compose.cloud.yml @@ -52,6 +52,7 @@ services: GATEWAY_QUEUE_POLL_MS: ${GATEWAY_QUEUE_POLL_MS:-100} TASK_MAX_QUEUED_PER_MODEL: ${TASK_MAX_QUEUED_PER_MODEL:-100} MOYI_TASK_WORKER_INTERVAL_MS: ${MOYI_TASK_WORKER_INTERVAL_MS:-1000} + MOYI_TASK_PROVIDER_TIMEOUT_MS: ${MOYI_TASK_PROVIDER_TIMEOUT_MS:-3600000} DB_POOL_MAX_SIZE: ${DB_POOL_MAX_SIZE:-10} DB_POOL_MIN_IDLE: ${DB_POOL_MIN_IDLE:-2} JAVA_OPTS: ${JAVA_OPTS:--Xms256m -Xmx1536m -XX:+ExitOnOutOfMemoryError} diff --git a/infra/moyi/tests/test_deploy.py b/infra/moyi/tests/test_deploy.py index ec8d3ff..9e643d2 100644 --- a/infra/moyi/tests/test_deploy.py +++ b/infra/moyi/tests/test_deploy.py @@ -37,6 +37,25 @@ def configuration(): class DeploymentTests(unittest.TestCase): + def test_duplicate_empty_secret_is_rejected_before_compose(self): + with tempfile.TemporaryDirectory() as directory: + env_file = Path(directory) / ".env.cloud" + env_file.write_text("TRIPO_API_KEY=private-test-value\nTRIPO_API_KEY=\n", encoding="utf-8") + env_file.chmod(0o600) + with patch.object(deploy, "execute") as execute: + with self.assertRaisesRegex(ValueError, "Duplicate environment setting: TRIPO_API_KEY") as error: + deploy.load_config(env_file, "https") + self.assertNotIn("private-test-value", str(error.exception)) + execute.assert_not_called() + + def test_commented_assignment_does_not_override_secret(self): + with tempfile.TemporaryDirectory() as directory: + env_file = Path(directory) / ".env.cloud" + env_file.write_text("# TRIPO_API_KEY=\nTRIPO_API_KEY=private-test-value\n", encoding="utf-8") + env_file.chmod(0o600) + with patch.object(deploy, "execute", return_value=json.dumps(configuration())): + self.assertEqual(deploy.load_config(env_file, "https"), configuration()) + def test_proxy_replaces_forwarding_headers_for_verification_limits(self): routes = (DIRECTORY / "nginx" / "routes.conf").read_text(encoding="utf-8") self.assertEqual(routes.count('proxy_set_header Forwarded "";'), 2) diff --git a/prototype/src/services/catalog.ts b/prototype/src/services/catalog.ts index a6a0f1f..5ed0c6e 100644 --- a/prototype/src/services/catalog.ts +++ b/prototype/src/services/catalog.ts @@ -162,11 +162,20 @@ export interface UsageAuditPage { export interface AdminUsageSummary { callsToday: number callsThisMonth: number - waiting: number + waiting: number | null costToday: number costThisMonth: number series: Array<{ date: string; count: number }> - capacityGroups: Array<{ id: string; name: string; running: number; limit: number; queued: number }> + capacityGroups: Array<{ id: string; name: string; sourceLabel?: string; providerName?: string; mode?: string; routeEnabled?: boolean; running: number | null; limit: number; queued: number | null }> + running?: number | null + capacityConfig?: { + queueWaitMs: number + defaultModelConcurrency: number + defaultKeyConcurrency: number + asyncQueueLimit: number + asyncWorkerIntervalMs: number + synchronousSnapshotAvailable: boolean + } } export interface AdminCatalogUser { @@ -207,7 +216,7 @@ export interface AdminInvitation { export interface ChatCompletionResult { id: string model: string - choices: Array<{ message: { role: string; content: string }; finish_reason: string }> + choices: Array<{ message: { role: string; content?: string | null; reasoning_content?: string; reasoning?: string; [key: string]: unknown }; finish_reason?: string | null }> usage?: { prompt_tokens: number; completion_tokens: number; total_tokens: number } } diff --git a/prototype/src/services/model-catalog.ts b/prototype/src/services/model-catalog.ts index 9a80ef8..2c77ae2 100644 --- a/prototype/src/services/model-catalog.ts +++ b/prototype/src/services/model-catalog.ts @@ -1,4 +1,59 @@ -import type { CatalogModel, LogicalModel } from './catalog' +import type { CatalogModel, CatalogProvider, LogicalModel } from './catalog' + +export interface ModelCatalogSummary { + publishedModels: number + readyModels: number + readyRoutes: number + unpricedRoutes: number +} + +const capabilityLabels: Record = { + text: '文本', + code: '代码', + multimodal: '多模态', + image: '图像', + audio: '音频', + video: '视频', + embedding: '向量', + '3d': '3D', +} + +/** + * Build the compact capability text shown for a provider in the admin overview. + * A provider can expose hundreds of route rows, so this must deduplicate by + * capability and keep the rendered label bounded for the summary card. + */ +export function providerCapabilityLabel(types: string[]): string { + const labels = [...new Set(types.map(type => capabilityLabels[type.trim().toLowerCase()] || '其他').filter(Boolean))] + if (!labels.length) return '待配置能力' + if (labels.length <= 3) return labels.join(' · ') + return `${labels.slice(0, 3).join(' · ')} 等 ${labels.length} 类` +} + +export function summarizeModelCatalog( + definitions: LogicalModel[], + routes: CatalogModel[], + providers: CatalogProvider[], +): ModelCatalogSummary { + const publishedModelIds = new Set(definitions.filter(model => model.status === 'active').map(model => model.id)) + const activeProviderIds = new Set(providers.filter(provider => provider.status === 'active').map(provider => provider.id)) + const readyModelIds = new Set() + let readyRoutes = 0 + let unpricedRoutes = 0 + + for (const route of routes) { + if (route.status !== 'active' || !publishedModelIds.has(route.logicalModelId) || !activeProviderIds.has(route.providerId)) continue + if (route.pricingConfigured !== true) { + unpricedRoutes++ + continue + } + if (route.billingReady === false || route.executionReady === false) continue + readyRoutes++ + readyModelIds.add(route.logicalModelId) + } + + return { publishedModels: publishedModelIds.size, readyModels: readyModelIds.size, readyRoutes, unpricedRoutes } +} // Browse published definitions even when none of their routes are enabled yet. // Route IDs remain the exact authorization and invocation identifiers. diff --git a/prototype/src/views/AdminConsole.vue b/prototype/src/views/AdminConsole.vue index 2918e53..4f965e4 100644 --- a/prototype/src/views/AdminConsole.vue +++ b/prototype/src/views/AdminConsole.vue @@ -39,6 +39,9 @@ import SlidePanel from '../components/SlidePanel.vue' import UiModal from '../components/UiModal.vue' import CatalogAdmin from '../components/CatalogAdmin.vue' import AccountAdmin from '../components/AccountAdmin.vue' +import { providerCapabilityLabel, summarizeModelCatalog } from '../services/model-catalog' +import { usePagination } from '../composables/usePagination' +import ListPagination from '../components/ListPagination.vue' const props = defineProps<{ view: string; currentUser?: AuthUser }>() const emit = defineEmits<{ navigate: [view: string]; notify: [message: string] }>() @@ -47,6 +50,7 @@ const users = ref([]) const providers = ref([]) const models = ref([]) const publicModelCount = ref(0) +const publishedModelCount = ref(0) const publicRouteCount = ref(0) const unpricedRouteCount = ref(0) const adminSummary = ref(null) @@ -84,12 +88,11 @@ async function refreshOverviewData(notifyOnSuccess = false) { ]) providers.value = mapProviders(providerResult.providers, modelResult.models) models.value = mapModels(modelResult.models, providerResult.providers) - const activeProviders = new Set(providerResult.providers.filter((item) => item.status === 'active').map((item) => item.id)) - const activeDefinitions = new Set(modelResult.logicalModels.filter((item) => item.status === 'active').map((item) => item.id)) - const publishedRoutes = modelResult.models.filter((item) => item.status === 'active' && activeProviders.has(item.providerId) && activeDefinitions.has(item.logicalModelId) && item.pricingConfigured && item.billingReady !== false && item.executionReady !== false) - publicRouteCount.value = publishedRoutes.length - publicModelCount.value = new Set(publishedRoutes.map((item) => item.logicalModelId)).size - unpricedRouteCount.value = modelResult.models.filter((item) => item.status === 'active' && activeProviders.has(item.providerId) && activeDefinitions.has(item.logicalModelId) && !item.pricingConfigured).length + const catalogSummary = summarizeModelCatalog(modelResult.logicalModels, modelResult.models, providerResult.providers) + publishedModelCount.value = catalogSummary.publishedModels + publicRouteCount.value = catalogSummary.readyRoutes + publicModelCount.value = catalogSummary.readyModels + unpricedRouteCount.value = catalogSummary.unpricedRoutes adminSummary.value = summaryResult verificationChannels.value = verificationResult users.value = userResult.users.map(mapUser) @@ -194,10 +197,12 @@ function formatUsagePayload(value: unknown) { const queueGroups = computed(() => (adminSummary.value?.capacityGroups || []).map((group) => ({ ...group, - type: '模型分组', - wait: group.queued ? '排队中' : '—', - status: group.queued ? '保护中' : '正常', + type: `${group.providerName || '未知渠道'} · ${group.sourceLabel || '模型分组'}`, + status: group.running === null ? '未读取' : group.routeEnabled === false ? '已停用,仍有任务' : group.queued ? '排队中' : group.running ? '执行中' : '空闲', + warning: group.running === null || group.routeEnabled === false || !!group.queued, }))) +const { page: capacityPage, pageSize: capacityPageSize, pagedItems: capacityPageGroups } = usePagination(queueGroups) +const configuredCapacity = computed(() => adminSummary.value?.capacityGroups.filter(group => group.routeEnabled !== false).reduce((total, group) => total + group.limit, 0)) const pricing = computed(() => models.value.filter((model) => model.pricingConfigured).map((model) => ({ model: model.name, unit: model.pricing?.unit || 'CNY / 1M tokens', @@ -227,7 +232,7 @@ function mapProviders(items: CatalogProvider[], modelItems: CatalogModel[]): Pro return items.map((provider) => ({ id: provider.id, name: provider.name, - capability: modelItems.filter((model) => model.providerId === provider.id).map((model) => model.type).join(' / ') || '待配置能力', + capability: providerCapabilityLabel(modelItems.filter((model) => model.providerId === provider.id).map((model) => model.type)), models: modelItems.filter((model) => model.providerId === provider.id).length, latency: '未采样', successRate: '—', @@ -277,7 +282,7 @@ function mapModels(items: CatalogModel[], providersList: CatalogProvider[]): Mod
@@ -286,9 +291,15 @@ function mapModels(items: CatalogModel[], providersList: CatalogProvider[]): Mod